MemorySpiel

raven1

Mitglied
//Hallo,

// mein Programmierproblem..........

//sobald der user auf eine Karte klickt, dann den "Schummelknopf" auslöst, dann diesselbe Karte //anklickt, erkennt das Programm ein Paar und dreht genau diese eine Karte als "paar" um.(zweimal //als gleiche Karte erkannt, also "paar"......
// wo liegt mein Fehler.......?? Danke für jeden Hinweis!!!!!!!!!!

Java:
public class MemoryFeld_12 extends JFrame{
	
	
	class TimerListener implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e){
			//System.out.println("Ich werde vom Timer ausgegeben. ");
			karteSchliessen();
		}
	}
	
	
	class MeinSchummelListener implements ActionListener{
		@Override
		public void actionPerformed(ActionEvent e){
			if(e.getActionCommand().equals("aufdecken")){
				if((zugErlaubt()== true)||(umgedrehteKarten == 0))
				kartenAufdecken();
			}
				
		}
       
}
	
    
	
	private MemoryKarte_12[]karten;
	
	
	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"
			};
	
	
	
	private int userPunkte;
    private int pcPunkte;
	
	private int werZieht;
	
	private JLabel userPunkteLabel, pcPunkteLabel;
	
	private JLabel werZiehtLabel;
	
	private int umgedrehteKarten;
	
	private MemoryKarte_12[] paar;
	
	private int spieler;
	
	private Timer timer;
	
	private int [][]gemerkteKarten;
	
	private int spielStaerke ;
	
	
	private JSlider slider;
	
	
	private int minimum, maximum;
	
	class MeinSliderListener  implements  ChangeListener{ 
		
		    
        
		
		@Override
		public void stateChanged(ChangeEvent e) {
			    
			    if (e.getSource()instanceof JSlider ){
			    	spielStaerke = slider.getValue();
			    	slider.setValue(spielStaerke);
			    	
			    	System.out.println(spielStaerke);   	
			}
	    }	   
	}

	
	
	public MemoryFeld_12 (String title){
	super(title);
	
	
	karten = new MemoryKarte_12[42];
	
	
	paar = new MemoryKarte_12[2];
	
	
	gemerkteKarten = new int[2][21];
	
    userPunkte = 0;
    pcPunkte = 0;
   
	
	
    umgedrehteKarten = 0;
	
	
    spieler = 0;
  
    minimum = 1;
    maximum = 10;
    
     spielStaerke = 5;
   
   
	
   
    for (int aussen =0; aussen <2; aussen ++)
    	for(int innen = 0; innen < 21; innen++)
    		gemerkteKarten[aussen][innen]= -1;
	
	
     initGUI();
     
     
     timer = new Timer (2000, new TimerListener());
    
     timer.setRepeats(false);
	
	
	
	setSize(420,740);
	setResizable(false);
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	setVisible(true);
	
	}
   
	private void initGUI() {
		
	
	setLayout(new FlowLayout(FlowLayout.LEFT));
	
	JPanel feld = new JPanel();
	
	feld.setLayout(new GridLayout(7,0));
	
	kartenZeichnen(feld);
	add(feld);
	
	JPanel ausgabe= new JPanel();
	userPunkteLabel = new JLabel();
	pcPunkteLabel = new JLabel();
	userPunkteLabel.setText(Integer.toString(userPunkte));
	pcPunkteLabel.setText(Integer.toString(pcPunkte));
	
	
	werZiehtLabel = new JLabel();
	werZiehtLabel.setText(Integer.toString(werZieht));
	                   
	
	                   JButton schummelKnopf = new JButton("Alles Aufdecken");
	                   schummelKnopf.setActionCommand("aufdecken");
	                   MeinSchummelListener schummel = new MeinSchummelListener();
	                   schummelKnopf.addActionListener (schummel);
	
	                   
	                	
		               	slider = new JSlider(minimum, maximum);
		               
		               	slider.setValue(spielStaerke);
		               	slider.setMajorTickSpacing(1);
		                slider.setMinorTickSpacing(1);
		                slider.setPaintLabels(true);
		                slider.setPaintTicks(true);
		                   
		                  
		                   MeinSliderListener listener= new MeinSliderListener();
		                   slider.addChangeListener(listener);
    
	
	ausgabe.setLayout(new GridLayout(0,2));
	
	ausgabe.add(new JLabel("User :    "));
	ausgabe.add(userPunkteLabel);
	ausgabe.add(new JLabel("PC :    "));
	ausgabe.add(pcPunkteLabel);
	
	ausgabe.add(new JLabel ("Es zieht der"));
	ausgabe.add(werZiehtLabel);
	
	ausgabe.add(schummelKnopf);
	
	ausgabe.add(new JLabel(" < stark    Spielstärke    schwach > "));
	ausgabe.add(new JLabel());
	ausgabe.add(slider);
	add(ausgabe);
	
	}
    
	
	private void kartenZeichnen(JPanel feld) {
	int count = 0;
	
	for (int i = 0; i<=41; i++){
	
	
	karten[i]= new MemoryKarte_12(bilder[count],count, this);
	

	

	
	if ((i + 1)%2 ==0)
		count++;
	 }
	
	Collections.shuffle(Arrays.asList(karten));
	for (int i = 0; i<= 41; i++){
		feld.add(karten[i]);
		karten[i].setBildPos(i);
	}
   }
	
	public void karteOeffnen(MemoryKarte_12 karte) {
		
		
		int kartenID, kartenPos;
		
		
		paar[umgedrehteKarten]= karte;
		
		
		kartenID = karte.getBildID();
		kartenPos = karte.getBildPos();
		
		
	    if ((gemerkteKarten[0][kartenID]==-1))
	    	
	    	gemerkteKarten[0][kartenID]= kartenPos;
	    else
	    	
	    	if(gemerkteKarten[0][kartenID]!=kartenPos)
	    		gemerkteKarten[1][kartenID]= kartenPos;
	    
	   
	    umgedrehteKarten++;
	    
	   
	    if ( umgedrehteKarten ==2){
	    	
	    	paarPruefen (kartenID);
	    	
	    	timer.start();
	    }

	    if (pcPunkte + userPunkte == 21){
	    	
	    	
	    	if (pcPunkte < userPunkte){
	    		JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei! Der User hat gewonnen mit " + userPunkte +" Punkten!" );
	    		}
	    	else{
	    		
	    		if(userPunkte <pcPunkte){
	    	    JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei! Der Computer hat gewonnen mit: " + pcPunkte + " Punkten!");
	    		}
	    		
	        System.exit(0);
	    	}		
	}}
	
	private void karteSchliessen() {
		boolean rausnehmen = false;
		
		
		if (paar[0].getBildID()== paar[1].getBildID())
			rausnehmen = true;
		
		
		paar[0].rueckseiteZeigen(rausnehmen);
		paar[1].rueckseiteZeigen(rausnehmen);
		
		
		umgedrehteKarten = 0;
		
		
		if ( rausnehmen == false)
			
			spielerWechseln();
			
			else
				
				if (spieler ==1)
						
					pcZug();
				
		}
		
		
	private void spielerWechseln() {
		
		if (spieler == 0){
			spieler = 1;
			
			werZiehtLabel.setText("Computer");
			pcZug();
			
		}else
			spieler = 0;
		
	}
	
	private void pcZug() {
		int kartenZaehler = 0;
		int zufall = 0;
		boolean treffer = false;
		
		
		if ((int )(Math.random()* spielStaerke)==0){
		
		while ((kartenZaehler<21)&& (treffer == false)){
			
			if ((gemerkteKarten [0][kartenZaehler]>=0)&&
			  (gemerkteKarten[1][kartenZaehler]>=0)){
				
				treffer = true;
				
				
				karten[gemerkteKarten[0][kartenZaehler]].doClick();
				
				karten[gemerkteKarten[1][kartenZaehler]].doClick();
				
				
				
				karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();
				
				karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);
				
				karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();
				
				karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
				
			}
			
			kartenZaehler++;
		}
		}
		
		if ( treffer == false){
			
			do{
				zufall = (int)(Math.random()* karten.length);
			
			}while (karten[zufall].isNochImSpiel()== false);
			
			 karten[zufall].doClick();
			
			
			
			karten[zufall].vorderseiteZeigen();
			
			karteOeffnen(karten[zufall]);
			
			
			
			do{
				zufall=(int)(Math.random()* karten.length);
			}while ((karten[zufall].isNochImSpiel()==false)||
					(karten[zufall].isUmgedreht()==true));
			
			
			
			karten[zufall].vorderseiteZeigen();
			
			karteOeffnen(karten[zufall]);
		  }
		}
			
		
	
	
	private void paarPruefen(int kartenID) {
		if (paar[0].getBildID()==paar[1].getBildID()){
			
			paarGefunden();
			
			
			gemerkteKarten[0][kartenID]= -2;
			gemerkteKarten[1][kartenID]= -2;
		}
		
	}
	
	private void paarGefunden() {
		
		if (spieler == 0){
			userPunkte ++;
			userPunkteLabel.setText(Integer.toString(userPunkte));
		}
		else
		{
			pcPunkte++;
			pcPunkteLabel.setText(Integer.toString(pcPunkte));
		}
		
	} 
	
	public boolean zugErlaubt(){
		boolean erlaubt = true;
		
		if ( spieler == 1)
			erlaubt = false;
		
		werZiehtLabel.setText("User");
		
		
		if ( umgedrehteKarten == 2 )
			erlaubt = false;
		
		return erlaubt;
	
	}
	
	public void kartenAufdecken() {
		
        for (int i = 0; i <= 41; i++) {
            if (karten[i].isNochImSpiel() == true) {
            	
                karten[i].vorderseiteZeigen();
            }
        }
       
        Timer quickBlende = new Timer(500, new ActionListener() {
          
            public void actionPerformed(ActionEvent e) {
                for (int i = 0; i <= 41; i++) {
                    if (karten[i].isNochImSpiel() == true) {  
                    	
                    	 karten[i].rueckseiteZeigen(false);
                        
                    }
                }
            }
        });
        quickBlende.setInitialDelay(500); 
        quickBlende.setRepeats(false);
        quickBlende.start();
        }}
 
