Memory-Spiel Aktivierung der Methode mit Timer

Hallo,

ich habe die folgende Aufgabe bekommen.
...
Bauen Sie eine „Schummel“-Funktion in das Memory-Spiel ein. Ergänzen Sie dazu eine Schaltfläche Alles aufdecken. Beim Anklicken der Schaltfläche sollen alle noch nicht aufgedeckten Karten für eine bestimmte Zeit angezeigt und danach automatisch wieder umgedreht werden.
Sorgen Sie dafür, dass die „Schummel“-Funktion nur dann aufgerufen werden kann, wenn gerade der Mensch am Zug ist und wenn keine andere Karte angezeigt wird. Dazu können Sie zum Beispiel die Schaltfläche zum Starten der „Schummel“-Funktion je nach Spielzustand aktivieren beziehungsweise deaktivieren.
Die Lösung ist nicht allzu schwierig, wenn Sie den „richtigen Dreh“ finden. Denken Sie bitte daran, dass Sie unter Umständen das Fenster für die Anwendung ein wenig vergrößern müssen, damit die neue Schaltfläche nach dem Einfügen auch zu sehen ist.
...

Ich habe es soweit geschafft das die Karten sich für 2 Sekunden zeigen und dann wieder umdrehen.
Jedoch bekomme ich es nicht hin das dies über einem Button funktioniert.
Bei Klasse "MemoryFeld" Zeile 104 taucht die Fehlermeldung auf (jetzt auskommentiert) und ich möchte das die Methode von "startschummler()" bei der Klasse "MemoryKarte" Zeile 96 gestartet wird, sobald der Button angeklickt wird.

Weiß jemand weiter, ich nämlich nicht :)

Java:
package einsendeaufgaben_JAVA13C;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.FlowPane;
import javafx.stage.Stage;

public class MemoryFX extends Application{
    @Override
    public void start(Stage meineStage) throws Exception {       
        FlowPane rootNode = new MemoryFeld().initGUI(new FlowPane());//den obersten Knoten erzeugen, hier verwenden wir ein FlowPane, erzeugt wird die Oberfläche über eine eigene Methode in der Klasse MemoryFeld
        //die Szene erzeugen
        //an den Konstruktor werden der oberste Knoten und die Größe übergeben
        Scene meineScene = new Scene(rootNode, 480, 600);//die Größe für Aufgabe 1 & Aufgabe 2 angepasst
                
        meineStage.setTitle("Memory");//den Titel über stage setzen       
        meineStage.setScene(meineScene);//die Szene setzen       
        meineStage.setResizable(false);//Größenänderungen verhindern       
        meineStage.show();//und anzeigen
    }
    
    public static void main(String[] args) {       
        launch(args);//der Start
        
    }
    
}
Java:
package einsendeaufgaben_JAVA13C;

//für die Klassen Arrays und Collections
import java.util.Arrays;
import java.util.Collections;

import javax.swing.JFrame;
import javax.swing.JOptionPane;

import javafx.scene.control.Button;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.control.Label;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.util.Duration;

public class MemoryFeld extends JFrame {
    private static final long serialVersionUID = -6518774972878710759L;
    /**
     * innere Klasse für den Eventhandler des Timer
     * @author silve
     *
     */
    class TimerHandler implements EventHandler<ActionEvent> {
            @Override
            /**
             * Methode ruft die Methode karteSchliessen() auf
             */
            public void handle(ActionEvent arg0) {
                karteSchliessen();
            }
        }
    
    private MemoryKarte[] karten;//das Array für die 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"};
        
    private int menschPunkte, computerPunkte;//für die Punkte   
    private Label menschPunkteLabel, computerPunkteLabel, esziehtLabel;//zwei Labels für die Punkte
    private String anzeige1, anzeige2;//Aufgabe 2 für die Anzeige wer zieht
    
    private int umgedrehteKarten;//wie viele Karten sind aktuell umgedreht?
        
    private MemoryKarte[] paar;//für das aktuell umdrehte Paar
        
    private int spieler;//für den aktuellen Spieler
            
    private int[][] gemerkteKarten;//das "Gedächtnis" für den Computer, er speichert hier wo das Gegenstück liegt
        
    private int spielstaerke;//für die Spielstärke
        
    private Timeline timer;//für den Timer
    
    //der Konstruktor
    public MemoryFeld() {       
        karten = new MemoryKarte[42];//das Array für die Karten erstellen, insgesamt 42 Stück
        
        paar = new MemoryKarte[2];//für das Paar
                
        gemerkteKarten = new int[2][21];//für das Gedächtnis, es speichert für jede Karte paarweise die Position im Spielfeld
        
        anzeige1 = "Der Mensch"; //Aufgabe 2, für die Bezeichnung wer gerade zieht
        anzeige2 = "Der Computer"; //Aufgabe 2, für die Bezeichnung wer gerade zieht
        
        //keiner hat zu Beginn einen Punkt
        menschPunkte = 0;
        computerPunkte = 0;
                
        umgedrehteKarten = 0;//es ist keine Karte umgedreht
                
        spieler = 0;//der Mensch fängt an
                
        spielstaerke = 0;//die Spielstärke ist 10
        
        //es gibt keine gemerkten Karten
        for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
    }

    /**
     * Methode erstellt die Oberfläche und zeichnet die Karten über eine eigene Methode, übergeben wird ein FlowPane
     */
    public FlowPane initGUI(FlowPane feld) {       
        kartenZeichnen(feld);//für die Ausgaben
        menschPunkteLabel = new Label();
        computerPunkteLabel = new Label();
        esziehtLabel = new Label();//Aufgabe 2
        menschPunkteLabel.setText(Integer.toString(menschPunkte));
        computerPunkteLabel.setText(Integer.toString(computerPunkte));   
        
        Button buttonschummeln = new Button("schummeln");//Aufgabe 3
//hier komme ich nicht weiter, die Aktivierung über den Button bekomme ich nicht hin
        //buttonschummeln.setOnAction(new MemoryKarte.startschummler);//Aufgabe 3
                    
        GridPane tempGrid = new GridPane();//in vier Spalten anzeigen       
        tempGrid.add(new Label("Mensch: "), 0 , 0 );//und einfügen, dabei werden die Koordinaten angegeben
        tempGrid.add(menschPunkteLabel, 1, 0);
        tempGrid.add(new Label("Computer: "), 0, 1);
        tempGrid.add(computerPunkteLabel, 1, 1);
        tempGrid.add(new Label("Es zieht: "), 0, 2 ); //Aufgabe 2
        tempGrid.add(esziehtLabel, 1, 2);//Aufgabe 2
        
        tempGrid.add(buttonschummeln, 0, 3);//Aufgabe 3
                
        feld.getChildren().add(tempGrid);
          
        return feld;
    }

