# Spielstand speichern



## stardust (14. Feb 2005)

HI  habe versucht das spiel mensch ärger dich nicht zu programmieren. hab auch einiges aus dem netz Das einzige was mir jetzt noch fehlt ist das ich meinen spielstand speichern kann und später weiter spielen kann.

Suche mich jetzt schon 2 tage blöd  kann mir einer von euch weiterhelfen? 

Brauch irgendwas zum speichern in eine datei und wieder zum lesen ....habe auch ein beispiel  hier im forum gefunden mit einem telefonbuch....hab das auch schon ausprobiert....aber in die datei werden nur diese ¬í p zeichen geschrieben 

es wäre wirklich sehr nett, wenn mir eines von euch helfen könnte 



hier der code von meiner klasse spiel.....



```
import java.awt.event.MouseEvent;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

import java.awt.*;
import java.util.*;
import java.io.*;

/**
 * Ein funktionales sowie grafisches Spiel(brett). Die funktionale Hauptklasse.
 */
public class Spiel extends JPanel implements ActionListener {
	private Feld[] feld;
	private Feld[][] startFeld, hausFeld;

	private Feld aktivesFeld, zielFeld;

	private Wuerfel wuerfel;
	private Spieler[] spieler;
	private JLabel[] name;

	private int aktiverSpieler;

	private GridBagConstraints c;
	private GridBagLayout layout;

	private JPanel steuerung;
	private JButton wuerfeln, ziehen;
	private JLabel status1, status2;
	private String sieger;

	private boolean dreimalWuerfeln;

	private MouseAdapter maus, maus2;
        
        private Vector stand;
        private String spielstanddatei = "./spielstand.txt";

	/**
	 * Erzeugt ein neues Spiel.
	 */
	public Spiel() {
		c = new GridBagConstraints();
		layout = new GridBagLayout();

		maus = new MouseAdapter() {
			public void mouseClicked(MouseEvent e) {
				if (((Feld) e.getSource()).getZustand() == aktiverSpieler
					&& !wuerfeln.isEnabled()
					&& SwingUtilities.isLeftMouseButton(e)) {
					if (!(((Feld) e.getSource()) == aktivesFeld)
						&& getZielFeldVon((Feld) e.getSource()) != null) {
						waehlen((Feld) e.getSource());
					} else if (aktivesFeld == e.getSource())
						ziehen();
				} else if (
					zielFeld == e.getSource()
						&& !wuerfeln.isEnabled()
						&& SwingUtilities.isLeftMouseButton(e)) {
					ziehen();
				} else if (
					wuerfeln.isEnabled()
						&& SwingUtilities.isRightMouseButton(e))
					wuerfeln();
			}
		};

		maus2 = new MouseAdapter() {
			public void mouseClicked(MouseEvent e) {
				if (wuerfeln.isEnabled()
					&& SwingUtilities.isRightMouseButton(e))
					wuerfeln();
			}
		};
		addMouseListener(maus2);

		feld = new Feld[40];
		for (int i = 0; i < 40; i++) {
			feld[i] = new Feld();
			feld[i].setPreferredSize(getFeldgröße());
			feld[i].addMouseListener(maus);
		}

		startFeld = new Feld[4][4];
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				startFeld[i][j] = new Feld(i, i);
				startFeld[i][j].setPreferredSize(getFeldgröße());
			}
		}

		hausFeld = new Feld[4][4];
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				hausFeld[i][j] = new Feld(i);
				hausFeld[i][j].setPreferredSize(getFeldgröße());
				hausFeld[i][j].addMouseListener(maus);
			}
		}

		spieler = new Spieler[4];
		for (int i = 0; i < 4; i++)
			spieler[i] = null;

		name = new JLabel[4];
		name[0] = new JLabel("", JLabel.LEFT);
		name[1] = new JLabel("", JLabel.RIGHT);
		name[2] = new JLabel("", JLabel.RIGHT);
		name[3] = new JLabel("", JLabel.LEFT);
		for (int i = 0; i < 4; i++)
			name[i].setForeground(Color.GRAY);

		steuerung = new JPanel(new GridBagLayout());
		wuerfeln = new JButton("würfeln");
		wuerfel = new Wuerfel();
		ziehen = new JButton("ziehen");

		wuerfeln.setMnemonic('w');
		wuerfeln.addActionListener(this);
		wuerfeln.addMouseListener(maus2);
		wuerfeln.setActionCommand("würfeln");

		wuerfel.setPreferredSize(getFeldgröße());

		ziehen.setMnemonic('z');
		ziehen.addActionListener(this);
		ziehen.addMouseListener(maus2);
		ziehen.setActionCommand("ziehen");
		ziehen.setEnabled(false);

		status1 = new JLabel(" ", JLabel.RIGHT);
		status1.setOpaque(true);
		status2 = new JLabel(" ");
		status2.setOpaque(true);

		sieger = "";

		setLayout(layout);
		setBackground(Color.YELLOW);
	}

	/**
	 * Reagiert auf die Betätigung des Buttons "würfeln" oder "ziehen". Ruft 
	 * entsprechend die Methode <code>wuerfeln()</code> oder <code>ziehen()</code> 
	 * auf.
	 * @param e die ausgelöste Aktion
	 * @see #wuerfeln
	 * @see #ziehen
	 */
	public void actionPerformed(ActionEvent e) {
		if ("würfeln".equals(e.getActionCommand())) {
			wuerfeln();
		} else if ("ziehen".equals(e.getActionCommand()))
			ziehen();
	}

	/**
	 * Fügt dem Spiel eine Komponente hinzu. Diese wird mit der jeweiligen 
	 * Position, Ausdehnung und Füllart in das <code>GridBagLayout</code>-Gitter 
	 * eingefügt. 
	 * @param komponente die einzufügene Komponente
	 * @param x x-Position im Gitter
	 * @param y y-Position im Gitter
	 * @param breite Anzahl der zu füllenden Zellen (horizontal)
	 * @param höhe Anzahl der zu füllenden Zellen (vertikal)
	 * @param fill Füllmodus
	 */
	public void add(
		Component komponente,
		int x,
		int y,
		int breite,
		int höhe,
		int fill) {
		c.gridx = x;
		c.gridy = y;
		c.gridwidth = breite;
		c.gridheight = höhe;
		c.fill = fill;
		layout.setConstraints(komponente, c);
		add(komponente);
	}

	/**
	 * Fügt einem Kontainer eine Komponente hinzu. Diese wird mit der jeweiligen 
	 * Position, Ausdehnung und Füllart in das <code>GridBagLayout</code>-Gitter 
	 * eingefügt. 
	 * @param komponente die einzufügene Komponente
	 * @param kontainer der Kontainer, in den die Komponente eingefügt wird
	 * @param x x-Position im Gitter
	 * @param y y-Position im Gitter
	 * @param breite Anzahl der zu füllenden Zellen (horizontal)
	 * @param höhe Anzahl der zu füllenden Zellen (vertikal)
	 * @param fill Füllmodus
	 */
	public void add(
		Component komponente,
		Container kontainer,
		int x,
		int y,
		int breite,
		int höhe,
		int fill) {
		c.gridx = x;
		c.gridy = y;
		c.gridwidth = breite;
		c.gridheight = höhe;
		c.fill = fill;
		layout.setConstraints(komponente, c);
		kontainer.add(komponente);
	}

	/**
	 * Überprüft ob es dem aktuellen Spieler möglich ist zu ziehen.
	 * @return <code>true</code> wenn der Spieler keine Zugmöglichkeit hat, sonst 
	 * <code>false</code>
	 */
	public boolean aussetzen() {
		if (!isStartVoll()) {
			for (int i = 0; i < 40; i++)
				if (feld[i].getZustand() == aktiverSpieler) {
					if (getZielFeldVon(feld[i]) != null) {
						return false;
					}
				}
			for (int i = 0; i < 4; i++)
				if (hausFeld[aktiverSpieler][i].getZustand()
					== aktiverSpieler) {
					if (getZielFeldVon(hausFeld[aktiverSpieler][i]) != null) {
						return false;
					}
				}
		} else
			return false;
		return true;
	}

	/**
	 * Fügt einen neuen computergesteuerten Mitspieler dem Spiel hinzu.
	 * @param nr Spielernummer
	 * @param name Name des Spielers
	 * @param verzögerung zeitliche Verzögerung zwischen den Aktionen dieses Spielers
	 */
	public void computerErstellen(int nr, String name, long verzögerung) {
		this.spieler[nr] = new Computer(name, nr, verzögerung, this);
		this.name[nr].setText(name);
	}

	/**
	 * Liefert die Nummer des aktuellen Spielers.
	 * @return die Nummer des aktuellen Spielers
	 */
	public int getAktiverSpieler() {
		return aktiverSpieler;
	}

	/**
	 * Liefert das momentan aktive Feld. Dieses ist immer mit einer Spielfigur des 
	 * aktuellen Spielers besetzt.
	 * @return das momentan aktive Feld
	 */
	public Feld getAktivesFeld() {
		return aktivesFeld;
	}

	/**
	 * Liefert das der übergebenen Nummer entsprechende Spielfeld.
	 * @param i Nummer des Feldes
	 * @return das der Nummer entsprechende Spielfeld
	 */
	public Feld getFeld(int i) {
		return feld[i];
	}

	/**
	 * Berechnet und liefert eine der Bildschirmauflösung entsprechende Größe für die
	 * Spielfelder.
	 * @return die Größe für die Spielfelder
	 */
	public Dimension getFeldgröße() {
		int höhe =
			(int) Toolkit.getDefaultToolkit().getScreenSize().getHeight();

		if (höhe < 1024)
			if (höhe < 768)
				if (höhe < 600)
					höhe = 20;
				else
					höhe = 30;
			else
				höhe = 40;
		else
			höhe = 50;

		return new Dimension(höhe, höhe);
	}

	/**
	 * Liefert das der übergebenen Spielernummer und Nummer entsprechende 
	 * "Haus"-Feld.
	 * @param i Spielernummer
	 * @param j Nummer des Feldes
	 * @return das der Nummer entsprechende Spielfeld
	 */
	public Feld getHausFeld(int i, int j) {
		return hausFeld[i][j];
	}

	/**
	 * Liefert den aktuellen Zustand des Spiels. Diese ist 'a' wenn der aktuelle 
	 * Spieler würfeln muss, 'b' wenn eine Figur gewählt und 'c' wenn 
	 * gezogen oder eine andere Figur gewählt werden muss.
	 * @return die Spielphase
	 */
	public char getPhase() {
		if (wuerfeln.isEnabled() && !ziehen.isEnabled())
			return 'a';
		else if (!wuerfeln.isEnabled() && !ziehen.isEnabled())
			return 'b';
		else
			return 'c';
	}

	/**
	 * Liefert den der übergebenen Nummer entsprechenden Spieler.
	 * @param nr Spielernummer
	 * @return der der Nummer entsprechende Spieler
	 */
	public Spieler getSpieler(int nr) {
		return spieler[nr];
	}

	/**
	 * Liefert den "ziehen"-Button.
	 * @return der "ziehen"-Button
	 */
	public JButton getZiehen() {
		return ziehen;
	}

	/**
	 * Berechnet das Zielfeld des übergebenen Feldes nach der Augenzahl. Falls kein 
	 * Zielfeld existiert oder frei ist wird <code>null</code> zurückgegeben. 
	 * @param feld das Feld, von welchem das Zielfeld berechnet werden soll
	 * @return das berechnete Zielfeld
	 */
	public Feld getZielFeldVon(Feld feld) {
		for (int i = 0; i < 40; i++) {
			if (this.feld[i] == feld) {
				if (i + wuerfel.getAugen()
					>= spieler[aktiverSpieler].getStart()
					&& i < spieler[aktiverSpieler].getStart()) {
					if ((wuerfel.getAugen()
						- ((spieler[aktiverSpieler].getStart()) - i))
						< 4
						&& hausFeld[aktiverSpieler][wuerfel.getAugen()
							- ((spieler[aktiverSpieler]).getStart() - i)]
								.getZustand()
							!= aktiverSpieler)
						return hausFeld[aktiverSpieler][wuerfel.getAugen()
							- ((spieler[aktiverSpieler].getStart()) - i)];
				} else if (i + wuerfel.getAugen() > 39) {
					if (spieler[aktiverSpieler].getStart() == 0) {
						if (wuerfel.getAugen() - (40 - i) < 4
							&& hausFeld[aktiverSpieler][wuerfel.getAugen()
								- (40 - i)].getZustand()
								!= aktiverSpieler)
							return hausFeld[aktiverSpieler][wuerfel.getAugen()
								- (40 - i)];
					} else if (
						this.feld[wuerfel.getAugen() - (40 - i)].getZustand()
							!= aktiverSpieler)
						return this.feld[wuerfel.getAugen() - (40 - i)];
				} else if (
					this.feld[i + wuerfel.getAugen()].getZustand()
						!= aktiverSpieler) {
					return this.feld[i + wuerfel.getAugen()];
				}
			} else if (
				(i < 4)
					&& (hausFeld[aktiverSpieler][i] == feld)
					&& (i + wuerfel.getAugen() < 4)
					&& (hausFeld[aktiverSpieler][i
						+ wuerfel.getAugen()].getZustand()
						!= aktiverSpieler))
				return hausFeld[aktiverSpieler][i + wuerfel.getAugen()];
		}
		return null;
	}

	/**
	 * Überprüft, ob der aktuelle Spieler gewonnen hat.
	 * @return <code>true</code> wenn der aktuelle Spieler gewonnen hat, sonst 
	 * <code>false</code>
	 */
	public boolean gewonnen() {
		if (spieler[aktiverSpieler] != null) {
			boolean gewonnen = true;
			for (int i = 0; i < 4; i++)
				if (hausFeld[aktiverSpieler][i].getZustand() != aktiverSpieler)
					gewonnen = false;
			return gewonnen;
		} else
			return false;
	}

	/**
	 * Positioniert und fügt alle Komponenten dem Spiel hinzu.
	 */
	public void hinzufügen() {
		c.insets = new Insets(2, 2, 2, 2);

		if (spieler[0] != null) {
			feld[0].setSpieler(0);

			add(startFeld[0][0], 0, 0, 1, 1, GridBagConstraints.NONE);
			add(startFeld[0][1], 1, 0, 1, 1, GridBagConstraints.NONE);
			add(startFeld[0][2], 1, 1, 1, 1, GridBagConstraints.NONE);
			add(startFeld[0][3], 0, 1, 1, 1, GridBagConstraints.NONE);

			add(name[0], 1, 2, 3, 1, GridBagConstraints.BOTH);

			add(hausFeld[0][0], 1, 5, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[0][1], 2, 5, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[0][2], 3, 5, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[0][3], 4, 5, 1, 1, GridBagConstraints.NONE);
		}
		if (spieler[1] != null) {
			feld[10].setSpieler(1);

			add(startFeld[1][0], 9, 0, 1, 1, GridBagConstraints.NONE);
			add(startFeld[1][1], 10, 0, 1, 1, GridBagConstraints.NONE);
			add(startFeld[1][2], 10, 1, 1, 1, GridBagConstraints.NONE);
			add(startFeld[1][3], 9, 1, 1, 1, GridBagConstraints.NONE);

			add(name[1], 7, 2, 3, 1, GridBagConstraints.BOTH);

			add(hausFeld[1][0], 5, 1, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[1][1], 5, 2, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[1][2], 5, 3, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[1][3], 5, 4, 1, 1, GridBagConstraints.NONE);
		}
		if (spieler[2] != null) {
			feld[20].setSpieler(2);

			add(startFeld[2][0], 9, 9, 1, 1, GridBagConstraints.NONE);
			add(startFeld[2][1], 10, 9, 1, 1, GridBagConstraints.NONE);
			add(startFeld[2][2], 10, 10, 1, 1, GridBagConstraints.NONE);
			add(startFeld[2][3], 9, 10, 1, 1, GridBagConstraints.NONE);

			add(name[2], 7, 8, 3, 1, GridBagConstraints.BOTH);

			add(hausFeld[2][0], 9, 5, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[2][1], 8, 5, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[2][2], 7, 5, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[2][3], 6, 5, 1, 1, GridBagConstraints.NONE);
		}
		if (spieler[3] != null) {
			feld[30].setSpieler(3);

			add(startFeld[3][0], 0, 9, 1, 1, GridBagConstraints.NONE);
			add(startFeld[3][1], 1, 9, 1, 1, GridBagConstraints.NONE);
			add(startFeld[3][2], 1, 10, 1, 1, GridBagConstraints.NONE);
			add(startFeld[3][3], 0, 10, 1, 1, GridBagConstraints.NONE);

			add(name[3], 1, 8, 3, 1, GridBagConstraints.BOTH);

			add(hausFeld[3][0], 5, 9, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[3][1], 5, 8, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[3][2], 5, 7, 1, 1, GridBagConstraints.NONE);
			add(hausFeld[3][3], 5, 6, 1, 1, GridBagConstraints.NONE);
		}

		add(wuerfel, 5, 5, 1, 1, GridBagConstraints.NONE);

		add(feld[0], 0, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[1], 1, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[2], 2, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[3], 3, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[4], 4, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[5], 4, 3, 1, 1, GridBagConstraints.NONE);
		add(feld[6], 4, 2, 1, 1, GridBagConstraints.NONE);
		add(feld[7], 4, 1, 1, 1, GridBagConstraints.NONE);
		add(feld[8], 4, 0, 1, 1, GridBagConstraints.NONE);
		add(feld[9], 5, 0, 1, 1, GridBagConstraints.NONE);
		add(feld[10], 6, 0, 1, 1, GridBagConstraints.NONE);
		add(feld[11], 6, 1, 1, 1, GridBagConstraints.NONE);
		add(feld[12], 6, 2, 1, 1, GridBagConstraints.NONE);
		add(feld[13], 6, 3, 1, 1, GridBagConstraints.NONE);
		add(feld[14], 6, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[15], 7, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[16], 8, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[17], 9, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[18], 10, 4, 1, 1, GridBagConstraints.NONE);
		add(feld[19], 10, 5, 1, 1, GridBagConstraints.NONE);
		add(feld[20], 10, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[21], 9, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[22], 8, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[23], 7, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[24], 6, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[25], 6, 7, 1, 1, GridBagConstraints.NONE);
		add(feld[26], 6, 8, 1, 1, GridBagConstraints.NONE);
		add(feld[27], 6, 9, 1, 1, GridBagConstraints.NONE);
		add(feld[28], 6, 10, 1, 1, GridBagConstraints.NONE);
		add(feld[29], 5, 10, 1, 1, GridBagConstraints.NONE);
		add(feld[30], 4, 10, 1, 1, GridBagConstraints.NONE);
		add(feld[31], 4, 9, 1, 1, GridBagConstraints.NONE);
		add(feld[32], 4, 8, 1, 1, GridBagConstraints.NONE);
		add(feld[33], 4, 7, 1, 1, GridBagConstraints.NONE);
		add(feld[34], 4, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[35], 3, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[36], 2, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[37], 1, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[38], 0, 6, 1, 1, GridBagConstraints.NONE);
		add(feld[39], 0, 5, 1, 1, GridBagConstraints.NONE);

		c.insets = new Insets(0, 0, 0, 0);
		add(wuerfeln, 0, 11, 5, 1, GridBagConstraints.BOTH);
		JButton bar = new JButton();
		bar.setEnabled(false);
		add(bar, 5, 11, 1, 1, GridBagConstraints.BOTH);
		add(ziehen, 6, 11, 5, 1, GridBagConstraints.BOTH);
		add(status1, 0, 12, 5, 1, GridBagConstraints.HORIZONTAL);
		JLabel space = new JLabel(":", JLabel.CENTER);
		space.setOpaque(true);
		add(space, 5, 12, 1, 1, GridBagConstraints.BOTH);
		add(status2, 6, 12, 5, 1, GridBagConstraints.HORIZONTAL);
	}

	/**
	 * Überprüft ob alle Startfelder des aktuellen Spielers unbesetzt sind.
	 * @return <code>true</code> wenn die Startfelder unbesetzt sind, sonst 
	 * <code>false</code>
	 */
	public boolean isStartLeer() {
		boolean isStartLeer = true;
		for (int i = 0; i < 4; i++)
			if (startFeld[aktiverSpieler][i].getZustand() == aktiverSpieler)
				isStartLeer = false;
		return isStartLeer;
	}

	/**
	 * Überprüft ob alle Startfelder des aktuellen Spielers besetzt sind.
	 * @return <code>true</code> wenn die Startfelder besetzt sind, sonst 
	 * <code>false</code>
	 */
	public boolean isStartVoll() {
		boolean isStartVoll = true;
		for (int i = 0; i < 4; i++)
			if (startFeld[aktiverSpieler][i].getZustand() != aktiverSpieler)
				isStartVoll = false;
		return isStartVoll;
	}

	/**
	 * Überprüft ob der aktuelle Spieler unabhängig vom Würfelergebnis ziehen kann.
	 * @return <code>true</code> wenn der aktuelle Spieler ziehen kann, sonst 
	 * <code>false</code>
	 */
	public boolean kannZiehen() {
		if (!isStartLeer()) {
			int x = 0;
			for (int i = 0; i < 4; i++)
				if (startFeld[aktiverSpieler][i].getZustand()
					!= aktiverSpieler)
					x++;
			for (int i = 3; i > 3 - x; i--)
				if (hausFeld[aktiverSpieler][i].getZustand() != aktiverSpieler)
					return true;
			return false;
		} else
			return true;
	}

	/**
	 * Nimmt den nächsten Spieler an die Reihe. Ist der nächste Spieler ein 
	 * computergesteuerter Spieler wird dieser zum ziehen aufgefordert. Sollte der 
	 * aktuelle Spieler gewonnen haben wird ein Dialog mit dieser Nachricht 
	 * angezeigt. Sollte dann nurnoch ein Mitspieler im Spiel sein wird hier die 
	 * Partie beendet.
	 */
	public void nächsterSpieler() {
		if (gewonnen()) {
			if (sieger.equals(""))
				sieger =
					spieler[aktiverSpieler].getName() + " ist erster Sieger";
			JOptionPane.showMessageDialog(
				this,
				spieler[aktiverSpieler].getName() + " hat gewonnen!",
				"Herzlichen Glückwunsch",
				JOptionPane.INFORMATION_MESSAGE);
			feld[spieler[aktiverSpieler].getStart()].setSpieler(4);
			spieler[aktiverSpieler] = null;
			name[aktiverSpieler].setForeground(Color.GRAY);
			name[aktiverSpieler].setFont(
				new Font(
					name[aktiverSpieler].getFont().getName(),
					Font.ITALIC,
					name[aktiverSpieler].getFont().getSize()));
			for (int i = 0; i < 4; i++) {
				startFeld[aktiverSpieler][i].setBlank(true);
				hausFeld[aktiverSpieler][i].removeMouseListener(maus);
			}
		}
		int anzahl = 0;
		for (int i = 0; i < 4; i++)
			if (spieler[i] != null)
				anzahl++;
		if (anzahl < 2) {
			for (int i = 0; i < 40; i++)
				feld[i].removeMouseListener(maus);
			wuerfeln.setEnabled(false);
			ziehen.setEnabled(false);
			status1.setText(" Partie beendet");
			status2.setText(sieger);
		} else {
			if (spieler[aktiverSpieler] != null)
				name[aktiverSpieler].setForeground(Color.GRAY);
			if (aktiverSpieler == 3) {
				aktiverSpieler = 0;
				if (spieler[0] == null)
					nächsterSpieler();
				else {
					name[aktiverSpieler].setForeground(Color.BLACK);
					wuerfel.setAktiv(false);
					wuerfeln.setEnabled(true);
					spieler[aktiverSpieler].setWuerfe(0);

					if (!spieler[aktiverSpieler].isMensch())
						 ((Computer) spieler[aktiverSpieler]).ziehen();
				}
			} else {
				aktiverSpieler++;
				if (spieler[aktiverSpieler] == null)
					nächsterSpieler();
				else {
					name[aktiverSpieler].setForeground(Color.BLACK);
					wuerfel.setAktiv(false);
					wuerfeln.setEnabled(true);
					spieler[aktiverSpieler].setWuerfe(0);

					if (!spieler[aktiverSpieler].isMensch())
						 ((Computer) spieler[aktiverSpieler]).ziehen();
				}
			}
		}
		update();
	}

	/**
	 * Lässt das übergebene Feld zum aktiven Feld werden.
	 * @param aktivesFeld das neue aktive Feld
	 */
	public void setAktivesFeld(Feld aktivesFeld) {
		this.aktivesFeld = aktivesFeld;
	}

	/**
	 * (De-)Aktiviert die "Dreimal Würfeln"-Regel.
	 * @param dreimalWuerfeln <code>true</code> zum aktivieren, sonst 
	 * <code>false</code>
	 */
	public void setDreimalWürfeln(boolean dreimalWuerfeln) {
		this.dreimalWuerfeln = dreimalWuerfeln;
	}

	/**
	 * Fügt einen neuen benutzergesteuerten Mitspieler dem Spiel hinzu.
	 * @param nr Spielernummer
	 * @param name Name des Spielers
	 */
	public void spielerErstellen(int nr, String name) {
		this.spieler[nr] = new Spieler(name, nr);
		this.name[nr].setText(name);
	}

	/**
	 * Startet die Partie.
	 */
	public void starten() {
		aktiverSpieler = 3;
		nächsterSpieler();
	}

	/**
	 * Aktualisiert das Spielbrett und die Statusleiste.
	 */
	public void update() {
		for (int i = 0; i < 40; i++) {
			if (feld[i] == aktivesFeld || feld[i] == zielFeld)
				feld[i].repaint(true);
			else
				feld[i].repaint(false);
		}
		for (int i = 0; i < 4; i++)
			for (int j = 0; j < 4; j++) {
				startFeld[i][j].repaint();
				if (hausFeld[i][j] == aktivesFeld
					|| hausFeld[i][j] == zielFeld)
					hausFeld[i][j].repaint(true);
				else
					hausFeld[i][j].repaint(false);
			}
		wuerfel.repaint();
		if (spieler[aktiverSpieler] != null) {
			status1.setText(spieler[aktiverSpieler].getName() + " ");
			switch (getPhase()) {
				case 'a' :
					status2.setText(" Würfeln");
					break;
				case 'b' :
					status2.setText(" Figur wählen");
					break;
				case 'c' :
					status2.setText(" Ziehen oder andere Figur wählen");
					break;
			}
		}
                 speicherSpiel(spielstanddatei);
	}

	/**
	 * Aktiviert das übergebene Feld, berechnet dessen Zielfeld und markiert diese.
	 * @param feld das zu aktivierende Feld
	 */
	public void waehlen(Feld feld) {
		aktivesFeld = feld;
		zielFeld = getZielFeldVon(aktivesFeld);
		ziehen.setEnabled(true);
		update();
	}

	/**
	 * Würfelt. Falls es nur eine Zugmöglichkeit gibt wird automatisch gezogen.
	 */
	public void wuerfeln() {
		wuerfel.wuerfeln();
		wuerfel.setAktiv(true);

		int x = 0;
		Feld figur = null;
		for (int i = 0; i < 40; i++)
			if (feld[i].getZustand() == aktiverSpieler)
				if (getZielFeldVon(feld[i]) != null) {
					x++;
					figur = feld[i];
				}
		for (int i = 0; i < 4; i++)
			if (hausFeld[aktiverSpieler][i].getZustand() == aktiverSpieler)
				if (getZielFeldVon(hausFeld[aktiverSpieler][i]) != null) {
					x++;
					figur = hausFeld[aktiverSpieler][i];
				}

		if (dreimalWuerfeln
			&& spieler[aktiverSpieler].getWuerfe() < 2
			&& !kannZiehen()
			&& wuerfel.getAugen() != 6) {
			wuerfel.setAktiv(false);
			wuerfeln.setEnabled(true);
			spieler[aktiverSpieler].setWuerfe(
				spieler[aktiverSpieler].getWuerfe() + 1);
		} else if (aussetzen() && wuerfel.getAugen() != 6) {
			nächsterSpieler();
		} else {
			wuerfeln.setEnabled(false);
			if ((wuerfel.getAugen() == 6)
				&& (feld[spieler[aktiverSpieler].getStart()].getZustand()
					!= aktiverSpieler)
				&& !isStartLeer()) {
				for (int i = 0; i < 4; i++)
					if (startFeld[aktiverSpieler][i].getZustand()
						== aktiverSpieler) {
						aktivesFeld = startFeld[aktiverSpieler][i];
						zielFeld = feld[spieler[aktiverSpieler].getStart()];
						ziehen();
						i = 4;
					}
				wuerfeln.setEnabled(true);
			} else if (
				!isStartLeer()
					&& feld[spieler[aktiverSpieler].getStart()].getZustand()
						== aktiverSpieler
					&& getZielFeldVon(feld[spieler[aktiverSpieler].getStart()])
						!= null) {
				aktivesFeld = feld[spieler[aktiverSpieler].getStart()];
				zielFeld = getZielFeldVon(aktivesFeld);
				ziehen();
			} else if (isStartVoll()) {
				nächsterSpieler();
			} else if (x == 1) {
				aktivesFeld = figur;
				zielFeld = getZielFeldVon(aktivesFeld);
				ziehen();
			} else if (aussetzen() && wuerfel.getAugen() == 6) {
				wuerfel.setAktiv(false);
				wuerfeln.setEnabled(true);
			}
		}
		update();
	}

	/**
	 * Zieht die ausgewählte Spielfigur.
	 */
	public void ziehen() {
		if (zielFeld.getZustand() != 4)
			for (int i = 3; i >= 0; i--)
				if (startFeld[zielFeld.getZustand()][i].getZustand() == 4) {
					startFeld[zielFeld.getZustand()][i].setZustand(
						zielFeld.getZustand());
					i = 0;
				}
		zielFeld.setZustand(aktivesFeld.getZustand());
		zielFeld = null;
		aktivesFeld.setZustand(4);
		aktivesFeld = null;
		ziehen.setEnabled(false);
		if (wuerfel.getAugen() != 6)
			nächsterSpieler();
		else
			wuerfeln.setEnabled(true);
		wuerfel.setAktiv(false);
		update();
	}
        
          /**
         *Speichern in Datei
         *
         */
        private void speicherSpiel(String datei)
        {
            try
            {
                ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(datei));
		out.writeObject(stand);
            }
	catch (Exception e)
        {
            e.printStackTrace();            
        }
        }
}
```