Zuletzt bearbeitet von einem Moderator:
T

Tomate_Salat

Gast
// Was // soll // das // denn //?
// ich // verstehe // dein // Problem // nicht
// schreib // das // nochmal // ohne // nervige // zwischenzeichen
// und // zwar // so // dass // man // es // auch // versteht // Danke!!!!!!!
 
S

SlaterB

Gast
der überall stehende dicke rote Hinweis
> Java™ Quelltext ist bitte in [ JAVA ]-Tags zu schreiben: [ JAVA ]hier Java Code einfügen[ /JAVA ]
war dir nicht aufgefallen?

ohne die Bilder kann niemand deinen Code gut ausprobieren, wäre schön wenn du eine funktionierende Variante mit einfachen Texten A, B, C, D usw. daraus gemacht hättest,
und wie wäre es noch mit weiteren Erklärungen? welchen Sinn hat denn die Schummelfunktion grundsätzlich,
was bewirkt sie?

steht vielleicht auch im Code, ich schaue nebenbei rein..

edit:
Hinweis: vorheriges Posting in
http://www.java-forum.org/hausaufgaben/113324-memory-spiel.html#post797626


edit:
die Klasse MemoryKarte_12 fehlt..
 
Zuletzt bearbeitet von einem Moderator:

raven1

