Memory-Spiel Aktivierung der Methode mit Timer

J

Java11.03.2019

Mitglied
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

  • grafiken.zip
    65,6 KB · Aufrufe: 6
J

Java11.03.2019

Mitglied
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
 
kneitzel

kneitzel

Top Contributor
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!
 
J

Java11.03.2019

Mitglied
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
 
mihe7

mihe7

Top Contributor
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!");
    }
}
 
kneitzel

kneitzel

Top Contributor
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.
 
J

Java11.03.2019

Mitglied
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
 
kneitzel

kneitzel

Top Contributor
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?
 
J

Java11.03.2019

Mitglied
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
 
J

Java11.03.2019

Mitglied
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

  • 1578928191651.png
    1578928191651.png
    33,5 KB · Aufrufe: 3
kneitzel

kneitzel

Top Contributor
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.
 
kneitzel

kneitzel

Top Contributor
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!
 
mihe7

mihe7

Top Contributor
kneitzel

kneitzel

Top Contributor
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.
 
mihe7

mihe7

Top Contributor
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...
 
J

Java11.03.2019

Mitglied
@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:
kneitzel

kneitzel

Top Contributor
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;
           }
          
        }
 
J

Java11.03.2019

Mitglied
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;
            }
            
        }
 
kneitzel

kneitzel

Top Contributor
Der Schritt ist auch in Ordnung. Und ja - ich liebe es, so Dinge in Methoden zu schieben, da der Code dadurch lesbarer wird. Im Clean Code gibt es diesbezüglich einige Aussagen. Wenn dich das Thema interessiert, dann kannst Du später z.B. einmal clean-code-developer.de ansehen.

Der Code mit Methoden könnte dann z.B. so aussehen:
Java:
        public boolean istSpielerDran() {
            return spieler == 0;
        }
        public boolean istComputerDran() {
            return spieler == 1;
        }

        public boolean hatKartenUmgedreht() {
            return umgedrehteKarten != 0;
        }

        private void schummlen() {//Aufgabe 3
            System.out.println("geschummelt");
            
            if (!istSpielerDran()) {
                System.out.println("Du bist derzeit nicht dran, warte bist du dran bist");
                return;
            }
            
            if (hatKartenUmgedreht) {
                System.out.println("Du hast schon eine Karte aufgedeckt und kannst daher nicht mehr schummeln");
                return;
            }
            
            // Jetzt wollen wir alle Karten durchgehen 
            // und jede Karte prüfen, ob die Karte noch im Spiel ist.
        }

Der nächste Schritt ist da schon einmal als Kommentar angegeben. Sogar zwei Schritte.

Wir haben ja alle Karten in der Klasse gespeichert ... jetzt wollen wir alle Karten einmal durchgehen. Dazu brauchen wir einen Code.

Code:
Schleife Über alle Karten {
    // Erst noch nichts machen ...
}

Und wenn Du den Code hast, dann brauchen wir eine Prüfung, ob die Karte noch im Spiel ist.
Code:
Schleife Über alle Karten {
    if (karte.istKarteImSpiel()) {
        // Erst noch nichts machen ...
    }
}

==> Achtung: Hier musst du dann auch die Klasse von der Karte anpassen. Wenn Du ein private Feld mit einer Information hast, dann kannst Du da z.B. ein Getter erstellen oder eine andere Methode, die public ist, damit Du Zugriff hast. Das Feld selbst bleibt private.

Und wenn Du das auch noch hast: die nächsten Schritte, die Du Dir überlegen kannst:

3. Schritt: Jede Karte, die noch im Spiel ist, wird aufgedeckt.

4. Schritt: Wenn Du mit der Schleife fertig bist, brauchen wir einen Timer, damit nach einer gewissen Zeit die Karten wieder umgedreht werden. Also brauchen wir so einen Timer, wie Du zuerst bei der Karte mit eingebaut hattest.

5. Schritt: In der Methode, die dann durchläuft, gehst Du wieder alle Karten durch (Siehe erster Schritt in diesem Post! Kannst Du also 1:1 übernehmen)

6. Schritt: Du prüft die Karte, ob sie noch im Spiel ist (Siehe Schritt 2!)

7. Schritt: Wenn die Karte noch im Spiel ist, drehst Du sie zurück.

Jetzt ganz wichtig: Mach wirklich jeden Schritt einen nach dem anderen. Wenn Du auf ein Problem stößt: Direkt melden. Ich selbst bin leider nebenher auch etwas beschäftigt, so dass ich das doch deutlich zeitversetzter sehe, so dass ich Dir die Chance geben will, da nicht ständig auf mich warten zu müssen....
 