----------



## Jockel (14. Feb 2005)

Irgendwie finde ich den Teil nicht, wo Du den Spielstand wieder aus der Datei ausliest... Es kann dir doch egal sein, wie das Objekt in der Datei nachher aussieht, solange das gewünschte Ergebniss kommt.

PS: es hilft, wenn du nur den nötigen Code postest... ich wage es zu bezweifeln, dass die Leute großartig Lust haben, soviel Code durchzulesen, wo eigentlich nur ein paar wenige Zeilen signifikant sind.


----------



## Java Lover (14. Feb 2005)

also erstma muss ich meinem vorredner mal recht geben, ist doch vollkommen egal wie die datei dann nach dem speichern aussieht, aber an deiner stelle würde ich einen objectoutputstream in einen bytearrayoutputstream reinpacken (einfach beim erzeugen in den konstuktor) und dann den bytarrayoutputstream in ein bytearray knovertieren mit bytearrayoutputstream.toByteArray().
diesen kannst du dann direkt in einen fileoutputstream schreiben schon haste die datei gespeichert und beim laden gehts genauso nur andersrum.


----------



## Beni (14. Feb 2005)

Ich möchte meinem Vorredner nicht widersprechen, aber ich würde den ObjectOutputStream direkt in einen FileOutputStream leiten (im Konstruktor kann man das angeben), und mir die mühe mit dem ByteArray sparen ;-)