    private void kartenZeichnen(FlowPane feld) {//das eigentliche Spielfeld erstellen
        int count = 0;
        for (int i = 0; i <= 41; i++) {           
            karten[i] = new MemoryKarte(bilder[count], count, this);//eine neue Karte erzeugen           
            if ((i + 1) % 2 == 0)//bei jeder zweiten Karte kommt auch ein neues Bild
                count++;
        }       
        Collections.shuffle(Arrays.asList(karten));//die Karten werden gemischt
        
        for (int i = 0; i <= 41; i++) {//und ins Spielfeld gesetzt
            feld.getChildren().add(karten[i]);           
            karten[i].setBildPos(i);//die Position der Karte setzen
        }
    }
    
    /**
     * Methode übernimmt die wesentliche Steuerung des Spiels
     */   
    public void karteOeffnen(MemoryKarte karte) {//Sie wird beim Anklicken einer Karte ausgeführt       
        int kartenID, kartenPos;//zum Zwischenspeichern der ID und der Position
        
        esziehtLabel.setText((anzeige1));//Aufgabe 2, wenn der Mensch eine Karte anklickt wird angezeigt das der Mensch zieht
        
        paar[umgedrehteKarten]=karte;//die Karten zwischenspeichern
                
        kartenID = karte.getBildID();//die ID und die Position beschaffen
        kartenPos = karte.getBildPos();
                        
        if ((gemerkteKarten[0][kartenID] == -1)) //die Karte in das Gedächtnis des Computers eintragen, aber nur dann, wenn es noch keinen Eintrag an der entsprechenden Stelle gibt
            gemerkteKarten[0][kartenID] = kartenPos;
        else           
            if (gemerkteKarten[0][kartenID] != kartenPos) //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
                gemerkteKarten[1][kartenID] = kartenPos;
        umgedrehteKarten++;//umgedrehte Karten erhöhen
                
        if (umgedrehteKarten == 2) {//sind 2 Karten umgedreht worden?           
            paarPruefen(kartenID);//dann prüfen wir, ob es ein Paar ist           
            timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler()));//den Timer erzeugen           
            timer.play();//und starten
        }
        
        if (computerPunkte + menschPunkte == 21) {//haben wir zusammen 21 Paare, dann ist das Spiel vorbei   
             if (menschPunkte > computerPunkte) {//Aufgabe 1
                JOptionPane.showMessageDialog(this, "Der Mensch hat Gewonnen");
             }
             else {
                JOptionPane.showMessageDialog(this, "Der Computer hat Gewonnen");           
             }
             Platform.exit();
        }
    }
    
    /**
     * Methode dreht die Karten wieder auf die Rückseite, bzw. nimmt sie aus dem Spiel
     */
    private void karteSchliessen() {
        boolean raus = false;       
        if (paar[0].getBildID() == paar[1].getBildID()) //ist es ein Paar?
            raus = true;       
        paar[0].rueckseiteZeigen(raus);//wenn es ein Paar war, nehmen wir die Karten aus dem Spiel, sonst drehen wir sie nur wieder um
        paar[1].rueckseiteZeigen(raus);       
        umgedrehteKarten = 0;//es ist keine Karte mehr geöffnet       
        if (raus == false) { //hat der Spieler kein Paar gefunden?           
            spielerWechseln();//dann wird der Spieler gewechselt
        }
        else                       
            if (spieler == 1)//hat der Computer ein Paar gefunden?, dann ist er noch einmal an der Reihe
                computerZug();
    }
    
    /**
     * Methode prüft, ob ein Paar gefunden wurde
     * @param kartenID
     */
    private void paarPruefen(int kartenID) {
        if (paar[0].getBildID() == paar[1].getBildID()) {           
            paarGefunden();//die Punkte setzen           
            gemerkteKarten[0][kartenID]=-2;//die Karten aus dem Gedächtnis löschen
            gemerkteKarten[1][kartenID]=-2;
        }
    }

    /**
     * Methode setzt die Punkte, wenn ein Paar gefunden wurde
     */
    private void paarGefunden() {       
        if (spieler == 0) {//spielt gerade der Mensch?
            menschPunkte++;
            menschPunkteLabel.setText(Integer.toString(menschPunkte));
        }
        else {
            computerPunkte++;
            computerPunkteLabel.setText(Integer.toString(computerPunkte));
        }
    }
    
    /**
     * Methode wechselt den Spieler
     */
    private void spielerWechseln() {               
        if (spieler == 0) {//wenn der Mensch an der Reihe war, kommt jetzt der Computer
            spieler = 1;
            computerZug();
        }
        else
            spieler = 0;
            
        esziehtLabel.setText(anzeige2);//Aufgabe 2
    }
    
    /**
     * Methode setzt die Computerzüge um
     */
    private void computerZug() {
        int kartenZaehler = 0;
        int zufall = 0;
        boolean treffer = false;       
        if ((int)(Math.random() * spielstaerke) == 0) {//zur Steuerung über die Spielstärke           
            while ((kartenZaehler < 21) && (treffer == false)) {//erst einmal nach einem Paar suchen, dazu durchsuchen wir das Array gemerkteKarten, bis wir in beiden Dimensionen, einen Wert finden               
                if ((gemerkteKarten[0][kartenZaehler] >=0) &&  (gemerkteKarten[1][kartenZaehler] >=0)) {//gibt es in beiden Dimensionen einen Wert größer oder gleich 0?                   
                    treffer = true;//dann haben wir ein Paar                   
                    karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();//die Vorderseite der Karte zeigen                   
                    karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);//und dann die Karte öffnen                   
                    karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();//die zweite Karte auch
                    karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
                }
                kartenZaehler++;
            }
        }       
        if (treffer == false) {//wenn wir kein Paar gefunden haben, drehen wir zufällig zwei Karten um           
            do {//solange eine Zufallszahl suchen, bis eine Karte gefunden wird, die noch im Spiel ist
                zufall = (int)(Math.random() * karten.length);
            } while (karten[zufall].isNochImSpiel() == false);                       
            karten[zufall].vorderseiteZeigen();//die erste Karte umdrehen, die Vorderseite der Karte zeigen           
            karteOeffnen(karten[zufall]);//und dann die Karte öffnen
            
            do {//für die zweite Karte müssen wir außerdem prüfen, ob sie nicht gerade angezeigt wird
                zufall = (int)(Math.random() * karten.length);
            } while ((karten[zufall].isNochImSpiel() == false) || (karten[zufall].isUmgedreht() == true));           
            karten[zufall].vorderseiteZeigen();//und die zweite Karte umdrehen
            karteOeffnen(karten[zufall]);
            esziehtLabel.setText(anzeige2);//Aufgabe 2
        }
    }
    
    /**
     * Methode liefert, ob Züge des Menschen erlaubt sind
     * @return
     */   
    public boolean zugErlaubt() {//die Rückgabe ist false, wenn gerade der Computer zieht, oder wenn schon zwei Karten umgedreht sind sonst ist die Rückgabe true
        boolean erlaubt = true;       
        if (spieler == 1)//zieht der Computer?
            erlaubt = false;       
        if (umgedrehteKarten == 2)//sind schon zwei Karten umdreht?
            erlaubt = false;
        return erlaubt;
    }
    
}
Java:
package einsendeaufgaben_JAVA13C;