J

Java11.03.2019

Mitglied
Leider bin ich mir hiermit nicht sicher...
Java:
for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
 
kneitzel

kneitzel

Top Contributor
Leider bin ich mir hiermit nicht sicher...
Java:
for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
Da fehlt mir jetzt gerade der genaue Kontext.

Nach meinem Verständnis ist gemerkteKarten doch nur ein "Gedächtnis" für den Computer. Das musst Du beim Mogeln nicht mit anpacken.

Oder um was geht es Dir dabei? Welchen Teil der Aufgabe willst Du so anpassen?
 
J

Java11.03.2019

Mitglied
Der Schritt ist auch in Ordnung. Und ja - ich liebe es, so Dinge in Methoden zu schieben, da der Code dadurch lesbarer wird. Im Clean Code gibt es diesbezüglich einige Aussagen. Wenn dich das Thema interessiert, dann kannst Du später z.B. einmal clean-code-developer.de ansehen.

Der Code mit Methoden könnte dann z.B. so aussehen:
Java:
        public boolean istSpielerDran() {
            return spieler == 0;
        }
        public boolean istComputerDran() {
            return spieler == 1;
        }

        public boolean hatKartenUmgedreht() {
            return umgedrehteKarten != 0;
        }

        private void schummlen() {//Aufgabe 3
            System.out.println("geschummelt");
           
            if (!istSpielerDran()) {
                System.out.println("Du bist derzeit nicht dran, warte bist du dran bist");
                return;
            }
           
            if (hatKartenUmgedreht) {
                System.out.println("Du hast schon eine Karte aufgedeckt und kannst daher nicht mehr schummeln");
                return;
            }
           
            // Jetzt wollen wir alle Karten durchgehen
            // und jede Karte prüfen, ob die Karte noch im Spiel ist.
        }

Der nächste Schritt ist da schon einmal als Kommentar angegeben. Sogar zwei Schritte.

Wir haben ja alle Karten in der Klasse gespeichert ... jetzt wollen wir alle Karten einmal durchgehen. Dazu brauchen wir einen Code.

Code:
Schleife Über alle Karten {
    // Erst noch nichts machen ...
}

Und wenn Du den Code hast, dann brauchen wir eine Prüfung, ob die Karte noch im Spiel ist.
Code:
Schleife Über alle Karten {
    if (karte.istKarteImSpiel()) {
        // Erst noch nichts machen ...
    }
}

==> Achtung: Hier musst du dann auch die Klasse von der Karte anpassen. Wenn Du ein private Feld mit einer Information hast, dann kannst Du da z.B. ein Getter erstellen oder eine andere Methode, die public ist, damit Du Zugriff hast. Das Feld selbst bleibt private.

Und wenn Du das auch noch hast: die nächsten Schritte, die Du Dir überlegen kannst:

3. Schritt: Jede Karte, die noch im Spiel ist, wird aufgedeckt.

4. Schritt: Wenn Du mit der Schleife fertig bist, brauchen wir einen Timer, damit nach einer gewissen Zeit die Karten wieder umgedreht werden. Also brauchen wir so einen Timer, wie Du zuerst bei der Karte mit eingebaut hattest.

5. Schritt: In der Methode, die dann durchläuft, gehst Du wieder alle Karten durch (Siehe erster Schritt in diesem Post! Kannst Du also 1:1 übernehmen)

6. Schritt: Du prüft die Karte, ob sie noch im Spiel ist (Siehe Schritt 2!)

7. Schritt: Wenn die Karte noch im Spiel ist, drehst Du sie zurück.

Jetzt ganz wichtig: Mach wirklich jeden Schritt einen nach dem anderen. Wenn Du auf ein Problem stößt: Direkt melden. Ich selbst bin leider nebenher auch etwas beschäftigt, so dass ich das doch deutlich zeitversetzter sehe, so dass ich Dir die Chance geben will, da nicht ständig auf mich warten zu müssen....


Ich wollte mit deinen Schritten weitermachen, die Schleife erstellen und prüfen welche Karten noch im Spiel sind.
Ja du hast mit dem Gedächtnis recht, nur weiß ich nicht wie ich prüfen soll ob die Karten noch im Spiel sind.

Ich weiß ich stelle mich an wie der letzte Mensch, ich bin wohl in einem Lerntief.

