Hallo Freunde, bin bei der letzten Frage stecken geblieben . Ich muß in dieser Applikation allle nocht
nicht umgedrehte Karten mit" Alles Aufdecken " button aufmachen.
Ich habe einen Button gemachtt "Alles Aufdecken" .
Eine Methode " aufdecken()" geschrieben der alle Karten umdrehen soll , nur es funktionert nicht . Wie kann ich weiter kommen ?
nicht umgedrehte Karten mit" Alles Aufdecken " button aufmachen.
Ich habe einen Button gemachtt "Alles Aufdecken" .
Eine Methode " aufdecken()" geschrieben der alle Karten umdrehen soll , nur es funktionert nicht . Wie kann ich weiter kommen ?
Code:
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Collections;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;
public class MemoryFeld extends JFrame {
// eine inner Klasse für den timer
class TimerListener implements ActionListener {
@Override
// die methode ruft die methode karteschliessen auf
public void actionPerformed(ActionEvent e) {
karteSchliessen();
}
}
------------------------------------------------------------------------------------------------------------------------------------
class ButtonListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("Alles Aufdecken"))
;
aufdecken();
}
--------------------------------------------------------------------------------------------------------------------------------------
//das Array für die Karten
private MemoryKarte[] karten;
//das Array für die Namen der Grafiken
private String[] bilder = { "grafiken/apfel.jpg", "grafiken/birne.jpg",
"grafiken/blume.jpg", "grafiken/blume2.jpg", "grafiken/ente.jpg",
"grafiken/fisch.jpg", "grafiken/fuchs.jpg", "grafiken/igel.jpg",
"grafiken/kaenguruh.jpg", "grafiken/katze.jpg", "grafiken/kuh.jpg",
"grafiken/maus1.jpg", "grafiken/maus2.jpg", "grafiken/maus3.jpg",
"grafiken/melone.jpg", "grafiken/pilz.jpg", "grafiken/ronny.jpg",
"grafiken/schmetterling.jpg", "grafiken/sonne.jpg",
"grafiken/wolke.jpg", "grafiken/maus4.jpg" };
//für die Punkte
private int menschPunkte, computerPunkte;
public String anzeige = "Es Zieht der Mensch";
public String anzeige1 = "Es Zieht der Computer";
//zwei Labels für die Punkte
private JLabel menschPunkteLabel, computerPunkteLabel, anzeigeLabel;
private JButton aufdecken;
//wie viele Karten sind aktuell umgedreht?
private int umgedrehteKarten;
//für das aktuell umdrehte Paar
private MemoryKarte[] paar;
//für den aktuellen Spieler
private int spieler;
// für den Timer
private Timer timer;
//das "Gedächtnis" für den Computer
//er speichert hier wo das Gegenstück liegt
private int[][] gemerkteKarten;
//für die Spielstärke
private int spielstaerke;
//der Konstruktor
//er erzeugt das Spielfeld mit den Karten und die Oberfläche
public MemoryFeld(String titel) {
super(titel);
//das Array für die Karten erstellen, insgesamt 42 Stück
karten = new MemoryKarte[42];
//für das Paar
paar = new MemoryKarte[2];
//für das Gedächtnis
//es speichert für jede Karte paarweise die Position im Spielfeld
gemerkteKarten = new int[2][21];
//keiner hat zu Beginn einen Punkt
menschPunkte = 0;
computerPunkte = 0;
//es ist keine Karte umgedreht
umgedrehteKarten = 0;
//der Mensch fängt an
spieler = 0;
// spielstärke setzen
spielstaerke = 10;
//es gibt keine gemerkten Karten
for (int aussen = 0; aussen < 2; aussen++)
for (int innen = 0; innen < 21; innen++)
gemerkteKarten[aussen][innen] = -1;
//die Oberfläche erstellen
initGUI();
//eine neue Instanz erstellen, der Timer soll alle 2 Sekunden ausgelöst werden
timer = new Timer(2000, new TimerListener());
//in unserem Spiel soll er aber nur einmal ausgeführt werden
timer.setRepeats(false);
//Größe setzen, keine Größenänderungen zulassen, Standard-Verhalten festlegen und anzeigen
setSize(405, 565);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
--------------------------------------------------------------------------------------------------------------------------------------
public void aufdecken() {
bildVorne = new ImageIcon(vorne)
}
--------------------------------------------------------------------------------------------------------------------------------------
//die Methode erstellt die Oberfläche und zeichnet die Karten
private void initGUI() {
//das Layout setzen
setLayout(new FlowLayout(FlowLayout.LEFT));
//ein Panel für das eigentliche Spielfeld
JPanel feld = new JPanel();
//das Panel bekommt ein Gridlayout mit 7 Zeilen
feld.setLayout(new GridLayout(7, 0));
//die Karten erstellen und zeichnen
kartenZeichnen(feld);
add(feld);
//für die Ausgaben
JPanel ausgabe = new JPanel();
aufdecken = new JButton("Alles Aufdecken");
anzeigeLabel = new JLabel();
menschPunkteLabel = new JLabel();
computerPunkteLabel = new JLabel();
menschPunkteLabel.setText(Integer.toString(menschPunkte));
computerPunkteLabel.setText(Integer.toString(computerPunkte));
//in zwei Spalten
ausgabe.setLayout(new GridLayout(0, 2));
ausgabe.add(new JLabel("Mensch: "));
ausgabe.add(menschPunkteLabel);
ausgabe.add(new JLabel("Computer: "));
ausgabe.add(computerPunkteLabel);
ausgabe.add(anzeigeLabel);
ausgabe.add(aufdecken);
add(ausgabe);
TimerListener listener = new TimerListener();
aufdecken.addActionListener(listener);
}
//das eigentliche Spielfeld erstellen
private void kartenZeichnen(JPanel feld) {
int count = 0;
for (int i = 0; i <= 41; i++) {
//eine neue Karte erzeugen
karten[i] = new MemoryKarte(bilder[count], count, this);
//bei jeder zweiten Karte kommt auch ein neues Bild
if ((i + 1) % 2 == 0)
count++;
}
// die karten werden gemischt und ins spielfeld gesetzt
Collections.shuffle(Arrays.asList(karten));
for (int i = 0; i <= 41; i++) {
feld.add(karten[i]);
karten[i].setBildPos(i);
}
}
//die Methode übernimmt die wesentliche Steuerung des Spiels
//Sie wird beim Anklicken einer Karte ausgeführt
public void karteOeffnen(MemoryKarte karte) {
//zum Zwischenspeichern der ID und der Position
int kartenID, kartenPos;
anzeigeLabel.setText((anzeige));
//die Karten zwischenspeichern
paar[umgedrehteKarten] = karte;
//die ID und die Position beschaffen
kartenID = karte.getBildID();
kartenPos = karte.getBildPos();
//die Karte in das Gedächtnis des Computers eintragen
//aber nur dann, wenn es noch keinen Eintrag an der entsprechenden Stelle gibt
if ((gemerkteKarten[0][kartenID] == -1))
gemerkteKarten[0][kartenID] = kartenPos;
else
//wenn es schon einen Eintrag gibt
//und der nicht mit der aktuellen Position übereinstimmt, dann haben wir die
//zweite Karte gefunden
//die wird dann in die zweite Dimension eingetragen
if (gemerkteKarten[0][kartenID] != kartenPos)
gemerkteKarten[1][kartenID] = kartenPos;
//umgedrehte Karten erhöhen
umgedrehteKarten++;
//sind 2 Karten umgedreht worden?
if (umgedrehteKarten == 2) {
//dann prüfen wir, ob es ein Paar ist
paarPruefen(kartenID);
//den Timer starten
timer.start();
}
//haben wir zusammen 21 Paare, dann ist das Spiel vorbei
if (computerPunkte + menschPunkte == 21) {
JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei.");
JOptionPane.showMessageDialog(this, "Der Mensch hat "
+ (menschPunkte) + " punkte gemacht");
JOptionPane.showMessageDialog(this, "Der Computer hat "
+ (computerPunkte) + " punkte gemacht ");
if (menschPunkte > computerPunkte)
JOptionPane.showMessageDialog(this, " Der Mensch Hat Gewonnen");
else
JOptionPane.showMessageDialog(this,
" Der Computer Hat Gewonnen");
System.exit(0);
}
}
//die Methode dreht die Karten wieder auf die Rückseite
//bzw nimmt sie aus dem Spiel
private void karteSchliessen() {
boolean raus = false;
//ist es ein Paar?
if (paar[0].getBildID() == paar[1].getBildID())
raus = true;
//wenn es ein Paar war, nehmen wir die Karten aus dem Spiel
//sonst drehen wir sie nur wieder um
paar[0].rueckseiteZeigen(raus);
paar[1].rueckseiteZeigen(raus);
//es ist keine Karte mehr geöffnet
umgedrehteKarten = 0;
//hat der Spieler kein Paar gefunden?
if (raus == false)
//dann wird der Spieler gewechselt
spielerWechseln();
else
//hat der Computer ein Paar gefunden?
//dann ist er noch einmal an der Reihe
if (spieler == 1)
computerZug();
}
// diese Methode überprüft ob ein Paar gefunden wurde
//die Methode prüft, ob ein Paar gefunden wurde
private void paarPruefen(int kartenID) {
if (paar[0].getBildID() == paar[1].getBildID()) {
//die Punkte setzen
paarGefunden();
//die Karten aus dem Gedächtnis löschen
gemerkteKarten[0][kartenID] = -2;
gemerkteKarten[1][kartenID] = -2;
}
}
//die Methode setzt die Punkte, wenn ein Paar gefunden wurde
private void paarGefunden() {
//spielt gerade der Mensch?
if (spieler == 0) {
menschPunkte++;
menschPunkteLabel.setText(Integer.toString(menschPunkte));
} else {
computerPunkte++;
computerPunkteLabel.setText(Integer.toString(computerPunkte));
}
}
//die Methode wechselt den Spieler
private void spielerWechseln() {
//wenn der Mensch an der Reihe war,
//kommt jetzt der Computer
if (spieler == 0) {
spieler = 1;
computerZug();
anzeigeLabel.setText(anzeige1);
} else
spieler = 0;
}
//die Methode setzt die Computerzüge um
private void computerZug() {
int kartenZaehler = 0;
int zufall = 0;
boolean treffer = false;
//zur Steuerung über die Spielstärke
if ((int) (Math.random() * spielstaerke) == 0) {
//erst einmal nach einem Paar suchen
//dazu durchsuchen wir das Array gemerkteKarten, bis wir in beiden Dimensionen
//einen Wert finden
while ((kartenZaehler < 21) && (treffer == false)) {
//gibt es in beiden Dimensionen einen Wert größer oder gleich 0?
if ((gemerkteKarten[0][kartenZaehler] >= 0)
&& (gemerkteKarten[1][kartenZaehler] >= 0)) {
//dann haben wir ein Paar
treffer = true;
//die Vorderseite der Karte zeigen
karten[gemerkteKarten[0][kartenZaehler]]
.vorderseiteZeigen();
//und dann die Karte öffnen
karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);
//die zweite Karte auch
karten[gemerkteKarten[1][kartenZaehler]]
.vorderseiteZeigen();
karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
}
kartenZaehler++;
}
}
//wenn wir kein Paar gefunden haben, drehen wir zufällig zwei Karten um
if (treffer == false) {
//solange eine Zufallszahl suchen, bis eine Karte gefunden wird, die noch im Spiel ist
do {
zufall = (int) (Math.random() * karten.length);
} while (karten[zufall].isNochImSpiel() == false);
//die erste Karte umdrehen
//die Vorderseite der Karte zeigen
karten[zufall].vorderseiteZeigen();
//und dann die Karte öffnen
karteOeffnen(karten[zufall]);
//für die zweite Karte müssen wir außerdem prüfen, ob sie nicht gerade angezeigt wird
do {
zufall = (int) (Math.random() * karten.length);
} while ((karten[zufall].isNochImSpiel() == false)
|| (karten[zufall].isUmgedreht() == true));
//und die zweite Karte umdrehen
karten[zufall].vorderseiteZeigen();
karteOeffnen(karten[zufall]);
}
}
//die Methode liefert, ob Züge des Menschen erlaubt sind
//die Rückgabe ist false, wenn gerade der Computer zieht
//oder wenn schon zwei Karten umgedreht sind
//sonst ist die Rückgabe true
public boolean zugErlaubt() {
boolean erlaubt = true;
//zieht der Computer?
if (spieler == 1)
erlaubt = false;
//sind schon zwei Karten umdreht?
if (umgedrehteKarten == 2)
erlaubt = false;
return erlaubt;
}
}