Mitglied
// das // sein // kommentar//zeichen//tomatensalat//du // verstehen????

leider hat es dieses erste Mal mit dem "laden" nicht so geklappt, aber vieleicht fällt es "alten hasen" schwer sich in "grünzeug"
reinzuversetzen, Kommentare habe ich alle rausgelassen, damit es nicht zuviel / oder unübersichtlich wird
Zum Ausprobieren kann ich alle Klassen MemoryFeld.java und MemoryKarte.java und Memory.main mit Kommentaren reinstellen,
"Schummelfunktion" über JButton = alle Karten/Bilder für gewisse Zeit anzeigen lassen, um zu gewinnen!!! // so war's gefragt!!!
danke

------------------------------------------------------------------
die einzige f.&$)§=ng Sprache die die god$&"$ f.§$%ng Programmierer wirklich f.§$%ng verstehen ist fluchen....
 

Mofi

Bekanntes Mitglied
// das // sein // kommentar//zeichen//tomatensalat//du // verstehen????

leider hat es dieses erste Mal mit dem "laden" nicht so geklappt, aber vieleicht fällt es "alten hasen" schwer sich in "grünzeug"
reinzuversetzen, Kommentare habe ich alle rausgelassen, damit es nicht zuviel / oder unübersichtlich wird
Zum Ausprobieren kann ich alle Klassen MemoryFeld.java und MemoryKarte.java und Memory.main mit Kommentaren reinstellen,
"Schummelfunktion" über JButton = alle Karten/Bilder für gewisse Zeit anzeigen lassen, um zu gewinnen!!! // so war's gefragt!!!
danke

------------------------------------------------------------------
die einzige f.&$)§=ng Sprache die die god$&"$ f.§$%ng Programmierer wirklich f.§$%ng verstehen ist fluchen....