Java:
/**
 * Aufgabe 3
 */
    public boolean istSpielerDran() {
        return spieler == 0;
    }
    
    public boolean istComupterDran() {
        return spieler == 1;
    }
    
    public boolean hatKartenUmgedreht() {
        return umgedrehteKarten != 0;
    }

    private void schummlen() {//Aufgabe 3
        System.out.println("geschummelt");
            
        if (!istSpielerDran()) {//wenn der Computer dran ist
            System.out.println("Du bist derzeit nicht dran, warte bist du dran bist");
            return;
        }
        
        if (hatKartenUmgedreht()) {//wenn der Mensch dran ist
            System.out.println("Du hast schon eine Karte aufgedeckt und kannst daher nicht mehr schummeln");
            return;
        }

//in Bearbeitung    
        
        for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++);
                if (karte.istKarteImSpiel()) {//ich habe leider keine Idee wie die Prüfung aussehen könnte
                    return;
                }
        
    }
 
kneitzel

kneitzel

Top Contributor
Also Du hast (stark gekürzt):
Java:
public class MemoryKarte extends Button {
    private boolean nochImSpiel;//ist die Karte noch im Spiel?
}
==> Da kann man einen Getter zu schreiben.

Und Du hast (ebenfalls stark gekürzt):
Java:
public class MemoryFeld extends JFrame {
    private MemoryKarte[] karten;//das Array für die Karten
}

Damit sollte sich doch etwas anfangen lassen, oder?
 
J

Java11.03.2019

Mitglied
Wie entfernst Du denn eine Karte aus dem Spiel?

Mit der Methode karteSchliessen() in der Klasse "MemoryFeld"
Java:
    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();
    }

und der Methode rueckseiteZeigen() in der Klasse "MemoryKarte
Java:
    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;
        }
 
mihe7

mihe7

Top Contributor
Karte hat also eine Instanzvariable, die nochImSpiel heißt. Dann sollte die Methode istKarteImSpiel() doch trivial sein, oder?
 
J

Java11.03.2019

Mitglied
kann mir einer zeigen wie das umzusetzen ist, am besten lerne ich wohl beim zuschauen, ich bin aktuell ahnungslos und sehr verzweifelt
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
BTW: du vermischt da JavaFX und Swing, das wird dir irgendwann auf die Füße fallen...
Statt dem JOptionPane kannst du einfach einen Dialog nehmen, und extends JFrame kann ersatzlos weg.
 
mihe7

mihe7

Top Contributor
Java:
       for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++);
                if (karte.istKarteImSpiel()) {//ich habe leider keine Idee wie die Prüfung aussehen könnte
                    return;
                }

Die Methode "istKarteImSpiel()" hast Du jetzt und es geht einfach mit 3. aus Kommentar #21 weiter:

3. Schritt: Jede Karte, die noch im Spiel ist, wird aufgedeckt.
Statt dem return musst Du also die Karte aufdecken.
 
kneitzel

kneitzel

Top Contributor
Öhm, was ist denn da dieses "karte" für eine Variable? Und warum wird die so oft geprüft? (2*21 = 42 Mal wird diese Variable geprüft ... ohne dass die Karte einen neuen Inhalt bekommt!)

Die zwei Schleifen stammen noch vom Versuch, über das zweidimensionale Array gemerkteKarten zu gehen und das hatten wir doch bereits durch #23 und #26 als nicht korrekt erkannt .... das war zumindest meine Hoffnung. In #26 habe ich aufgezeigt, dass es ein eindimensionales Array karten gibt - evtl. böte sich dieses ja hier an so euch nichts besseres einfallen sollte...
 
J

Java11.03.2019

Mitglied
@JustNobody ,
danke für den Hinweis, mein Kopf war voll und ich konnte wohl nichts mehr aufnehmen.

Der folgende Code sollte jetzt passen, jetzt versuche ich alle Karten die noch im Spiel sind aufzudecken.
Java:
        for (int i = 0; i <= 41; i++) {
            System.out.print(i);
            if (karten[i].isNochImSpiel())//den Wert der Variablen isnochImSpiel (true)
                    System.out.print(karten[i].isNochImSpiel());          
            }
 
J

Java11.03.2019

Mitglied
@JustNobody & @mihe7 ,
es war eine sehr schwierige Geburt, nun habe ich es endlich.
Am meisten hakte es an if (karten[i].isNochImSpiel()), die Logik dahinter verstehe ich noch nicht ganz, aber so ist halt die Syntax.
Euch vielen Lieben Dank, insbesondere für eure Geduld, ohne euch hätte ich das nie geschafft.
Vllt. schreibt man sich nochmal, würde mich freuen.