----------



## Java Lover (14. Feb 2005)

hab grad dein letzten fitzel endeckt *g*
der sollte aber soweit ich weiß andersherum sein
also bspweise...


```
byte[] = data;
baos = new ByteArrayOutputStream();

oos = new ObjectOutputStream(oos);
oos.write(dein spielstand);
oos.flush();

data = baos.toByteArray();

oos.close();
baos.close();

fos = new FileOutputStream(dateipfad);
fos.write(data);
fos.close();
```

schon sollte das irgendwie passen *g* teste halt ma aus

_Code Tags eingefügt / Stefan1200_


----------



## Java Lover (14. Feb 2005)

ok benni hast recht, is ja soooo einfach *lol*
so denn viel spaß damit


----------



## Beni (14. Feb 2005)

Also sorry Java Lover, aber jetzt machst dus echt kompliziert

```
FileOutputStream out = new FileOutputStream( "dateiname" );
ObjectOutputStream objectOut = new ObjectOutputStream( out );

objectOut.writeObject( deinSpielstand );

objectOut.close();
```

Lesen ist dann später:

```
ObjectInputStream in = new ObjectInputStream( new FileInputStream( "dateiname" ));

// unter der Annahme, dass "deinSpielstand" vom Typ ArrayList ist:
deinSpielstand = (ArrayList)in.readObject(); 

in.close();
```