1. Kann man Text wo immer mal wieder // steht sehr schwer lesen (oder machst du sowas in deinem Code auch?)
2. Wird dir keiner helfen, wenn du unhöflich bist
3. Ist es schwer ein Fehler nach zu voll ziehen, wenn man das Programm nicht starten kann. (Habs nicht ausprobiert aber es klang eben, dass ein paar Klassen fehlen. Oh und wenn die Bilder fehlen, kann man das Programm ja auch nicht testen. Keiner hier wird Lust haben,´dafür extra Bilder zu machen oder den Code zuändern.

Wenn du willst, dass man/wir dir helfen musst du schon ein wenig entgegen kommend sein...
 

raven1

Mitglied
Klasse MemoryFeld
Java:
package java_12_memory;

import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
// für die Klassen Arrays und Collections
import java.util.Arrays;
import java.util.Collections;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.Timer;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;



// die Klasse MemoryFeld_12 soll das Spielfeld mit den Karten verwalten
// dazu legen wir ein GridLayout mit 7 Zeilen und  Spalten an, und fügen die Karten
// über eine Schleife ein. Neben der Spielverwaltung soll die Klasse MemoryFeld 
// auch die Logik des Spiels abdecken z.B. wie viele Karten sind umgedreht?, 
// handelt es sich bei den umgedrehten Karten um ein Paar etc.
 
public class MemoryFeld_12 extends JFrame{
	
class TimerListener implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e){
			
				karteSchliessen();
			
		}
	}

	class MeinSchummelListener implements ActionListener{
		@Override
		public void actionPerformed(ActionEvent e){
			if(e.getActionCommand().equals("aufdecken")){
				if((zugErlaubt()== true)||(umgedrehteKarten == 1)) 
				kartenAufdecken();
					
				}
			}
                }
	
	private static final long serialVersionUID = 1762429892759091611L;
    
	
	private MemoryKarte_12[]karten;
	
	// hier legen wir ein Array vom Typ String an mit den Namen 
	//der Bilddateien für die Vorderseiten an
	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"
			};
	
	
	
	private int userPunkte;
        private int pcPunkte;
	
	private int werZieht;
	
	private JLabel userPunkteLabel, pcPunkteLabel;
	
	private JLabel werZiehtLabel;
	
	private int umgedrehteKarten;
	// für das aktuell umgedrehte Paar. Die Variabel paar ist ein Array vom Typ
	//MemoryKarte und soll später die beiden aktuell umgedrehten Karten zwischenspeicher
	private MemoryKarte_12[] paar;
	
	private int spieler;
	
	private Timer timer;
	
	private int [][]gemerkteKarten;
	
	private int spielStaerke ;
	
	private JSlider slider;
	
	private int minimum, maximum;
	
	
	class MeinSliderListener  implements  ChangeListener{ 
		
		@Override
		public void stateChanged(ChangeEvent e) {
			   
			    if (e.getSource()instanceof JSlider ){
			    	spielStaerke = slider.getValue();
			    	slider.setValue(spielStaerke);
			  }
	        }	   
	}

	// der Konstruktor
	// er erzeugt das Spielfeld mit den Karten und die Oberfläche,
	
	public MemoryFeld_12 (String title){
	super(title);
	
	// das Array für die Karten erstellen, insgesamt 42 Stück
	karten = new MemoryKarte_12[42];
	
	// für das Paar
	paar = new MemoryKarte_12[2];
	
	// speichert für jede Karte paarweise die Position im Spielfeld
	gemerkteKarten = new int[2][21];
    
    // keiner hat zu Beginn einen Punkt
    userPunkte = 0;
    pcPunkte = 0;
    
	
    // es ist keine Karte umgedreht
    umgedrehteKarten = 0;
	
    // der Mensch fängt an
    spieler = 0;
    
    //minimum und maximum setzen
    minimum = 1;
    maximum = 10;
    
    spielStaerke = 5;
    
    // es gibt keine gemerkten Karten
    // alle Elemente im Array gemerkteKarten werden mit dem Wert -1 initialisiert 
    // Er soll markieren, dass noch keine Karten an der entsprechenden Stelle 
    // gespeichert wurde
    
    for (int aussen =0; aussen <2; aussen ++)
    	for(int innen = 0; innen < 21; innen++)
    		gemerkteKarten[aussen][innen]= -1;
	
	// die graphische Oberfläche erstellen
        initGUI();
     
    
     timer = new Timer (2000, new TimerListener());
     // den Timer starten
     // timer.start();
     timer.setRepeats(false);
	
	
	setSize(420,740);
	setResizable(false);
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	setVisible(true);
	
	}
    // die Methode erstellt die Oberflaeche und zeichnet die Karten
	private void initGUI() {
		
	setLayout(new FlowLayout(FlowLayout.LEFT));
	
	JPanel feld = new JPanel();
	
	feld.setLayout(new GridLayout(7,0));
	
	kartenZeichnen(feld);
	add(feld);
	
	JPanel ausgabe= new JPanel();
	userPunkteLabel = new JLabel();
	pcPunkteLabel = new JLabel();
	userPunkteLabel.setText(Integer.toString(userPunkte));
	pcPunkteLabel.setText(Integer.toString(pcPunkte));
	
	
	werZiehtLabel = new JLabel();
	werZiehtLabel.setText(Integer.toString(werZieht));
	                   
	
	                   JButton schummelKnopf = new JButton("Alles Aufdecken");
	                   schummelKnopf.setActionCommand("aufdecken");
	                   MeinSchummelListener schummel = new MeinSchummelListener();
	                   schummelKnopf.addActionListener (schummel);
	
	                   
	                	slider = new JSlider(minimum, maximum);
		               	slider.setValue(spielStaerke);
		               	slider.setMajorTickSpacing(1);
		                slider.setMinorTickSpacing(1);
		                slider.setPaintLabels(true);
		                slider.setPaintTicks(true);
		                   
		                   // den Slider mit dem Listener verbinden
		                   MeinSliderListener listener= new MeinSliderListener();
		                   slider.addChangeListener(listener);
    
	 
	
	ausgabe.setLayout(new GridLayout(0,2));
	ausgabe.add(new JLabel("User :    "));
	ausgabe.add(userPunkteLabel);
	ausgabe.add(new JLabel("PC :    "));
	ausgabe.add(pcPunkteLabel);
	
	ausgabe.add(new JLabel ("Es zieht der"));
	ausgabe.add(werZiehtLabel);
	ausgabe.add(schummelKnopf);
	ausgabe.add(new JLabel(" < stark    Spielstärke    schwach > "));
	ausgabe.add(new JLabel());
	ausgabe.add(slider);
	add(ausgabe);
	
	}
    
	// die Methode kartenZeichnen legt das eigentliche Spielfeld mit den Karten an.
	// In der Methode kartenZeichnen()lassen wir zuerst das Array mit den Spilekarten
	// wie gewohnt erstellen, fügen die Karten aber noch nicht in das eigentliche 
	// Spielfeld ein, sondern mischen sie erst über die Methode shuffle() der Klasse 
	// Collections. 
	private void kartenZeichnen(JPanel feld) {
	int count = 0;
	// die for Schleife erzeugt 42 Instanzen der Klasse MemoryKarte 
	for (int i = 0; i<=41; i++){
	
	
		// übergeben in der Methode kartenZeichnen () der Klasse MemoryFeld die this-Referenz
		// als drittes Argument des Konstruktors der Klasse MemoryKarte
	karten[i]= new MemoryKarte_12(bilder[count],count, this);
	

	

	
	// bei jeder zweiten Karte kommt auch ein neues Bild
	// die if Abfrage sorgt dafür, dass der Wert von Karte bei jedem zweiten Durchlauf 
	// der Schleife erhöht wird.Dazu wird mit dem Modulo Operator % , ob sich der Wert
	// von i +1 ohne Rest durch 2 teilen lässt. i+1muss verwendet werden , da i beim ersten  
        // Durchlauf
	// den Wert o hat und immer um 1 hinterherhinkt.
	
	// die if-Abfrage ist erforderlich , da wir jedes Bild bzw. jede Karte doppelt benötigen.
	// Nach dem Abarbeiten der Schleife stehen also hintereinander die Bilder der Vorderseiten
	// für die einzelnen Paare im Spielfeld.
	if ((i + 1)%2 ==0)
		count++;
	 }
	// die Karten werden gemischt und ins Spielfeld gesetzt, dazu verwendet man die 
	// Methode shuffle()der Klasse Collections. Sie kann eine Liste zufällig durcheinander
	// würfeln. Allerdings erwartet die Methode die Liste als Argument vom Typ List.
	// Daher kann das Array mit den Karten nicht direkt übergeben werden, sondern es muss
	// zuerst mit der Methode asList()der Klasse Arrays in den Typ List umgebaut werden.
	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_12 karte) {
		
		// zum Zwischenspeichern der ID und der Position 
		int kartenID, kartenPos;
		
		// die Karten zwischenspeichern
		// in der Methode legen wir die gerade umgedrehte Karte, die über das Argument 
		// karte übergeben wird in dem Array paar ab.
		// der Wert der Instanzvariablen umgedrehteKarten entscheidet darüber , an
		// welcher Position im Array die Karte gespeichert wird.
		paar[umgedrehteKarten]= karte;
		
		// die ID und die Position beschaffen
		// hier beschaffen wir uns die eindeutige Kennzeichnung des Bildes, das auf der 
		// Karte angezeigt wird , sowie die Position der Karte im Spielfeld und speichern 
		// diese Daten in lokalen Variablen zwischen.
		kartenID = karte.getBildID();
		kartenPos = karte.getBildPos();
		
		// die Position der Karte in die Erinnerung des PC's eintragen,
		// und zwar genau an die Position im Array gemerkteKarten, die auch für den 
		// "Index" des Bildes steht, das auf der Karte angezeigt wird.
		// die Position der Karten mit der Grafik apfel.jpg würden zum Beispiel 
		// in beiden Dimensionen des Arrays an erster Stelle ( also bei
		// gemerkteKarten[0][0] und gemerkteKarten[1][0]gespeichert, da diese Grafik
		// im Array bilder an ersterStelle steht -also den "Index" 0 hat.
		// aber nur dann, wenn es noch keinen Eintrag an der 
		// entsprechenden Stelle gibt.
		// damit wir die Position an der Karten nicht ständig überschreiben 
		// prüfen wir mit der Abfrage, ob es schon einen Eintrag für die Karte in 
		// ersten Dimension gibt.Wenn es nicht der Fall ist
		// tragen wir die Position in der ersten Dimension ein.
	        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
	    	// sie wird in die zweite Dimension eingetragen
	    	if(gemerkteKarten[0][kartenID]!=kartenPos)
	    		gemerkteKarten[1][kartenID]= kartenPos;
	    
	    
	    umgedrehteKarten++;
	    
	    // sind 2 Karten umgedreht worden
	    if ( umgedrehteKarten ==2){
	    	// dann prüfen wir , ob es ein Paar ist
	    	paarPruefen (kartenID);
	    
	    	karteSchliessen();
	    	
	    	// den Timer starten
	    	timer.start();
	    }
	    //haben wir zusammen 21 Paare, dann ist das Spiel vorbei
	    if (pcPunkte + userPunkte == 21){
	    	
	    	
	    	if (pcPunkte < userPunkte){
	    		JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei! Der User hat gewonnen mit " + userPunkte +" Punkten!" );
	    		}
	    	else{
	    		
	    		if(userPunkte <pcPunkte){
	    	    JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei! Der Computer hat gewonnen mit: " + pcPunkte + " Punkten!");
	    		}
	    		
	        System.exit(0);
	    	}		
	}}
	// Die Methode karteSchliessen()dreht die Karten wieder auf die Rückseite, 
	// bzw. nimmt sie komplett aus dem Spiel. Außerdem wechselt sie über die Methode#
	// spielerWechsel()den Spieler, wenn kein Paar gefunden wurde und lässt
	// den Pc nochmals ziehen, wenn er an der Reihe war. Dazu rufen wir dann die Methode
	// pcZug() auf.
	private void karteSchliessen() {
		boolean rausnehmen = false;
		
		// ist es ein Paar?
		if (paar[0].getBildID()== paar[1].getBildID())
			rausnehmen = true;
		
		paar[0].rueckseiteZeigen(rausnehmen);
		paar[1].rueckseiteZeigen(rausnehmen);
		
		// es ist keine Karte mehr geöffnet
		umgedrehteKarten = 0;
		
		// hat der Spieler kein Paar gefunden?
		if ( rausnehmen == false)
			// dann wird der Spieler gewechselt
			spielerWechseln();
			
			else
				// hat der PC ein Paar gefunden?
				// dann ist er nochmals an der Reihe
				if (spieler ==1)
						
					pcZug();
				
		}
		
	// die Methode spielerWechseln()wechselt den aktuellen Spieler und
	// sorgt dafür, dass der PC zieht wenn er an der Reihe ist. Dazu rufen wir wieder die 
	// Methode pcZug()auf.		
	private void spielerWechseln() {
		
		if (spieler == 0){
			spieler = 1;
			
			// den aktuellen Benutzer anzeigen
			werZiehtLabel.setText("Computer");
			pcZug();
			
		}else
			spieler = 0;
		
	}
	// die Methode pcZug() setzt die PC Züge um
	private void pcZug() {
		int kartenZaehler = 0;
		int zufall = 0;
		boolean treffer = false;
		
		
		
		if ((int )(Math.random()* spielStaerke)==0){
		// erst einmal nach einem Paar suchen
		// dazu durchsuchen wir alle Elemente im Array gemerkteKarten, 
		// bis wir in den beiden Dimension einen Wert für eine Karte finden
		while ((kartenZaehler<21)&& (treffer == false)){
			//gibt es in den 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 zeigen
				karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();
				// die Karte oeffnen
				karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);
				// die zweite Karte auch
				karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();
				// die zweite Karte oeffnen
				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);
			
			 
			
			
			// Vorderseite der Karte anzeigen
			karten[zufall].vorderseiteZeigen();
			// und die Karte oeffnen
			karteOeffnen(karten[zufall]);
			
			
			// für die zweite Karte müssen wir außerdem prüfen
			// ob sie nicht gerade angezeigt wird
			// die Eigenschaft length liefert für ein Array die echte Anzahl der Elemente
			//- in diesem Fall für das Array karten den Wert 42.
			do{
				zufall=(int)(Math.random()* karten.length);
			}while ((karten[zufall].isNochImSpiel()==false)||
					(karten[zufall].isUmgedreht()==true));
			
			
			
			  
			
			// Vorderseite der Karte anzeigen
			karten[zufall].vorderseiteZeigen();
			// und die Karte oeffnen
			karteOeffnen(karten[zufall]);
		  }
		}// ende methode pcZug();
			
		
	
	// die Methode paarPrüfen() 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 paarGefunden()setzt die Punkte, wenn ein Paar gefunden wurde
	
	private void paarGefunden() {
		// spielt gerade der User?
		if (spieler == 0){
			userPunkte ++;
			userPunkteLabel.setText(Integer.toString(userPunkte));
		}
		else
		{
			pcPunkte++;
			pcPunkteLabel.setText(Integer.toString(pcPunkte));
		}
		
	} 
	
	// die Methode liefert ob Züge des Users 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 Pc?
		if ( spieler == 1)
			erlaubt = false;
		
		// den aktuellen Benutzer anzeigen
		werZiehtLabel.setText("User");
		
		// sind schon zwei Karten umgedreht
		if ( umgedrehteKarten == 2 )
			erlaubt = false;
		
		return erlaubt;
	
	}
	//Methode kartenAufdecken()um Vorderseite anzuzeigen
	public void kartenAufdecken() {
		// alle Karten die noch im Spiel sind 
        for (int i = 0; i <= 41; i++) {
            if (karten[i].isNochImSpiel() == true) {
            	// aufdecken /Vorderseite anzeigen;
                karten[i].vorderseiteZeigen();
            }
        }
        // Ein Timer erstellen, der die Karten nach ( hier 1/2 Sek.) zurückdreht
       
        Timer quickBlende = new Timer(500, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                for (int i = 0; i <= 41; i++) {
                    if (karten[i].isNochImSpiel() == true) {  
                    	karten[i].rueckseiteZeigen(false);
                        
                    }
                }
            }
        });
        quickBlende.setInitialDelay(500); 
        quickBlende.setRepeats(false);
        quickBlende.start();
        
    }}