import javafx.event.EventHandler;
import javafx.scene.control.Button;
import javafx.scene.image.ImageView;
import javafx.util.Duration;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;


/**
 * Klasse für eine Karte des Memory-Spiels, die erbst von Button
 */
public class MemoryKarte extends Button {
    private int bildID;//die Instanzvariablen, eine eindeutige ID zur Identifizierung des Bildes   
    private ImageView bildVorne, bildHinten;//für die Vorder- und Rückseite
        
    private int bildPos;//wo liegt die Karte im Spielfeld
    
    private boolean umgedreht;//ist die Karte umgedreht?   
    private boolean nochImSpiel;//ist die Karte noch im Spiel?
        
    private MemoryFeld spielfeld;//das Spielfeld für die Karte
    
    private Timeline timer;//für den Timer, Aufgabe 3
    
    /**
     * die innere Klasse für den Eventhandler der Karte
     */
    class KartenHandler implements EventHandler<ActionEvent>{
        @Override
        public void handle(ActionEvent arg0) {
            if ((nochImSpiel == false) || (spielfeld.zugErlaubt() == false))//ist die Karte überhaupt noch im Spiel und sind Züge erlaubt?
                return;           
            if (umgedreht == false) {//wenn die Rückseite zu sehen ist, die Vorderseite anzeigen
                vorderseiteZeigen();
                spielfeld.karteOeffnen(MemoryKarte.this);//die Methode karteOeffnen() im Spielfeld aufrufen, übergeben wird dabei die Karte also die this-Referenz der äußeren Klasse
            }
        }
    }

    //der Konstruktor er setzt die Bilder
    public MemoryKarte(String vorne, int bildID, MemoryFeld spielfeld) {       
        bildVorne = new ImageView(vorne);//die Vorderseite, der Dateiname des Bildes wird an den Konstruktor übergeben       
        bildHinten = new ImageView("grafiken/back.jpg");//die Rückseite, sie wird fest gesetzt
        setGraphic(bildHinten);
        
        startschummler();
                
        this.bildID = bildID;//die Bild-ID         
        umgedreht = false;//die Karte ist erst einmal umgedreht und noch im Feld
        nochImSpiel = true;       
        this.spielfeld = spielfeld;//mit dem Spielfeld verbinden
        
        setOnAction(new KartenHandler());//die Action setzen
    }
    
    public void vorderseiteZeigen() {//Methode zeigt die Vorderseite der Karte an
        setGraphic(bildVorne);
        umgedreht = true;
    }

    public void rueckseiteZeigen(boolean rausnehmen) {//Methode zeigt die Rückseite der Karte an
        if (rausnehmen == true) {//soll die Karten komplett aus dem Spiel genommen werden?           
            setGraphic(new ImageView("grafiken/aufgedeckt.jpg"));//das Bild aufgedeckt zeigen und die Karte aus dem Spiel nehmen
            nochImSpiel = false;
        }
        else {           
            setGraphic(bildHinten);//sonst nur die Rückseite zeigen
            umgedreht = false;
        }
    }
        
    public int getBildID() {//die Methode liefert die Bild-ID einer Karte
        return bildID;
    }
    
    public int getBildPos() {//die Methode liefert die Position einer Karte
        return bildPos;
    }
        
    public void setBildPos(int bildPos) {//die Methode setzt die Position einer Karte
        this.bildPos = bildPos;
    }
        
    public boolean isUmgedreht() {//die Methode liefert den Wert der Variablen umgedreht
        return umgedreht;
    }
    
    public boolean isNochImSpiel() {//die Methode liefert den Wert der Variablen nochImSpiel
        return nochImSpiel;
    }
    
//Made by Dennis Aufgabe 3       
    public void startschummler() {//Methode um den Timer zu starten für Aufgabe 3
        timer = new Timeline(new KeyFrame(Duration.millis(1000), new TimerSchummlerPhase1()));   
        timer.play();//und starten
    }
    
//Made by Dennis Aufgabe 3       
        class TimerSchummlerPhase1 implements EventHandler<ActionEvent> {                             
            public void handle(ActionEvent arg0) {//hier werden alle Karten für 2 Sekunden angezeigt   
                vorderseiteZeigen();
                timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerSchummlerPhase2()));//den Timer erzeugen           
                timer.play();//und starten
                }
        }
            
        class TimerSchummlerPhase2 implements EventHandler<ActionEvent> {                         
            public void handle(ActionEvent arg0) {//nach den 2 Sekunden wird wieder Rückseite angeseigt               
                rueckseiteZeigen(false);
                }
        }       
    
}
 