Wenn ihr Unterstützung bei den Finanzen oder ähnliches braucht, wendet euch gerne an mich.
Die Kernkompetenz meiner Seits liegt in der Finanzbuchhaltung und Investitionen von P2P Kredite sowie ETFs.

Jetzt kümmere ich mich ums Fine Tuning :)

Klasse "MemoryFeld"
Java:
/**
* Aufgabe 3
*/
    public boolean istSpielerDran() {
        return spieler == 0;
    }
   
    public boolean istComupterDran() {
        return spieler == 1;
    }
   
    public boolean hatKartenUmgedreht() {
        return umgedrehteKarten != 0;
    }

    private void schummlen() {//Aufgabe 3
        System.out.println("geschummelt");
           
        if (!istSpielerDran()) {//wenn der Computer dran ist
            System.out.println("Du bist derzeit nicht dran, warte bist du dran bist");
            return;
        }
       
        if (hatKartenUmgedreht()) {//wenn der Mensch dran ist
            System.out.println("Du hast schon eine Karte aufgedeckt und kannst daher nicht mehr schummeln");
            return;
        }
       
        for (int i = 0; i <= 41; i++) {
            if (karten[i].isNochImSpiel())//den Wert der Variablen isnochImSpiel (true)
                karten[i].kartenAufdecken();
            }      
       
        timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler1()));//den Timer erzeugen          
        timer.play();//und starten  
    }
   
    private void alleKartenZudecken() {     
        for (int i = 0; i <= 41; i++) {
            if (karten[i].isNochImSpiel())//den Wert der Variablen isnochImSpiel (true)
                karten[i].kartenZudecken();
            }
    }

Klasse "MemoryFeld"
Java:
    class TimerHandler1 implements EventHandler<ActionEvent> {
        @Override
        /**
         * Methode ruft die Methode alleKartenZudecken() auf
         */
        public void handle(ActionEvent arg0) {
            alleKartenZudecken();
        }
    }

Klasse "MemoryKarte"
Java:
    public void kartenAufdecken() {//Aufgrabe 3 die Methode deckt alle Karten auf
        setGraphic(bildVorne);  
    }

    public void kartenZudecken() {
        setGraphic(bildHinten);
       
    }
 
J

Java11.03.2019

Mitglied
sowohl als auch, an beide Punkte hatte ich in den letzten drei Tage nachgedacht
 
mihe7

mihe7

Top Contributor
Zum ersten Punkt: eine Bedingung ist ein boolescher Ausdruck, also etwas, das einen booleschen Wert (true oder false) liefert.
Beispiel:
Java:
if (x < 5) {
    ...
}
Hier liefert x < 5 true, wenn x < 5 gilt. Das könntest Du auch in einer Variablen speichern und die Bedingung durch die Variable ersetzen:
Java:
boolean lessThan5 = x < 5; 
if (lessThan5) { ... }

Ein
Java:
if (lessThan5 == true) { ... }
wäre dagegen doppelt gemoppelt, denn lessThan5 == true liefert true, genau dann wenn lessThan5 bereits true ist.

Da die Methode ein boolean liefert, ist in der Bedingung kein weiterer Vergleich notwendig.

Übrigens kann man auch statt
Java:
if (lessThan5 == false) { ... }
einfach
Java:
if (!lessThan5) { ... }
schreiben.

Der zweite Punkt hängt damit zusammen, dass man den Zustand kapseln will. Das hat zwei Gründe: erstens will man den Zugriff auf den Zustand so restriktiv wie möglich halten. Beispielsweise habe ich hier:
Java:
class X {
    private boolean on;
    public boolean isOn() { return on; }
}
von außen keine Möglichkeit, on direkt zu verändern. Der Zustand ist nur innerhalb der Klasse in dort definierter Weise änderbar. Somit kann es weniger zu bösen Überraschungen kommen.