die Klasse MemoryKarte.java
Java:
package java_12_memory;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JButton;
// Um die Bilder möglichst einfach anzeigen zu lassen und einfach auf das Anklicken einer
// Karte reagieren zu können,wird die Klasse für die Karten von JButton abgeleitet

public class MemoryKarte_12 extends JButton{
	
	private static final long serialVersionUID = -3408908836941319593L;
	
	// eine eindeutige ID zur Identifizierung des Bildes
	private int bildID;
	
	// hier vereinbaren wir zwei Instanzvariablen vom Typ ImageIcon
	
	private ImageIcon bildVorne, bildHinten;
	
	// Wo liegt die Karte im Spielfeld?
	private int bildPos;
	
	// ist die Karte umgedreht?
	private boolean umgedreht;
	
	// ist die Karte noch im Spiel
	private boolean nochImSpiel;
	
	//das Spielfeld für die Karte

	private MemoryFeld_12 spielfeld;
	
	// die innere Klasse für den ActionListener
	class KartenListener implements ActionListener {

		@Override
		// hier wird überprüft ob, 
		public void actionPerformed(ActionEvent arg0) {
			
			// ist die Karte überhaupt noch im Spiel,
			// und sind Züge noch erlaubt? 
			if ((nochImSpiel == false)||(spielfeld.zugErlaubt()== false))
				
				// wenn das nicht der Fall ist, verlassen wir die Methode wieder
				return;
			
	
	// befindet sich die Karte noch im Spiel
	// wenn die Rückseite zu sehen ist , die Vorderseite anzeigen
	if (umgedreht == false){
		
		setIcon(bildVorne);
		//und setzen die Instanzvariable umgedreht auf true,
		//damit erkennt das Programm das die Vorderseite der Karte zu sehen ist
		umgedreht = true;

		
		// Vorderseite anzeigen
		vorderseiteZeigen();
		
		
		//die Methode karteOeffnen()im Spielfeld aufrufen,
		//übergeben wird dabei die Karte - also die this Referenz der äußeren Klasse
		spielfeld.karteOeffnen(MemoryKarte_12.this);
	}
  }
}

