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

Status
Nicht offen für weitere Antworten.
R

ReinerNiner

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


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[i] = new MemoryKarte(bilder[count], count, this);
            //bei jeder zweiten Karte kommt auch ein neues Bild
            if ((i + 1) % 2 == 0)
                count++;
        }
        //die Karten werden gemischt
        Collections.shuffle(Arrays.asList(karten));

        //und ins Spielfeld gesetzt
        for (int i = 0; i <= 41; i++) {
            feld.getChildren().add(karten[i]);
            //die Position der Karte setzen
            karten[i].setBildPos(i);
        }
    }
    
    //die Methode übernimmt die wesentliche Steuerung des Spiels
    //Sie wird beim Anklicken einer Karte ausgeführt
    public void karteOeffnen(MemoryKarte karte) {
        //zum Zwischenspeichern der ID und der Position
        int kartenID, kartenPos;

        //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;
    }
    
}

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);
    }
}

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();
    
}
 
VfL_Freak

VfL_Freak

Top Contributor
>> 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
 
R

ReinerNiner

Mitglied
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

VfL_Freak

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

mrBrown

Super-Moderator
Mitarbeiter
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.
 
Status
Nicht offen für weitere Antworten.
Anzeige

Neue Themen


Oben