# Memory-Spiel (Lösung benötigt) wird bezahlt



## ReinerNiner (14. Okt 2020)

hallo

danke im Voraus. Hier sind Aufgaben, die schnellstmöglich gelöst werden müssen. 

Ich bin bereit für die Lösung dieser Aufgaben zu bezahlen. Wer interessiert ist kann mir gern eine pm schicken oder mir hier schreiben. 

Bezahlung erfolgt über per paypal. 

1.Am Ende des Memory-Spiels soll ausgegeben werden wer gewonnen hat. Damit der Spieler diese Ausgabe lesen kann, muss ausserdem dafür gesorgt werden, dass das Spiel nicht sofort nach dem Ende geschlossen wird.
Die Ausgabe kann zum Beispiel in einem Label durchgeführt werden und das Spiel über einen Timer beendet werden.
Wenn ein Timer zum Beenden des Spiels verwendet wird, sollte darauf geachtet werden, dass der Computer nicht weiterspielt, wenn er das letzte Paar umgedreht hat. Dazu kann z.B. der Timer für das Umdrehen der Karten an einer passenden Stelle angehalten werden.

2.Erstellen Sie für das Memory-Spiel eine Anzeige des aktuellen Spielers. Lassen Sie dazu in einem Label unterhalb des Spielfelds anzeigen, ob gerade der Mensch zieht oder der Computer.

3.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.


[CODE lang="java" title="MemoryFeld"]//fÃ¼r die Klassen Arrays und Collections
import java.util.Arrays;