[Edit: Mist, zu spät  :bae: ]


----------



## stardust (20. Feb 2005)

Hey  

schon mal Vielen Dank für eure hilfe und sorry wegen dem langen Code.

Ich habe das mal ausprobiert...habe aber noch ein paar probleme auch vom verständnis her 

Also zum speichern benutze ich jetzt folgendes:


```
private Vector stand;      // kann das sein das ich hier was anderes nehmen sollte? Hab Vector genommen das es hier in einem andere Bsp. Telefonbuch benutzt worden ist

Bin leider nicht der beste programmierer und muss noch viel lernen  :) 

 private void speicherSpiel(String datei)
        {
                                
            try
            {
                FileOutputStream out = new FileOutputStream( "spielstand.txt" ); 
                ObjectOutputStream objectOut = new ObjectOutputStream(out);
		objectOut.writeObject(stand);
                objectOut.close();
            }
	catch (Exception e)
        {
            e.printStackTrace();            
        }
        }
```

Das nächste problem das ich habe ist beim öffnen...wie muss ich dann mein Spielstand definieren?

private ArrayList stand; ??? 


```
ObjectInputStream in = new ObjectInputStream( new FileInputStream( "spielstand.txt" )); 

// unter der Annahme, dass "deinSpielstand" vom Typ ArrayList ist: 
stand = (ArrayList)in.readObject(); 

in.close();
```


so und wenn ich jetzt also wieder alles in "stand" drin stehen habe....wie mache ich das denn das wieder jeder wert der in stand gespeichert ist, der jeweiligen variable zugeordnet wird?

Wie ihr seht bin ich noch sehr unerfahren  aber ich hoffe das sich das bald ändert *g*


----------

