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

Status
Nicht offen für weitere Antworten.

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.


[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

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
 

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

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

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.

Neue Themen


Oben