import java.util.Collections;

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 {
    //eine innere Klasse fÃ¼r den Eventhandler des Timer
    class TimerHandler implements EventHandler<ActionEvent> {
            @Override
            //die Methode ruft die Methode karteSchliessen() auf
            public void handle(ActionEvent arg0) {
                karteSchliessen();
            }
        }

    //das Array fÃ¼r die Karten
    private MemoryKarte[] karten;

    //das Array fÃ¼r die Namen der Grafiken
    private String[] bilder = {"grafiken/apfel.jpg", "grafiken/birne.jpg", "grafiken/blume.jpg", "grafiken/blume2.jpg",
            "grafiken/ente.jpg", "grafiken/fisch.jpg", "grafiken/fuchs.jpg", "grafiken/igel.jpg",
            "grafiken/kaenguruh.jpg", "grafiken/katze.jpg", "grafiken/kuh.jpg", "grafiken/maus1.jpg",
            "grafiken/maus2.jpg", "grafiken/maus3.jpg", "grafiken/melone.jpg", "grafiken/pilz.jpg",
            "grafiken/ronny.jpg", "grafiken/schmetterling.jpg","grafiken/sonne.jpg",
            "grafiken/wolke.jpg", "grafiken/maus4.jpg"};

    //fÃ¼r die Punkte
    private int menschPunkte, computerPunkte;
    //zwei Labels fÃ¼r die Punkte
    private Label menschPunkteLabel, computerPunkteLabel;

    //wie viele Karten sind aktuell umgedreht?
    private int umgedrehteKarten;

    //fÃ¼r das aktuell umdrehte Paar
    private MemoryKarte[] paar;

    //fÃ¼r den aktuellen Spieler
    private int spieler;

    //das "GedÃ¤chtnis" fÃ¼r den Computer
    //er speichert hier wo das GegenstÃ¼ck liegt
    private int[][] gemerkteKarten;

    //fÃ¼r die SpielstÃ¤rke
    private int spielstaerke;

    //fÃ¼r den Timer
    private Timeline timer;

    //der Konstruktor
    public MemoryFeld() {
        //das Array fÃ¼r die Karten erstellen, insgesamt 42 StÃ¼ck
        karten = new MemoryKarte[42];

        //fÃ¼r das Paar
        paar = new MemoryKarte[2];

        //fÃ¼r das GedÃ¤chtnis
        //es speichert fÃ¼r jede Karte paarweise die Position im Spielfeld
        gemerkteKarten = new int[2][21];

        //keiner hat zu Beginn einen Punkt
        menschPunkte = 0;
        computerPunkte = 0;

        //es ist keine Karte umgedreht
        umgedrehteKarten = 0;

        //der Mensch fÃ¤ngt an
        spieler = 0;

        //die SpielstÃ¤rke ist 10
        spielstaerke = 10;

        //es gibt keine gemerkten Karten
        for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
    }

    //die Methode erstellt die OberflÃ¤che und zeichnet die Karten Ã¼ber eine eigene Methode
    //Ã¼bergeben wird ein FlowPane
    public FlowPane initGUI(FlowPane feld) {
        //fÃ¼r die Ausgaben
        kartenZeichnen(feld);
        menschPunkteLabel = new Label();
        computerPunkteLabel = new Label();
        menschPunkteLabel.setText(Integer.toString(menschPunkte));
        computerPunkteLabel.setText(Integer.toString(computerPunkte));

        //in zwei Spalten anzeigen
        GridPane tempGrid = new GridPane();
        //und einfÃ¼gen, dabei werden die Koordinaten angegeben
        tempGrid.add(new Label("Mensch: "), 0 , 0 );
        tempGrid.add(menschPunkteLabel, 1, 0);
        tempGrid.add(new Label("Computer: "), 0, 1);
        tempGrid.add(computerPunkteLabel, 1 ,1);
        feld.getChildren().add(tempGrid);
        return feld;
    }

    //das eigentliche Spielfeld erstellen
    private void kartenZeichnen(FlowPane feld) {
        int count = 0;
        for (int i = 0; i <= 41; i++) {
            //eine neue Karte erzeugen
            karten_ = new MemoryKarte(bilder[count], count, this);
            //bei jeder zweiten Karte kommt auch ein neues Bild
            if ((i + 1) % 2 == 0)
                count++;
        }
        //die Karten werden gemischt
        Collections.shuffle(Arrays.asList(karten));

        //und ins Spielfeld gesetzt
        for (int i = 0; i <= 41; i++) {
            feld.getChildren().add(karten);
            //die Position der Karte setzen
            karten.setBildPos(i);
        }
    }

    //die Methode Ã¼bernimmt die wesentliche Steuerung des Spiels
    //Sie wird beim Anklicken einer Karte ausgefÃ¼hrt
    public void karteOeffnen(MemoryKarte karte) {
        //zum Zwischenspeichern der ID und der Position
        int kartenID, kartenPos;

        //die Karten zwischenspeichern
        paar[umgedrehteKarten]=karte;

        //die ID und die Position beschaffen
        kartenID = karte.getBildID();
        kartenPos = karte.getBildPos();

        //die Karte in das GedÃ¤chtnis des Computers eintragen
        //aber nur dann, wenn es noch keinen Eintrag an der entsprechenden Stelle gibt
        if ((gemerkteKarten[0][kartenID] == -1))
            gemerkteKarten[0][kartenID] = kartenPos;
        else
            //wenn es schon einen Eintrag gibt
            //und der nicht mit der aktuellen Position Ã¼bereinstimmt, dann haben wir die
            //zweite Karte gefunden
            //die wird dann in die zweite Dimension eingetragen
            if (gemerkteKarten[0][kartenID] != kartenPos)
                gemerkteKarten[1][kartenID] = kartenPos;
        //umgedrehte Karten erhÃ¶hen
        umgedrehteKarten++;

        //sind zwei Karten umgedreht worden?
        if (umgedrehteKarten == 2) {
            //dann prÃ¼fen wir, ob es ein Paar ist
            paarPruefen(kartenID);
            //den Timer erzeugen
            timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler()));
            //und starten
            timer.play();
        }
        //haben wir zusammen 21 Paare, dann ist das Spiel vorbei
        if (computerPunkte + menschPunkte == 21) {
            //wir beenden es hier direkt
            Platform.exit();
        }
    }

    //die Methode dreht die Karten wieder auf die RÃ¼ckseite
    //bzw. nimmt sie aus dem Spiel
    private void karteSchliessen() {
        boolean raus = false;
        //ist es ein Paar?
        if (paar[0].getBildID() == paar[1].getBildID())
            raus = true;
        //wenn es ein Paar war, nehmen wir die Karten aus dem Spiel
        //sonst drehen wir sie nur wieder um
        paar[0].rueckseiteZeigen(raus);
        paar[1].rueckseiteZeigen(raus);
        //es ist keine Karte mehr geÃ¶ffnet
        umgedrehteKarten = 0;
        //hat der Spieler kein Paar gefunden?
        if (raus == false)
            //dann wird der Spieler gewechselt
            spielerWechseln();
        else
            //hat der Computer ein Paar gefunden?
            //dann ist er noch einmal an der Reihe
            if (spieler == 1)
                computerZug();
    }

    //die Methode prÃ¼ft, ob ein Paar gefunden wurde
    private void paarPruefen(int kartenID) {
        if (paar[0].getBildID() == paar[1].getBildID()) {
            //die Punkte setzen
            paarGefunden();
            //die Karten aus dem GedÃ¤chtnis lÃ¶schen
            gemerkteKarten[0][kartenID]=-2;
            gemerkteKarten[1][kartenID]=-2;
        }
    }

    //die Methode setzt die Punkte, wenn ein Paar gefunden wurde
    private void paarGefunden() {
        //spielt gerade der Mensch?
        if (spieler == 0) {
            menschPunkte++;
            menschPunkteLabel.setText(Integer.toString(menschPunkte));
        }
        else {
            computerPunkte++;
            computerPunkteLabel.setText(Integer.toString(computerPunkte));
        }
    }

    //die Methode wechselt den Spieler
    private void spielerWechseln() {
        //wenn der Mensch an der Reihe war,
        //kommt jetzt der Computer
        if (spieler == 0) {
            spieler = 1;
            computerZug();
        }
        else
            spieler = 0;
    }

    //die Methode setzt die ComputerzÃ¼ge um
    private void computerZug() {
        int kartenZaehler = 0;
        int zufall = 0;
        boolean treffer = false;
        //zur Steuerung Ã¼ber die SpielstÃ¤rke
        if ((int)(Math.random() * spielstaerke) == 0) {
            //erst einmal nach einem Paar suchen
            //dazu durchsuchen wir das Array gemerkteKarten, bis wir in beiden Dimensionen
            //einen Wert finden
            while ((kartenZaehler < 21) && (treffer == false)) {
                //gibt es in beiden Dimensionen einen Wert grÃ¶ÃŸer oder gleich 0?
                if ((gemerkteKarten[0][kartenZaehler] >=0) &&  (gemerkteKarten[1][kartenZaehler] >=0)) {
                    //dann haben wir ein Paar
                    treffer = true;
                    //die Vorderseite der Karte zeigen
                    karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();
                    //und dann die Karte Ã¶ffnen
                    karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);
                    //die zweite Karte auch
                    karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();
                    karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
                }
                kartenZaehler++;
            }
        }
        //wenn wir kein Paar gefunden haben, drehen wir zufÃ¤llig zwei Karten um
        if (treffer == false) {
            //solange eine Zufallszahl suchen, bis eine Karte gefunden wird, die noch im Spiel ist
            do {
                zufall = (int)(Math.random() * karten.length);
            } while (karten[zufall].isNochImSpiel() == false);
            //die erste Karte umdrehen
            //die Vorderseite der Karte zeigen
            karten[zufall].vorderseiteZeigen();
            //und dann die Karte Ã¶ffnen
            karteOeffnen(karten[zufall]);

            //fÃ¼r die zweite Karte mÃ¼ssen wir auÃŸerdem prÃ¼fen, ob sie nicht gerade angezeigt wird
            do {
                zufall = (int)(Math.random() * karten.length);
            } while ((karten[zufall].isNochImSpiel() == false) || (karten[zufall].isUmgedreht() == true));
            //und die zweite Karte umdrehen
            karten[zufall].vorderseiteZeigen();
            karteOeffnen(karten[zufall]);
        }
    }

    //die Methode liefert, ob ZÃ¼ge des Menschen erlaubt sind
    //die RÃ¼ckgabe ist false, wenn gerade der Computer zieht
    //oder wenn schon zwei Karten umgedreht sind
    //sonst ist die RÃ¼ckgabe true
    public boolean zugErlaubt() {
        boolean erlaubt = true;
        //zieht der Computer?
        if (spieler == 1)
            erlaubt = false;
        //sind schon zwei Karten umdreht?
        if (umgedrehteKarten == 2)
            erlaubt = false;
        return erlaubt;
    }

}

