# Memory-Spiel  über Button Alles aufdecken



## DadeMurphy (20. August 2006)

HI,
habe mit dem C++Builder von Borland ein Memory-Spiel prog.
Ich habe im Prog.ein Button, wenn ich den anklicke,soll für ein paar Sekunden alle noch nicht aufgedeckten Karten angezeigt werden.
Ich weiß, das ich ein globales Feld erstellen soll, um den aktuellen Zustand des Feldes SpielFeld zwischenzuspeichern.Das neue Feld muss dieselben Dimensionen haben, wie das Feld SpielFeld.
Bereits aufgedeckte Karten dürfen nicht verändert werden.Die Grafig ,,aufgedeckt" hat den Index 21.
Ich muss in dem Prog. einen zweiten Timer verwenden, ausserdem soll die Schummel-Funktion nur dann aufgerufen werden können, wenn Timer1 nicht aktiv ist.

Ich hoffe, das mir jemand helfen kann.


Hier der Quelltext:



Hauptformular:

```
void_fastcall TForm1::DrawGrid1DblClick(TObject*Sender)
{
int x=DrawGrid1->Col;  //Variablen die Pos der Zelle zuweisen auf die doppelt geklickt wurde
int y=DrawGrid1->Row;   //

if (SpielFeld.OffeneKarten==0 && SpielFeld.player==1)   //Überprüfen, ob Spieler1 (PC) den Zug beendet hat
SpielFeld.player=0;   //wenn Zug beendet, ist Spieler2 (Mensch) dran also player 0

if (SpielFeld.OffeneKarten==0 && SpielFeld.player==0)
{ Überprüft, ob noch keine Karte umgedr. ist.Wenn nicht Methode KarteOeffnen() mit der Pos der Karte auf die //doppelt geklickt wurde

if (SpielFeld.SpielFeld[x][y]==22)
SpielFeld.KarteOeffnen(x,y);
}
else
if (SpielFeld.OffeneKarten==1 && SpielFeld.player==0)   //Wenn Karte bereits umgedr. ist, Überp. ob die Karte //an der Pos noch zugedeckt ist
{
if (SpielFeld.SpielFeld[x][y]==22)   //Vergleichen mit dem Bildindex (22) für verdeckte Karte wenn zugedeckt, //dann Methode KarteOeffnen() u. mit Pos aufrufen
{
SpielFeld.KarteOeffnen(x,y);
Timer1->Enabled=1;   //Timer1 aktivieren
}
}
DrawGrid1->Repaint();   //Tabelle wird neu gezeichnet
}

void_fastcallTForm1::Timer1Timer(TObject*Sender)
{
Timer1->Enabled=0;   //Timer1 wird deaktiviert
SpielFeld.SchliesseKarten();
Label3->Caption=IntToStr(SpielFeld.Paare[0]);
Label4->Caption=IntToStr(SpielFeld.Paare[1]);

if (SpielFeld.Paare[0]<SpielFeld.Paare[1])
{
Label5->Caption="Der Computer hat gewonnen";
}
else
{
Label5->Caption="Der Mensch hat gewonnen";
}
DrawGrid1->Repaint();   //Tabelle wird neu gezeichnet
}


Memoryfeld:
MemoryFeld::MemoryFeld()
{
int bild=0;
int Feld[42];
OffeneKarten=0;
player=0;
Paare[0]=0;
Paare[1]=0;

for (int i=0; i<21; i++)
for (int j=0; j<2; j++)
{
Aufgedeckt[i][j].x=-1;
Aufgedeckt[i][j].y=-1;
}
for (int i=0; i<42; i++)
{
Feld[i]=bild;
if (((i+1) %2==0))bild++;   //Der Wert von Bild wird bei jedem 2. lauf erhöht
}
randomize();
random_shuffle(Feld,Feld+42);

for (int i=0; i<7; i++)
for (int j=0; j<6; j++)
{
InitFeld[i][j]=Feld[j*7+i];   //eine Zelle weiter bewegen, zufällig angeordneter Werte werden in InitFeld kopiert
SpielFeld[i][j]=22;   // Das Feld SpielFeld wird belegt auf allen Pos mit dem Wert 22
}
}

void MemoryFeld::KarteOeffnen(int x,inty)
{
int a=0;
SpielFeld[x][y]=InitFeld[x][y];
OffeneKartenPos[OffeneKarten].x=x;   //Pos der aktuell umgedrehten Karten, keine umgedreht 0 sonst 1
OffeneKartenPos[OffeneKarten].y=y;

if (Aufgedeckt[SpielFeld[x][y]][0].x!=-1 && !(Aufgedeckt[SpielFeld[x][y]][0].x==x && Aufgedeckt[SpielFeld[x][y]][0].y==y))

a=1;

Aufgedeckt[SpielFeld[x][y]][a].x=x;   //Speichert die Pos der gerade umgedrehten Karten
Aufgedeckt[SpielFeld[x][y][a].y=y;
}

void MemoryFeld::SchliesseKarten()
{
bool treffer=0;

if (InitFeld[OffeneKartenPos[0].x][OffeneKartenPos[0].y]==InitFeld[OffeneKartenPos[1].x][OffeneKartenPos[1].y])
{   //Überprüft ob die aufged. Karten gleich sind. Greift mit OffeneKartenPos auf die Elemente im Feld InitFeld zu

SpielFeld[OffeneKartenPos[0].x][OffeneKartenPos[0].y]=21;
for (int i=0; i<2; i++)
{
Aufgedeckt[InitFeld[OffeneKartenPos[i].x][OffeneKartenPos[i].y]][i].x=1;
}
Paare[player]++;
treffer=1;
}
else
{
SpielFeld[OffeneKartenPos[0].x][OffeneKartenPos[0].y]=22;   //Karten werden zugedeckt, da ungleich
SpielFeld[OffeneKartenPos[1].x][OffeneKartenPos[1].y]=22;
}
OffeneKarten=0;

if ((Paare[0]+Paare[1]) !=21)   //Überprüft, ob alle Paare aufgedeckt
{
if ((player==0 && treffer==0 || (player==1 && treffer==1))
{
player=1;
ComputerZug();
}
}
}

void MemoryFeld::ComputerZug()
{
int x1,y1,x2,y2,found=0;
randomize();
for (int i=0; i<21; i++)
{
if (Aufgedeckt[i][0].x!=-1 && Aufgedeckt[i][1].x!=-1)   //Überprüft, ob 2 gleiche Bilder im Element, also Wert ! = -1 //haben
{

x1=Aufgedeckt[i][0].x;   //Pos ausleesen u. den Variablen zuweisen
y1=Aufgedeckt[i][0].y;
x2=Aufgedeckt[i][1].x;
y2=Aufgedeckt[i][1].y;
found=1;
}
}
found=(found && random(2));
if (found==1)
KarteOeffnen(x2,y2);   //Wenn Karte gefunden, umdrehen andere neu zeichnen
else
{            //wenn kein Paar gefunden, zufällige Pos im SpielFeld erzeugen
do
{
x1=random(7);
y1=random(6);
}
while (SpielFeld[x1][y1]!=22);
if (Aufgedeckt[InitFeld[x1][y1]][0].x!=-1 && !(Aufgedeckt[InitFeld[x1][y1]][0].x==x1 && Aufgedeckt[InitFeld[x1][y1]][0].y==y1))
{   //befinden sich Karten an der zufälligen Pos im Feld aufgedeckt, dann vergleichen

KarteOeffnen(Aufgedeckt[InitFeld[x1][y1]][0].x,Aufgedeckt[InitFeld[x1][y1]][0].y);
}
else
{
do
{
x2=random(7);
y2=random(6);
}
while (SpielFeld[x2][y2]!=22 ||  (x1==x2 && y1==y2));
KarteOeffnen(x2,y2);
}
}
KarteOeffnen(x1,y1);
Form1->DrawGrid1->Repaint();
Form1->Timer1->Enabled=1;
}


Memoryfeld.h
struct pos{int x; int y;};   //speichern der Position auf dem Spielfeld

class MemoryFeld
{
public:
MemoryFeld();
void KarteOeffnen(int x,inty);   //wird aufgerufen, wenn umgedr. u. anzeigen soll
void SchliesseKarten();   //Aufruf, wenn vom Spielfeld nehmen od. umdrehen
void ComputerZug();   //Spielzüge vom PC steuern
int OffeneKarten;   //Speichert die Anzahl der aufgedeckten Karten
int player;   //Nimmt die Nr. des Spielers auf 1=PC  0=Mensch
pos OffeneKartenPos[2];   //Speichert die Pos aufgedeckter Karten
int Paare[2];   //Speichert die Anzahl der Paare, die aufgedeckt wurden
int InitFeld[7][6];   //Speichert die Indizes der Bilder
int SpielFeld[7][6];   //Speichert den aktuellen Zustand des spielfeldes
pos Aufgedeckt[21][2];   //Speichert die Pos der Karten die 1 mal aufgedeckt wurden
};
```


----------



## Thomas Kuse (20. August 2006)

Also zum einen verwende bitte die [ cpp ] - Tags um Deinen Code ordentlich anzuzeigen.
Zum anderen wären natürlich vernünftige Kommentare sinnvoll um uns Deinen Quellcode selbsterklärend zu präsentieren.


----------



## DadeMurphy (20. August 2006)

Hi Thomas,
ich werde selbstverständlich meinen Quelltext noch auskommentieren.
Danke für deinen Tipp


----------



## stimon (21. August 2006)

Hallo,
warum so faul, ich habs doch auch geschaft, must dich halt mal mehr anstrengen.
Ach, wie lange probierst du schon an diesem Button?
Gruß stimon


----------



## DadeMurphy (21. August 2006)

HI Stimon,
dieser Button raubt mir noch den letzten Nerv.
Bin ca. schon eineinhalb Wochen damit beschäftigt, und das Mistding will immer noch nicht so wie ich 
Ich brauche wirklich ein paar gute Tipps, wie ich an die Sache ran gehen soll
Denke warscheinlich in die falschr Richtung


----------