	// der Konstruktor
	// er setzt die Größe , die Bilder und die Position
	public MemoryKarte_12 (String vorne, int bildID, MemoryFeld_12 spielfeld){
	
	   
		setPreferredSize(new Dimension(64,64));
	
	        // die Vorderseite, der Dateiname des Bildes wird an
	        // den Konstruktor der Klasse MemoryKarte_12 übergeben
		// und weisen hier die Bilder für die Vorderseite zu
		
		bildVorne = new ImageIcon(vorne);// eine neue Instanz der Klasse ImageIcon
	
	    // und hier für die Rückseite
		bildHinten = new ImageIcon("grafiken/back.jpg");
	    // und übergeben an den Konstruktor den Namen der BildDatei.
		setIcon(bildHinten);
	
	    // die Bild-ID
	    this.bildID= bildID;
		
	
	    // die Karte ist erst einmal umgedreht und noch im Feld
	    umgedreht = false;
	    nochImSpiel = true;
	    
	    // mit dem Spielfeld verbinden
	    this.spielfeld = spielfeld;
	
	
	    //den ActionListener verbinden
	    addActionListener(new KartenListener());
	}
	
	
	// die Methode zeigt die Rückseite der Karte an, bzw.drehen wir hier die Karte um
	
	public void rueckseiteZeigen(boolean rausnehmen){
	
	    // sollen die Karten komplett aus dem Spiel genommen werden
		if ( rausnehmen == true){
	
	        // das Bild aufgedeckt zeigen und die Karte aus dem Spiel nehmen
			setIcon(new ImageIcon("grafiken/aufgedeckt.jpg"));
			nochImSpiel= false;
		}
		
		else{
	        // sonst nur die Rückseite zeigen
			setIcon(bildHinten);
			umgedreht= false;
		}
	
	}
	// die Methode zeigt die Vorderseite an
	