[/CODE]

[CODE lang="java" title="MemoryFX"]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 {
        //den obersten Knoten erzeugen
        //hier verwenden wir ein FlowPane
        //erzeugt wird die OberflÃ¤che Ã¼ber eine eigene Methode in der Klasse MemoryFeld
        FlowPane rootNode = new MemoryFeld().initGUI(new FlowPane());
        //die Szene erzeugen
        //an den Konstruktor werden der oberste Knoten und die GrÃ¶ÃŸe Ã¼bergeben
        Scene meineScene = new Scene(rootNode, 480, 550);

        //den Titel Ã¼ber stage setzen
        meineStage.setTitle("Memory");
        //die Szene setzen
        meineStage.setScene(meineScene);
        //GrÃ¶ÃŸenÃ¤nderungen verhindern
        meineStage.setResizable(false);
        //und anzeigen
        meineStage.show();
    }

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

[/CODE]

[CODE lang="java" title="MemoryKarte"]import javafx.event.EventHandler;

import javafx.scene.control.Button;
import javafx.scene.image.ImageView;
import javafx.util.Duration;
import de.fernschulen.MemoryFeld.TimerHandler;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;


//die Klasse fÃ¼r eine Karte des Memory-Spiels
//Sie erbt von Button
public class MemoryKarte extends Button {
    //die Instanzvariablen
    //eine eindeutige ID zur Identifizierung des Bildes
    private int bildID;
    //fÃ¼r die Vorder- und RÃ¼ckseite
    private ImageView bildVorne, bildHinten;