Zweitens will man von der Implementierung abstrahieren, um Abhängigkeiten (= Komplexität) zu minimieren. Ob die Karte intern ein boolean hat und ob das "nochImSpiel" heißt, muss den Aufrufer nicht interessieren. Wenn Du später an der Implementierung etwas ändern willst, kannst Du das problemlos machen.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
B Memory Spiel Java Basics - Anfänger-Themen 29
Olis Erste Schritte Simples Memory Spiel möglich? Java Basics - Anfänger-Themen 1
P memory spiel Java Basics - Anfänger-Themen 10
P NullPointerException in Memory-Spiel Java Basics - Anfänger-Themen 5
I Memory-Spiel Feld nur einmal mischen Java Basics - Anfänger-Themen 2
K Memory-Spiel stecke Fest Java Basics - Anfänger-Themen 2
K Ein Memory Spiel ! Java Basics - Anfänger-Themen 6
K Memory-Spiel alle verdeckte karten aufdecken. Java Basics - Anfänger-Themen 26
I Memory-Spiel Java Basics - Anfänger-Themen 2
G Memory-Spiel Java Basics - Anfänger-Themen 8
Spencer Reid JavaFX Memory Thread.sleep Java Basics - Anfänger-Themen 1
T Art 4 Felder Matrix Memory Java Basics - Anfänger-Themen 2
V Memory Logik Problem/Denkblockade, bitte helft Java Basics - Anfänger-Themen 1
S Java memory fehler: Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap spa Java Basics - Anfänger-Themen 5
P Layout Manager - Welches Layout für Memory? Java Basics - Anfänger-Themen 7
A Java memory leakage Java Basics - Anfänger-Themen 9
T Out of Memory (Java Heap Space) Java Basics - Anfänger-Themen 9
S Datentypen Memory Problem Java Basics - Anfänger-Themen 12
O Memory Thread.sleep() Java Basics - Anfänger-Themen 5
T Memory Leak und der Garbage Collector Java Basics - Anfänger-Themen 21
A Memory Probleme beim Laden von thumbnails Java Basics - Anfänger-Themen 3
S memory heap problem Java Basics - Anfänger-Themen 9
J Memory Footprint von Objekten Java Basics - Anfänger-Themen 2
W Servlet - out of memory Java Basics - Anfänger-Themen 7
B Memory - Zufällige Anordnung von Buchstabenpaaren Java Basics - Anfänger-Themen 8
J Memory Java Basics - Anfänger-Themen 2
G Memory Projekt, Fragen über Fragen Java Basics - Anfänger-Themen 6
B Memory in Java Java Basics - Anfänger-Themen 16
T Out of Memory Error Java Basics - Anfänger-Themen 7
E Heapspace out of Memory Java Basics - Anfänger-Themen 8
M Java Spiel wie Wer wird Millionär Java Basics - Anfänger-Themen 1
T Startbildschirm für ein Spiel erstellen Java Basics - Anfänger-Themen 0
Z Kein überprüfen des gesamten Arrays möglich.(Viergewinnt Spiel) Java Basics - Anfänger-Themen 6
G Ufo Spiel programmieren Java Basics - Anfänger-Themen 13
C Java Spiel Java Basics - Anfänger-Themen 3
J Spiel programmieren Java Basics - Anfänger-Themen 16
S Spiel-Programmieren. Wenn ein Objekt den anderen berührt. Java Basics - Anfänger-Themen 6
Kamy Ein einfaches "Vier Gewinnt" Spiel für Anfängerin Java Basics - Anfänger-Themen 51
A Breakout-Spiel , Ball mit Platten abprallen lassen Java Basics - Anfänger-Themen 1
S Spiel programmieren mit Java Java Basics - Anfänger-Themen 11
J Spiel mit Button klick starten Java Basics - Anfänger-Themen 9
C Rekursives Backtracking beim Spiel Peg Java Basics - Anfänger-Themen 22
M Spiel programmieren Java Basics - Anfänger-Themen 16
Spencer Reid Feedback zu kleinem Spiel Java Basics - Anfänger-Themen 4
kokojamboo92 Spiel programmieren Java Basics - Anfänger-Themen 1
R Kleines Java Spiel funktioniert nicht. Java Basics - Anfänger-Themen 2
I Spiel Java Basics - Anfänger-Themen 34
H ein einfaches Tic Tac Toe Spiel Java Basics - Anfänger-Themen 1
I Spiel programmieren. Java Basics - Anfänger-Themen 16
B Hilfe bei Escape - Spiel Java Basics - Anfänger-Themen 6
S Java-Spiel Java Basics - Anfänger-Themen 2
M Nim-Spiel geht in den negativen Bereich Java Basics - Anfänger-Themen 1
K Klassen Registrierungsseite für ein Spiel Java Basics - Anfänger-Themen 6
J Programmierung Quiz Spiel Java Basics - Anfänger-Themen 3
J Programmierung Quiz Spiel Java Basics - Anfänger-Themen 2
M Brauche Tipps für ein Spiel Java Basics - Anfänger-Themen 4
S Probleme mit GamGrid Spiel-Erstellung => Actor reagiert nicht auf Tastatur Java Basics - Anfänger-Themen 2
Mxxxt Mosaik Spiel - Steuerpanel wird nicht angezeigt Java Basics - Anfänger-Themen 5
M Erste Schritte Zufallszahl Spiel Problem Java Basics - Anfänger-Themen 7
Z Erste Schritte Kleines 2D. Spiel Objekt Bewegung funktioniert nicht Java Basics - Anfänger-Themen 2
H Spiel Kniffel: Gesamtes Array untersuchen. Java Basics - Anfänger-Themen 15
Tacofan Hangman als fertiges Spiel Java Basics - Anfänger-Themen 7
M Array und Objektorientierung? - TicTacToe Spiel Java Basics - Anfänger-Themen 43
C Klassen Sudoku-Spiel Werte werden nicht gesetzt Java Basics - Anfänger-Themen 4
K Kleines Spiel auf Java programmieren Java Basics - Anfänger-Themen 2
W Tic Tac Toe Spiel ohne Arrays Java Basics - Anfänger-Themen 7
S Im objektorientiertem "Spiel" kämpfen Java Basics - Anfänger-Themen 3
I Klassen Umsetzungsfrage zu Spiel "Zuul" Java Basics - Anfänger-Themen 3
F Mastermind Spiel Java Basics - Anfänger-Themen 9
H Liste ausgeben (Spiel Hey Fisch (software-challenge) ändern Anzahl Fische) Java Basics - Anfänger-Themen 1
F Game-Engine für textbasierendes Spiel: Architektur? Java Basics - Anfänger-Themen 9
K Erste Schritte Frage Antwort Spiel - Fragen zur Planung Java Basics - Anfänger-Themen 2
J Java Spiel Zufallsauswahl für Zugbeginn Java Basics - Anfänger-Themen 3
J Frage Antwort Spiel - Wie Zeitcountdown realisieren? Java Basics - Anfänger-Themen 2
L Erste Schritte Spiel: Glückliches Sieben Java Basics - Anfänger-Themen 3
T Hangman spiel Java Basics - Anfänger-Themen 5
J 2 Pc's - Spiel gegeneinander ?! Java Basics - Anfänger-Themen 3
V Spiel Programmieren Java Basics - Anfänger-Themen 9
P 2D-Spiel und Bildschirmgröße Java Basics - Anfänger-Themen 2
O Methoden Fehlermeldung(Illegal start of expression) bei 4-Gewinnt-Spiel Java Basics - Anfänger-Themen 5
T Blöcke für ein Jump and Run Spiel Java Basics - Anfänger-Themen 8
S 2D-Spiel mit Threads... Java Basics - Anfänger-Themen 3
S 2D-Spiel im Vollbild an größe anpassen? Java Basics - Anfänger-Themen 3
M hangman spiel Java Basics - Anfänger-Themen 1
K JTextField in ein Spiel einfügen Java Basics - Anfänger-Themen 2
S Mosaik Spiel Java Basics - Anfänger-Themen 19
T OOP Mein erstes Java-Spiel - Schiffe versenken! Java Basics - Anfänger-Themen 2
K Erste Schritte Wie mache ich weiter? (Spiel-Menü) Java Basics - Anfänger-Themen 9
C Java Applet in html. Pong - old school Spiel Java Basics - Anfänger-Themen 10
J Variablen Invalid Character - Error -> Spiel mit Variablenergebnissen Java Basics - Anfänger-Themen 8
K Schere Stein Papier Spiel Java Basics - Anfänger-Themen 3
A Feedback zum Spiel Java Basics - Anfänger-Themen 5
F Hilfe bei meinem Spiel Java Basics - Anfänger-Themen 3
C Lotto Spiel Java Basics - Anfänger-Themen 23
Jagson Dotcom Spiel - Dots Random setzen Java Basics - Anfänger-Themen 8
Dogge Farben-Spiel Java Basics - Anfänger-Themen 20
K Diverse Bugs in einem Snake Spiel Java Basics - Anfänger-Themen 4
2 Lotto-Spiel Java Basics - Anfänger-Themen 9
X Datentypen Probleme mit Char bei meinem 1. Spiel Java Basics - Anfänger-Themen 20
D Erste Schritte Einstieg in die Java Spiel Programmierung Java Basics - Anfänger-Themen 7

Ähnliche Java Themen

Anzeige

Neue Themen


Oben