	public void vorderseiteZeigen(){
		setIcon(bildVorne);
		umgedreht = true;
		
	}
	
	// mit den nächsten 3 Methoden wird ein Zugriff von außen auf die Instanzvariablen
	// ermöglicht.
	// die Methode liefert die Bild ID einer Karte 
	public int getBildID(){
		return bildID;
	}
	// die Methode liefert die Position einer Karte
	public int getBildPos(){
		return bildPos;
	}
	
    // die Methode setzt die Position einer Karte
	public void setBildPos(int bildPos){
		this.bildPos= bildPos;
	}
	
	
	// da der PC nicht versucht bereits aufgedeckte oder aus dem Spiel genommene
	// Karten umzudrehen, müssen wir vor dem Umdrehen der zufällig ermittelten Karten
	// prüfen, ob die Karte noch im Spiel ist, bzw. im Moment nicht angezeigt wird.
	// Dazu fragen wir den Wert der Variablen nochImSpiel bzw umgedreht der jeweiligen Instanz
	// der Klasse MemoryKarte ab. Da die beiden Attribute privat vereinbart sind, müssen wir
	// noch entsprechende Methoden erstellen, über die wir uns die Werte von außen    
        // beschaffen können 
	// die Methode liefert den Wert der Variablen umgedreht
	public boolean isUmgedreht(){
		return umgedreht;
	}
	