    //wo liegt die Karte im Spielfeld
    private int bildPos;

    //ist die Karte umgedreht?
    private boolean umgedreht;
    //ist die Karte noch im Spiel?
    private boolean nochImSpiel;

    //das Spielfeld fÃ¼r die Karte
    private MemoryFeld spielfeld;

    //die innere Klasse fÃ¼r den Eventhandler der Karte
    class KartenHandler implements EventHandler<ActionEvent>{
        @Override
        public void handle(ActionEvent arg0) {
            //ist die Karte Ã¼berhaupt noch im Spiel?
            //und sind ZÃ¼ge erlaubt
            if ((nochImSpiel == false) || (spielfeld.zugErlaubt() == false))
                return;
            //wenn die RÃ¼ckseite zu sehen ist, die Vorderseite anzeigen
            if (umgedreht == false) {
                vorderseiteZeigen();
                //die Methode karteOeffnen() im Spielfeld aufrufen
                //Ã¼bergeben wird dabei die Karte
                //also die this-Referenz der Ã¤uÃŸeren Klasse
                spielfeld.karteOeffnen(MemoryKarte.this);
            }
        }
    }



//    {
//        //eine innere Klasse fÃ¼r den Eventhandler des Timer
//        class TimerHandler implements EventHandler<ActionEvent> {
//                @Override
//                //die Methode ruft die Methode karteSchliessen() auf
//                public void handle(ActionEvent arg0) {
//                    karteSchliessen();
//                }
//            }
//       


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