Anhänge

Hey Mihe7,

danke, jedoch klappt dein Vorschlag nicht.
Ich könnte die Methode in static abändern,

12865

aber dann kann ich die darauf folgende Klasse nicht aktivieren
12866
 
Bitte nicht ständig alles static machen! Du kannst davon ausgehen, dass das eigentlich immer falsch ist.

Stell Dir die Instanzen wie richtige Objekte vor! Du hast ein Objekt vom Typ MemoryFeld. Und in dem Objekt sind unter anderem alle Karten vom Typ MemoryKarte.

Und wenn Du da so einen Überblick hast: Dann musst Du überlegen, wo etwas hin gehört. Was bedeutet dieses Schummeln denn? Ist das etwas, was mit einer (einzelnen) Karte zusammen hängt? Oder hängt das eher mit dem ganzen MemoryFeld zusammen?
Zur Not: Immer in Worten genau beschreiben, was überhaupt passieren soll!
 
Bitte nicht ständig alles static machen! Du kannst davon ausgehen, dass das eigentlich immer falsch ist.

Stell Dir die Instanzen wie richtige Objekte vor! Du hast ein Objekt vom Typ MemoryFeld. Und in dem Objekt sind unter anderem alle Karten vom Typ MemoryKarte.

Und wenn Du da so einen Überblick hast: Dann musst Du überlegen, wo etwas hin gehört. Was bedeutet dieses Schummeln denn? Ist das etwas, was mit einer (einzelnen) Karte zusammen hängt? Oder hängt das eher mit dem ganzen MemoryFeld zusammen?
Zur Not: Immer in Worten genau beschreiben, was überhaupt passieren soll!
Hey JustNobody,

die ganz genauen Worte stehen ganz oben zu meinem ersten Beitrag, mit Code und Bilder.
Genauer und ausführlicher kann ich es nicht erklären.

Um deine Frage zu beantworten, ja es soll das ganze MemoryFeld für einen kleinen Zeitraum aufgedeckt werden, nur das ist nicht das Problem, wie im Code zu sehen habe ich das bereits geschafft. Ich bekomme es nur nicht hin, die Funktion mit dem Schummelbutton zu verbinden.

Ich hatte auch bereits den Vorschlag von "mihe7" umgesetzt, nur leider funktioniert dieser nicht.

Lieben Gruß
Dennis
 
Ich hatte auch bereits den Vorschlag von "@mihe7" umgesetzt, nur leider funktioniert dieser nicht.
Funktioniert:

Java:
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;

public class Test extends Application {

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("javafx-skeleton");

        Button button = new Button("Button");
        BorderPane panel = new BorderPane();
        panel.setCenter(button);

        button.setOnAction(e -> schummeln());
        Scene scene = new Scene(panel, 200, 200);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void schummeln() {
        System.out.println("Geschummelt!");
    }
}
 
die ganz genauen Worte stehen ganz oben zu meinem ersten Beitrag, mit Code und Bilder.
Das ist die Aufgabe. Es geht aber doch um das Verständnis. Was ist Dein genaues Verständnis? Daher ist es wichtig, dass Du immer mit eigenen Worten erläuterst, was Du im Code versuchst. Ein "da Aufgabe, da Code" hilft nicht, deine Denkfehler aufzuspüren um Dir dann die kritischen Punkte zu erläutern!

Um deine Frage zu beantworten, ja es soll das ganze MemoryFeld für einen kleinen Zeitraum aufgedeckt werden, nur das ist nicht das Problem, wie im Code zu sehen habe ich das bereits geschafft. Ich bekomme es nur nicht hin, die Funktion mit dem Schummelbutton zu verbinden.
Wenn also mit allen Karten des MemoryFeldes etwas gemacht werden soll (was die Karten schon können - umdrehen und so kannst Du mit den Karten ja schon machen.): In welche Klasse gehört dann die Methode, die das Schummeln macht?

Ich hatte auch bereits den Vorschlag von "mihe7" umgesetzt, nur leider funktioniert dieser nicht.
Das hast Du probiert, nur eben hast Du da aus meiner Sicht einen klaren Denkfehler, auf den ich oben mit der Frage, in welche Klasse der Code gehört, hinaus will.

Und der Hinweis mit dem static kann ich nur noch einmal wiederholen: Wenn etwas nicht geht, dann ist "es static machen" in der Regel NIE die Lösung.

Das Problem bei Ihm ist doch, dass er Code an die falsche Stelle packt. Da bringt so ein Test-Code auch relativ wenig. Schummeln in die richtige Klasse geschoben und ohne static und schon klappt der Aufruf. Man muss natürlich die Methode anpassen, so dass sie eben "... das ganze MemoryFeld für einen kleinen Zeitraum aufgedeckt ..." um einfach einen Auszug zu bringen.
 
Funktioniert:

Java:
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;

public class Test extends Application {

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("javafx-skeleton");

        Button button = new Button("Button");
        BorderPane panel = new BorderPane();
        panel.setCenter(button);

        button.setOnAction(e -> schummeln());
        Scene scene = new Scene(panel, 200, 200);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void schummeln() {
        System.out.println("Geschummelt!");
    }
}
Hey @mihe7 ,
bekommst du das auch mit meinem Code hin, ich nämlich nicht, ich weiß auch nicht woran es liegt?

Vielen Dank im Voraus
 
Ok, dann mach doch einfach einmal folgendes:
In MemoryFeld erzeugst Du eine Methode schummeln() und genau die rufst Du einfach mit Deinem Schummel Knopf auf.

Aus der MemoryKarte entfernst Du den ganzen Schummel-Code ...

In MemoryFeld schummeln gehst Du dann alle Karten durch: Ist diese noch im Spiel, dann drehst Du diese um.
Danach kommt dann ein Timer, der undoSchummeln oder so aufruft. Kannst Du so benennen, wie Du willst.
undoSchummeln geht dann wieder alle Karten durch: Ist diese noch im Spiel, dann drehst du diese zurück.

Kriegst Du das hin?
 