	// die Methode liefert den Wert der Variablen nochImSpiel
	public boolean isNochImSpiel(){
		return nochImSpiel;
	}
	
}


MainMethode
Java:
package java_12_memory;

public class MemoryMain_12 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 new MemoryFeld_12(" Mein Memory ");
	
	
}}
 

Anhänge

  • grafiken.zip
    100,5 KB · Aufrufe: 0

raven1

Mitglied
Hallo,

habe hoffentlich alles hochgeladen, incl. der Grafiken, aber meinen text vergessen

hoffe haben uns alle wieder beruhigt,

danke für eure Hinweise & Gedanken!!!
 
S

SlaterB

Gast
deine Ursprungsfrage ist schnell beantwortet,
durch das Schummeln werden alle Karten aufgedeckt, vor allem aber auch wieder verdeckt,
dabei bleibt die Variable umgedrehteKarten aber bei 1, wird nicht auf 0 zurückgesetzt, wie es etwa bei karteSchliessen() passieren würde, wenn auch auf kompliziertem Wege,

viel schlimmer ist aber aktuell der Computerspieler, um den solltest du dich kümmern,
in der spielerWechseln()-Methode wird pcZug(); ausgeführt, welcher über karteSchliessen() nochmal bei spielerWechseln() vorbei kommt,
außerdem läuft der Timer, der auch karteSchliessen() und damit spielerWechseln() ausführt,
so dass im Moment der PC ständig drankommt, durch 2x Wechseln kompliziert durcheinander

alles ist generell sehr kompliziert geraten..
 
Ähnliche Java Themen

Ähnliche Java Themen

Neue Themen


Oben