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{
private String anzeige = "Es Zieht der Mensch";
private String anzeige1 = "Es Zieht der Computer";
private ImageIcon bildVorne,bildHinten;
class MeinListener implements ActionListener {
@Override
// die Methode ruft die Methode karteSchliessen() auf
public void actionPerformed(ActionEvent e) {
if(e.getActionCommand().equals("aufdecken"));
kartenAufdecken();
if(e.getActionCommand().equals("zudecken"));
//kartenZudecken();
}
}
///eine innere Klasse für den Timer
class TimerListener implements ActionListener {
@Override
// die Methode ruft die Methode karteSchliessen() auf
public void actionPerformed(ActionEvent e) {
karteSchliessen();
}
}
//automatisch über Eclipse ergänzt
private static final long serialVersionUID = -649630686152121284L;
//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;
//zwei Labels für die Punkte
private JLabel menschPunkteLabel, computerPunkteLabel,anzeigeLabel;
//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;
//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();
//die Spielstärke ist 10, also eher schwach
spielstaerke = 10;
//für den Timer
//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,600);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
//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();
anzeigeLabel= new JLabel();
menschPunkteLabel = new JLabel();
computerPunkteLabel = new JLabel();
menschPunkteLabel.setText(Integer.toString(menschPunkte));
computerPunkteLabel.setText(Integer.toString(computerPunkte));
JButton schummelButton = new JButton("Alles Aufdecken");
schummelButton.setActionCommand("aufdecken");
// für den ActionListener
// für den ActionListener
MeinListener listener = new MeinListener();
schummelButton.addActionListener(listener);
JButton schummelButton1 = new JButton("Alles zudecken");
schummelButton1.setActionCommand("zudecken");
// für den ActionListener
// für den ActionListener
MeinListener listener1 = new MeinListener();
schummelButton1.addActionListener(listener1);
//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(schummelButton);
ausgabe.add(schummelButton1);
add(ausgabe);
}
//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 dann ins Spielfeld gesetzt
Collections.shuffle(Arrays.asList(karten));
for (int i = 0; i <= 41; i++) {
feld.add(karten[i]);
//die Position der Karte setzen
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 == 1) {
JOptionPane.showMessageDialog(this,"Das Spiel ist vorbei.");
// 4 neue MessageDialog eingefügt...
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();
}
//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();
}
else
spieler = 0;
anzeigeLabel.setText(anzeige1);
}
//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;
}
public void kartenAufdecken(){
int i =0;
for(i=0; i+1 <=42;++i ){
karten[i].vorderseiteZeigen();
}
}
/*public void kartenZudecken(){
int i =0;
for(i=0; i+1 <=42;++i ){
karten[i].rueckseiteZeigen(rootPaneCheckingEnabled);
}*/
}