Das ist die Aufgabe. Es geht aber doch um das Verständnis. Was ist Dein genaues Verständnis? Daher ist es wichtig, dass Du immer mit eigenen Worten erläuterst, was Du im Code versuchst. Ein "da Aufgabe, da Code" hilft nicht, deine Denkfehler aufzuspüren um Dir dann die kritischen Punkte zu erläutern!



Wenn also mit allen Karten des MemoryFeldes etwas gemacht werden soll (was die Karten schon können - umdrehen und so kannst Du mit den Karten ja schon machen.): In welche Klasse gehört dann die Methode, die das Schummeln macht?


Das hast Du probiert, nur eben hast Du da aus meiner Sicht einen klaren Denkfehler, auf den ich oben mit der Frage, in welche Klasse der Code gehört, hinaus will.

Und der Hinweis mit dem static kann ich nur noch einmal wiederholen: Wenn etwas nicht geht, dann ist "es static machen" in der Regel NIE die Lösung.


Das Problem bei Ihm ist doch, dass er Code an die falsche Stelle packt. Da bringt so ein Test-Code auch relativ wenig. Schummeln in die richtige Klasse geschoben und ohne static und schon klappt der Aufruf. Man muss natürlich die Methode anpassen, so dass sie eben "... das ganze MemoryFeld für einen kleinen Zeitraum aufgedeckt ..." um einfach einen Auszug zu bringen.
Der Schummelcode ist in der Klasse "MemoryKarte"
der Code ist als "//Made by Dennis Aufgabe 3" kommentiert, quasi die letzten drei Methoden bzw. inneren Klassen
 
Ok, dann mach doch einfach einmal folgendes:
In MemoryFeld erzeugst Du eine Methode schummeln() und genau die rufst Du einfach mit Deinem Schummel Knopf auf.

Aus der MemoryKarte entfernst Du den ganzen Schummel-Code ...

In MemoryFeld schummeln gehst Du dann alle Karten durch: Ist diese noch im Spiel, dann drehst Du diese um.
Danach kommt dann ein Timer, der undoSchummeln oder so aufruft. Kannst Du so benennen, wie Du willst.
undoSchummeln geht dann wieder alle Karten durch: Ist diese noch im Spiel, dann drehst du diese zurück.

Kriegst Du das hin?
@JustNobody ,

dein Vorschlag verstehe ich, jedoch weiß ich nicht wie ich es umsetzen soll.
Seit drei Tagen versuche ich die Verbindung vom Button zum unterem Code herzustellen, jedoch schaffe ich es nicht.
Der Button ist in der Klasse "MemoryFeld" und der folgende Code in der Klasse "MemoryKarte".

Der folgende Code läuft bereits, sobald das Programm startet läuft auch die Methode durch, da ich die Anweisung "startschummler();" im Konstruktor angegeben habe, nun möchte ich das der folgende Code nicht über den Konstruktor läuft sondern über ein Button.

Code:
//Made by Dennis Aufgabe 3       
    public void startschummler() {//Methode um den Timer zu starten für Aufgabe 3
        timer = new Timeline(new KeyFrame(Duration.millis(1000), new TimerSchummlerPhase1()));   
        timer.play();//und starten
    }
    
//Made by Dennis Aufgabe 3       
        //innere Klasse für den Timer
        class TimerSchummlerPhase1 implements EventHandler<ActionEvent> {                             
            public void handle(ActionEvent arg0) {//hier werden alle Karten für 2 Sekunden angezeigt   
                vorderseiteZeigen();
                timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerSchummlerPhase2()));//den Timer erzeugen           
                timer.play();//und starten
                }
        }
        
        //innere Klasse für den Timer
        class TimerSchummlerPhase2 implements EventHandler<ActionEvent> {                         
            public void handle(ActionEvent arg0) {//nach den 2 Sekunden wird wieder Rückseite angeseigt               
                rueckseiteZeigen(false);
                }
        }
 

Anhänge

Der Schummelcode ist in der Klasse "MemoryKarte"
Und das ist doch der Knackpunkt. Da gehört der Code (meiner Meinung nach) nicht hin und der Versuch, es zwanghaft woanders hin zu packen führt zu Problemen ....

Beispiel aus der Realität:

Der TÜV prüft Autos. Da macht der TÜV also gewisse Tests. Was und wie der TÜV aber macht ist rein Sache des TÜVs. Das gehört nicht ins Auto. Das Auto hat nur sein ganz normales Verhalten. Und da fängt der TÜV nicht an, irgendwas am Auto zu basteln.

So ist es auch hier: Das Spiel (Bei dir ist die Logik in MemoryFeld) nutzt die Karten einfach nur. Und daher: Das "Schummeln" ist eine Funktion des Spieles und daher gehört es auch in die Klasse MemoryFeld.

Oder wenn man das Pferd rein praktisch aufsatteln möchte:
Frage: Wo ist der Button? -> in MemoryFeld (in einer Instanz von MemoryFeld um genau zu sein!)
Also kannst Du in MemoryFeld eine Methode schreiben, die beim Drücken des Buttons aufgerufen wird.
Somit bist du bei einer Methode schummeln() in MemoryFeld.
Jetzt kannst Du Dir überlegen, ob Du auf alles Zugriff hast, das Du brauchst. Du brauchst Zugriff auf die Karten.
Hast Du die? --> Ja, Karten sind vorhanden und ansprechbar.
Kannst Du Karten identifizieren, die umgedreht werden müssen? --> ....

Da breche ich einmal ab - aber so könnte man auch das Problem etwas angehen.

Und ich habe oben erwähnt, dass "der Versuch, es zwanghaft woanders hin zu packen führt zu Problemen ....":
Du bist in einer Methode schummeln in MemoryKarte. Die ist auch noch statisch.
Hast Du Zugriff auf die Ressourcen, die Du benötigst? --> Nein, hast Du nicht.

Ich habe durchaus Verständnis dafür, wie Du da hin gekommen bist: Du hast halt dieses Schummeln erst an einzelnen Karten "probiert". Dadurch ist das Code in der Karte gelandet, wenn eine einzelne Karte kann so umgedreht werden. Da brauchst Du nichts anderes. Aber leider bist Du so in einer Sackgasse gelandet. Habe ich es geschafft, Dir diese Problematik etwas zu verdeutlichen?