        //die Action setzen
        setOnAction(new KartenHandler());
    }

    //die Methode zeigt die Vorderseite der Karte an
    public void vorderseiteZeigen() {
        setGraphic(bildVorne);
        umgedreht = true;
    }

    //die Methode zeigt die RÃ¼ckseite der Karte an
    public void rueckseiteZeigen(boolean rausnehmen) {
        //soll die Karten komplett aus dem Spiel genommen werden?
        if (rausnehmen == true) {
            //das Bild aufgedeckt zeigen und die Karte aus dem Spiel nehmen
            setGraphic(new ImageView("grafiken/aufgedeckt.jpg"));
            nochImSpiel = false;
        }
        else {
            //sonst nur die RÃ¼ckseite zeigen
            setGraphic(bildHinten);
            umgedreht = false;
        }
    }

    //die Methode liefert die Bild-ID einer Karte
    public int getBildID() {
        return bildID;
    }

    //die Methode liefert die Position einer Karte
    public int getBildPos() {
        return bildPos;
    }

    //die Methode setzt die Position einer Karte
    public void setBildPos(int bildPos) {
        this.bildPos = bildPos;
    }

    //die Methode liefert den Wert der Variablen umgedreht
    public boolean isUmgedreht() {
        return umgedreht;
    }

    //die Methode liefert den Wert der Variablen nochImSpiel
    public boolean isNochImSpiel() {
        return nochImSpiel;
    }

//    timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler()));
//    //und starten
//    timer.play();

}
[/CODE]_


----------



## VfL_Freak (15. Okt 2020)

Moin,

für solche Ansinnen gibt es hier aber einen eigenen Bereioch:


			https://www.java-forum.org/forum/private-stellangebote-und-stellensuche-von-usern.97/
		


LG Klaus


----------



## ReinerNiner (15. Okt 2020)

VfL_Freak hat gesagt.:


> Moin,
> 
> für solche Ansinnen gibt es hier aber einen eigenen Bereioch:
> 
> ...



kann man threads auch verlinken oder in versch. Foren gleichzeitig posten. Wenn ja, mit welcher Funktion? 

Danke


----------



## VfL_Freak (15. Okt 2020)

>> in versch. Foren gleichzeitig posten
ein klares "kommt drauf an" 😃
in Deinem Fall sollte es ja NUR  im andern Bereich gepostet werden, dass es hier bei "Hausaufgaben" falsch ist, denn Du wolltest ja weder Anregungen noch Hilfestellungen, sondern suchst jemand, der es für Dich macht!

>> mit welcher Funktion?
Was meinst mit 'Funktion'?

VG Klaus


----------



## ReinerNiner (15. Okt 2020)

Funktion hinter einem Symbol auf der Oberfläche. z.B. eine Taste, die die Funktion hat threads in versch. Foren zu kopieren (gleichzeitig zu posten). So dass man threads nicht extra neu erstellen muss, damit sie in versch. Foren gleichzeitig veröffentlicht werden. 
Verstanden? 

VG Reiner


----------



## VfL_Freak (15. Okt 2020)

Ach so ...
nicht das ist wüsste! Weil das ja eigentlich auch nur in Ausnahmefällren passieren soll!
Doppelposts sind hier allgemein nicht gerne gesehen!

VG Klaus


----------



## mrBrown (15. Okt 2020)

ReinerNiner hat gesagt.:


> Funktion hinter einem Symbol auf der Oberfläche. z.B. eine Taste, die die Funktion hat threads in versch. Foren zu kopieren (gleichzeitig zu posten). So dass man threads nicht extra neu erstellen muss, damit sie in versch. Foren gleichzeitig veröffentlicht werden.


In mehreren Foren posten sollte man nicht. Wenn nötig, kann ein Mod/Admin den Thread in's passende Forum verschieben.

Da hier jetzt schon doppelt gepostet wurde mach ich hier zu.


----------