(Ich habe da gerade Probleme, weitere Ansätze zu finden und weiß nicht genau, was ich noch probieren kann. Das ist aber nicht Dein Problem/Schuld/Was auch immer. Ich denke, dass es im direkten Kontakt einfacher zu erläutern wäre und ich einfach nur daran scheitere, mich verständlicher auszudrücken....)

Und evtl. einmal den Code Deiner Klasse etwas angepasst - ich habe aber nur den Code von mihe7 eingebaut:

Java:
package einsendeaufgaben_JAVA13C;

//für die Klassen Arrays und Collections
import java.util.Arrays;
import java.util.Collections;

import javax.swing.JFrame;
import javax.swing.JOptionPane;

import javafx.scene.control.Button;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.control.Label;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.util.Duration;

public class MemoryFeld extends JFrame {
    private static final long serialVersionUID = -6518774972878710759L;
    /**
     * innere Klasse für den Eventhandler des Timer
     * @author silve
     *
     */
    class TimerHandler implements EventHandler<ActionEvent> {
            @Override
            /**
             * Methode ruft die Methode karteSchliessen() auf
             */
            public void handle(ActionEvent arg0) {
                karteSchliessen();
            }
        }
    
    private MemoryKarte[] karten;//das Array für die 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"};
        
    private int menschPunkte, computerPunkte;//für die Punkte   
    private Label menschPunkteLabel, computerPunkteLabel, esziehtLabel;//zwei Labels für die Punkte
    private String anzeige1, anzeige2;//Aufgabe 2 für die Anzeige wer zieht
    
    private int umgedrehteKarten;//wie viele Karten sind aktuell umgedreht?
        
    private MemoryKarte[] paar;//für das aktuell umdrehte Paar
        
    private int spieler;//für den aktuellen Spieler
            
    private int[][] gemerkteKarten;//das "Gedächtnis" für den Computer, er speichert hier wo das Gegenstück liegt
        
    private int spielstaerke;//für die Spielstärke
        
    private Timeline timer;//für den Timer
    
    //der Konstruktor
    public MemoryFeld() {       
        karten = new MemoryKarte[42];//das Array für die Karten erstellen, insgesamt 42 Stück
        
        paar = new MemoryKarte[2];//für das Paar
                
        gemerkteKarten = new int[2][21];//für das Gedächtnis, es speichert für jede Karte paarweise die Position im Spielfeld
        
        anzeige1 = "Der Mensch"; //Aufgabe 2, für die Bezeichnung wer gerade zieht
        anzeige2 = "Der Computer"; //Aufgabe 2, für die Bezeichnung wer gerade zieht
        
        //keiner hat zu Beginn einen Punkt
        menschPunkte = 0;
        computerPunkte = 0;
                
        umgedrehteKarten = 0;//es ist keine Karte umgedreht
                
        spieler = 0;//der Mensch fängt an
                
        spielstaerke = 0;//die Spielstärke ist 10
        
        //es gibt keine gemerkten Karten
        for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
    }

    // Code von mihe7 kopiert als ersten Ansatz ....
    private void schummeln() {
        System.out.println("Geschummelt!");
    }

    /**
     * Methode erstellt die Oberfläche und zeichnet die Karten über eine eigene Methode, übergeben wird ein FlowPane
     */
    public FlowPane initGUI(FlowPane feld) {       
        kartenZeichnen(feld);//für die Ausgaben
        menschPunkteLabel = new Label();
        computerPunkteLabel = new Label();
        esziehtLabel = new Label();//Aufgabe 2
        menschPunkteLabel.setText(Integer.toString(menschPunkte));
        computerPunkteLabel.setText(Integer.toString(computerPunkte));   
        
        Button buttonschummeln = new Button("schummeln");//Aufgabe 3
        buttonschummeln.setOnAction(e->schummeln());// 1:1 von mihe7 übernommen!
                    
        GridPane tempGrid = new GridPane();//in vier Spalten anzeigen       
        tempGrid.add(new Label("Mensch: "), 0 , 0 );//und einfügen, dabei werden die Koordinaten angegeben
        tempGrid.add(menschPunkteLabel, 1, 0);
        tempGrid.add(new Label("Computer: "), 0, 1);
        tempGrid.add(computerPunkteLabel, 1, 1);
        tempGrid.add(new Label("Es zieht: "), 0, 2 ); //Aufgabe 2
        tempGrid.add(esziehtLabel, 1, 2);//Aufgabe 2
        
        tempGrid.add(buttonschummeln, 0, 3);//Aufgabe 3
                
        feld.getChildren().add(tempGrid);
          
        return feld;
    }

    private void kartenZeichnen(FlowPane feld) {//das eigentliche Spielfeld erstellen
        int count = 0;
        for (int i = 0; i <= 41; i++) {           
            karten[i] = new MemoryKarte(bilder[count], count, this);//eine neue Karte erzeugen           
            if ((i + 1) % 2 == 0)//bei jeder zweiten Karte kommt auch ein neues Bild
                count++;
        }       
        Collections.shuffle(Arrays.asList(karten));//die Karten werden gemischt
        
        for (int i = 0; i <= 41; i++) {//und ins Spielfeld gesetzt
            feld.getChildren().add(karten[i]);           
            karten[i].setBildPos(i);//die Position der Karte setzen
        }
    }
    
    /**
     * Methode übernimmt die wesentliche Steuerung des Spiels
     */   
    public void karteOeffnen(MemoryKarte karte) {//Sie wird beim Anklicken einer Karte ausgeführt       
        int kartenID, kartenPos;//zum Zwischenspeichern der ID und der Position
        
        esziehtLabel.setText((anzeige1));//Aufgabe 2, wenn der Mensch eine Karte anklickt wird angezeigt das der Mensch zieht
        
        paar[umgedrehteKarten]=karte;//die Karten zwischenspeichern
                
        kartenID = karte.getBildID();//die ID und die Position beschaffen
        kartenPos = karte.getBildPos();
                        
        if ((gemerkteKarten[0][kartenID] == -1)) //die Karte in das Gedächtnis des Computers eintragen, aber nur dann, wenn es noch keinen Eintrag an der entsprechenden Stelle gibt
            gemerkteKarten[0][kartenID] = kartenPos;
        else           
            if (gemerkteKarten[0][kartenID] != kartenPos) //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
                gemerkteKarten[1][kartenID] = kartenPos;
        umgedrehteKarten++;//umgedrehte Karten erhöhen
                
        if (umgedrehteKarten == 2) {//sind 2 Karten umgedreht worden?           
            paarPruefen(kartenID);//dann prüfen wir, ob es ein Paar ist           
            timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler()));//den Timer erzeugen           
            timer.play();//und starten
        }
        
        if (computerPunkte + menschPunkte == 21) {//haben wir zusammen 21 Paare, dann ist das Spiel vorbei   
             if (menschPunkte > computerPunkte) {//Aufgabe 1
                JOptionPane.showMessageDialog(this, "Der Mensch hat Gewonnen");
             }
             else {
                JOptionPane.showMessageDialog(this, "Der Computer hat Gewonnen");           
             }
             Platform.exit();
        }
    }
    
    /**
     * Methode dreht die Karten wieder auf die Rückseite, bzw. nimmt sie aus dem Spiel
     */
    private void karteSchliessen() {
        boolean raus = false;       
        if (paar[0].getBildID() == paar[1].getBildID()) //ist es ein Paar?
            raus = true;       
        paar[0].rueckseiteZeigen(raus);//wenn es ein Paar war, nehmen wir die Karten aus dem Spiel, sonst drehen wir sie nur wieder um
        paar[1].rueckseiteZeigen(raus);       
        umgedrehteKarten = 0;//es ist keine Karte mehr geöffnet       
        if (raus == false) { //hat der Spieler kein Paar gefunden?           
            spielerWechseln();//dann wird der Spieler gewechselt
        }
        else                       
            if (spieler == 1)//hat der Computer ein Paar gefunden?, dann ist er noch einmal an der Reihe
                computerZug();
    }
    
    /**
     * Methode prüft, ob ein Paar gefunden wurde
     * @param kartenID
     */
    private void paarPruefen(int kartenID) {
        if (paar[0].getBildID() == paar[1].getBildID()) {           
            paarGefunden();//die Punkte setzen           
            gemerkteKarten[0][kartenID]=-2;//die Karten aus dem Gedächtnis löschen
            gemerkteKarten[1][kartenID]=-2;
        }
    }

    /**
     * Methode setzt die Punkte, wenn ein Paar gefunden wurde
     */
    private void paarGefunden() {       
        if (spieler == 0) {//spielt gerade der Mensch?
            menschPunkte++;
            menschPunkteLabel.setText(Integer.toString(menschPunkte));
        }
        else {
            computerPunkte++;
            computerPunkteLabel.setText(Integer.toString(computerPunkte));
        }
    }
    
    /**
     * Methode wechselt den Spieler
     */
    private void spielerWechseln() {               
        if (spieler == 0) {//wenn der Mensch an der Reihe war, kommt jetzt der Computer
            spieler = 1;
            computerZug();
        }
        else
            spieler = 0;
            
        esziehtLabel.setText(anzeige2);//Aufgabe 2
    }
    
    /**
     * Methode setzt die Computerzüge um
     */
    private void computerZug() {
        int kartenZaehler = 0;
        int zufall = 0;
        boolean treffer = false;       
        if ((int)(Math.random() * spielstaerke) == 0) {//zur Steuerung über die Spielstärke           
            while ((kartenZaehler < 21) && (treffer == false)) {//erst einmal nach einem Paar suchen, dazu durchsuchen wir das Array gemerkteKarten, bis wir in beiden Dimensionen, einen Wert finden               
                if ((gemerkteKarten[0][kartenZaehler] >=0) &&  (gemerkteKarten[1][kartenZaehler] >=0)) {//gibt es in beiden Dimensionen einen Wert größer oder gleich 0?                   
                    treffer = true;//dann haben wir ein Paar                   
                    karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();//die Vorderseite der Karte zeigen                   
                    karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);//und dann die Karte öffnen                   
                    karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();//die zweite Karte auch
                    karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
                }
                kartenZaehler++;
            }
        }       
        if (treffer == false) {//wenn wir kein Paar gefunden haben, drehen wir zufällig zwei Karten um           
            do {//solange eine Zufallszahl suchen, bis eine Karte gefunden wird, die noch im Spiel ist
                zufall = (int)(Math.random() * karten.length);
            } while (karten[zufall].isNochImSpiel() == false);                       
            karten[zufall].vorderseiteZeigen();//die erste Karte umdrehen, die Vorderseite der Karte zeigen           
            karteOeffnen(karten[zufall]);//und dann die Karte öffnen
            
            do {//für die zweite Karte müssen wir außerdem prüfen, ob sie nicht gerade angezeigt wird
                zufall = (int)(Math.random() * karten.length);
            } while ((karten[zufall].isNochImSpiel() == false) || (karten[zufall].isUmgedreht() == true));           
            karten[zufall].vorderseiteZeigen();//und die zweite Karte umdrehen
            karteOeffnen(karten[zufall]);
            esziehtLabel.setText(anzeige2);//Aufgabe 2
        }
    }
    
    /**
     * Methode liefert, ob Züge des Menschen erlaubt sind
     * @return
     */   
    public boolean zugErlaubt() {//die Rückgabe ist false, wenn gerade der Computer zieht, oder wenn schon zwei Karten umgedreht sind sonst ist die Rückgabe true
        boolean erlaubt = true;       
        if (spieler == 1)//zieht der Computer?
            erlaubt = false;       
        if (umgedrehteKarten == 2)//sind schon zwei Karten umdreht?
            erlaubt = false;
        return erlaubt;
    }
    
}
D.h. da hast Du nun eine Methode schummeln(), in der erst einmal nur eine Ausgabe steht.

Da kannst Du evtl. nun abprüfen:
- Ist der Spieler gerade dran? (Nur dann soll es funktionieren.)
- Alle Karten, die noch verdeckt sind, umdrehen.
- Timer starten, damit nach gewünschter Zeit wieder die umgedrehten Karten zurück gedreht werden.
 
Also ich führe Dich jetzt gerne ganz langsam Schritt für Schritt bis zur Lösung. Eine fertige Lösung werde ich Dir aber nicht hin knallen. Durch die einzelnen Schritt wirst Du aber die Lösung auch schnell bekommen.

a) Prüfen des aktuellen Standes:
Hast Du den Code denn erst einmal so übernommen, wie ich ihn gepostet habe? Funktioniert es, dass Du dann die Ausgabe "geschummelt" bekommst?

n) Wenn das funktioniert, dann können wir den nächsten Schritt angehen. In dem möchte ich mich diesem Teil der Aufgabe stellen: "Sorgen Sie dafür, dass die „Schummel“-Funktion nur dann aufgerufen werden kann, wenn gerade der Mensch am Zug ist".
(Bitte wirklich nur diesen kleinen Part angehen. Immer wirklich ein Feature nach dem anderen!)

Der erste Schritt wäre jetzt, dass Du prüfst: Ist der Spieler / Mensch gerade dran oder der Computer. Hast Du eine Idee, wie man dies einbauen könnte? Wir brauchen dazu eine Bedingung. Der Code sieht dann z.B. so aus:

Java:
    private void schummeln() {
        // Wir lassen die Meldung erst einmal für Dich drinnen. Dann siehst Du, wenn es ausgeführt wird.
        System.out.println("Geschummelt!");
        
        if (!istMenschDran()) {
            System.out.println("Sorry - Du bist derzeit nicht dran. Warte, bis Du dran bist!");
            return; // Dadurch brechen wir die Methode hier ab.
        }

        // Hier geht es dann später weiter...
        
        System.out.println("Jetzt schummeln wir...");
    }
Also entweder bauen wir uns die Methode istMenschDran() oder wir ersetzen diesen Aufruf.

Wenn Du meinst, dass Du eine Lösung dafür hast:
Zum Test einfach einmal den Knopf drücken, wenn Du dran bist. Dann sollte an Ausgabe kommen:
Geschummelt!
Jetzt schummeln wir....
Den Knopf drücken, wenn der Computer dran ist, können wir so derzeit nicht testen. Um das zu testen setzt du einmal im Konstruktor spieler = 1 und startest das Spiel um den Schummel Knopf zu drücken (sonst nichts anderes probieren!).
Dann sollte ausgegeben werden
Geschummelt!
Sorry - Du bist derzeit nicht dran. Warte, bis Du dran bist!
==> Nicht vergessen, die Initialisierung wieder nach dem Test auf spieler = 0 zu setzen!
 
Die Idee war, dass er das anhand des Testcodes erkennt :(
Sorry, das hatte ich so nicht erkannt. Und ich war irgendwie genervt, weil die Ansätze scheinbar nicht richtig verstanden wurden und mir etwas die Ideen ausgingen. Hätte da evtl. erst mal selbst eine Pause machen sollen statt zu schreiben.

@Java11.03.2019 Das geht nicht gegen Dich. Du versuchst es ja zu verstehen und zu einer Lösung zu kommen. Das sehe ich und daher sind das keine Vorwürfe gegen Dich oder Dein Verhalten. Will ich nur noch einmal unterstreichen.... Den Spruch von wegen "Es gibt keine dummen Fragen..." kennst Du ja bestimmt. Daher: Du bist hier auch mit dieser Frage herzlich willkommen und wir versuchen gerne, Dir weiter zu helfen.
 
Sorry, das hatte ich so nicht erkannt. Und ich war irgendwie genervt, weil die Ansätze scheinbar nicht richtig verstanden wurden und mir etwas die Ideen ausgingen. Hätte da evtl. erst mal selbst eine Pause machen sollen statt zu schreiben.
Kein Problem. Mein Smiley war auch nicht auf Deinen Kommentar gemünzt, sondern darauf, dass irgendwie nichts von @Java11.03.2019 kommt. Ich hätte da z. B. etwas wie den Code aus #12 erwartet. Oder für Deinen groben Algorithmus aus #12 irgendein Stück Code wie in #14. Irgendwas, wo man mal den Versuch eines Ansatzes sieht...
 
@JustNobody

gerne auch so, danke für deine Unterstützung und für deine ausführliche Beschreibung.
Ich dachte mir fehle nicht mehr viel und ich wollte den Weg nicht nochmal neu gehen, jedoch wenns nicht geht dann gehts nicht. Deine Erklärung zu dem TÜV war sehr schlüssig :)

Wie folgt der angepasste Code
Java:
private void schummlen() {//Aufgabe 3
            System.out.println("geschummelt");
          
            if (spieler == 1) {
                System.out.println("Du bist derzeit nicht dran, Warte bist du dran bist");
            }
          
        }
 
Zuletzt bearbeitet:
Sehr schön. Da es aber eine Abbruch-Bedingung für das Schummeln ist, muss das return da noch mit rein.

Kommen wir zum nächsten Punkt: "die „Schummel“-Funktion nur dann aufgerufen werden kann, wenn keine andere Karte angezeigt wird." Was kann man da für eine Bedingung prüfen? Woran erkennst Du, dass schon eine Karte aufgedeckt ist?

Java:
private void schummlen() {//Aufgabe 3
            System.out.println("geschummelt");
          
            if (spieler == 1) {
                System.out.println("Du bist derzeit nicht dran, Warte bist du dran bist");
                return;
            }
    
            if (karteAufgedeckt()) {
                System.out.println("Du hast schon eine Karte aufgedeckt und kannst daher nicht mehr schummeln!");
                return;
           }
          
        }
 
eine Frage dazu, dein Gedanke eine Methode zwischen zu schalten finde ich gut, da es besser zu lesen wäre
wie würde dafür die Methode aussehen?

wie folgt der Code
Java:
        private void schummlen() {//Aufgabe 3
            System.out.println("geschummelt");
            
            if (spieler == 1) {//wenn der Computer dran ist
                System.out.println("Du bist derzeit nicht dran, warte bist du dran bist");
                return;
            }
            
            if (umgedrehteKarten == 1) {//wenn der Mensch dran ist
                System.out.println("Du hast schon eine Karte aufgedeckt und kannst daher nicht mehr schummeln");
                return;
            }
            
        }
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben