hauptformular.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "hauptformular.h"
#include "memoryfeld.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
MemoryFeld SpielFeld;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
 : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1:rawGrid1DrawCell(TObject *Sender, int ACol,
 int ARow, TRect &Rect, TGridDrawState State)
{
ImageList1->Draw(DrawGrid1->Canvas,Rect.Left,Rect.Top,SpielFeld.SpielFeld[ACol][ARow]);
}
//---------------------------------------------------------------------------
void __fastcall TForm1:rawGrid1DblClick(TObject *Sender)
{
int x=DrawGrid1->Col;
int y=DrawGrid1->Row;
if (SpielFeld.OffeneKarten==0 && SpielFeld.player==1)
 SpielFeld.player=0;
if (SpielFeld.OffeneKarten==0 && SpielFeld.player==0)
{
if (SpielFeld.SpielFeld[x][y]==22)
SpielFeld.KarteOeffnen(x,y);
}
else
if (SpielFeld.OffeneKarten==1 && SpielFeld.player==0)
{
 if (SpielFeld.SpielFeld[x][y]==22)
 {
 SpielFeld.KarteOeffnen(x,y);
 Timer1->Enabled=1;
 }
}
DrawGrid1->Repaint();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
Timer1->Enabled=0;
SpielFeld.SchliesseKarten();
Label3->Caption=IntToStr(SpielFeld.Paare[0]);
Label4->Caption=IntToStr(SpielFeld.Paare[1]);
DrawGrid1->Repaint();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{

}
//---------------------------------------------------------------------------

hauptformular.h

//---------------------------------------------------------------------------

#ifndef hauptformularH
#define hauptformularH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Grids.hpp>
#include <ImgList.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
 TDrawGrid *DrawGrid1;
 TImageList *ImageList1;
 TTimer *Timer1;
 TLabel *Label1;
 TLabel *Label2;
 TLabel *Label3;
 TLabel *Label4;
 TButton *Button1;
 TTimer *Timer2;
 void __fastcall DrawGrid1DrawCell(TObject *Sender, int ACol,
 int ARow, TRect &Rect, TGridDrawState State);
 void __fastcall DrawGrid1DblClick(TObject *Sender);
 void __fastcall Timer1Timer(TObject *Sender);
 void __fastcall Button1Click(TObject *Sender);
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
 __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

memoryfeld.cpp

//---------------------------------------------------------------------------

#pragma hdrstop

#include "memoryfeld.h"
#include "hauptformular.h"
#include <algorithm.h>

MemoryFeld::MemoryFeld(){

 int bild=0;
 int Feld[42];
 OffeneKarten=0;
 player=0;
 Paare[0]=0;
 Paare[1]=0;
 //Initialisiere Aufgedeckt mit -1
 for (int i=0; i<21; i++)
 for (int j=0; j<2; j++)
 {
 Aufgedeckt[j].x=-1;
 Aufgedeckt[i][j].y=-1;
 }
 //Belegen von Feld
 for (int i=0; i<42; i++)
 {
 Feld[i]=bild;
 if (((i+1) % 2 == 0)) bild++;
 }

 //Mischen von Feld
 randomize();
 random_shuffle(Feld,Feld+42);
 //Kopieren aus Feld in InitFeld
 for (int i=0; i<7; i++)
 for (int j=0; j<6; j++)
 {
 InitFeld[i][j]=Feld[j+7+i];
 SpielFeld[i][j]=22;
 }
}

void MemoryFeld::KarteOeffnen(int x, int y){
 int a=0;
 SpielFeld[x][y]=InitFeld[x][y];
 OffeneKartenPos[OffeneKarten].x=x;
 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;
 Aufgedeckt[SpielFeld[x][y]][a].y=y;
 OffeneKarten++;
}
//Karte Schliessen
void MemoryFeld::SchliesseKarten(){
 bool treffer=0;
if (InitFeld[OffeneKartenPos[0].x][OffeneKartenPos[0].y]==InitFeld[OffeneKartenPos[1].x][OffeneKartenPos[1].y])
{
SpielFeld[OffeneKartenPos[0].x][OffeneKartenPos[0].y]=21;

SpielFeld[OffeneKartenPos[1].x][OffeneKartenPos[1].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;
SpielFeld[OffeneKartenPos[1].x][OffeneKartenPos[1].y]=22;
}
OffeneKarten=0;
if ((Paare[0]+Paare[1])!=21 ){
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!=x-1)
{
x1=Aufgedeckt[i][0].x;
y1=Aufgedeckt[i][0].y;
x2=Aufgedeckt[i][1].x;
y2=Aufgedeckt[i][1].y;
found=1;
}
}
if (found==1)
 KarteOeffnen(x2,y2);
 else
 {
 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[InitFled[x1][y1]][0].y==1))
{
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;

}

//---------------------------------------------------------------------------

#pragma package(smart_init)

memoryfeld.h

//---------------------------------------------------------------------------

#ifndef memoryfeldH
#define memoryfeldH
struct pos {int x; int y;};

class MemoryFeld{
 public:
 MemoryFeld();
 void KarteOeffnen(int x, int y);
 void SchliesseKarten();
 void ComputerZug(); 

 int OffeneKarten;
 int player;
 pos OffeneKartenPos[2];
 int Paare[2];
 //das Feld fuer die Indizes der Bilder
 int InitFeld[7] [6];
 //das Spielfeld
 int SpielFeld[7] [6];
 //Bilder, die bereits aufgedeckt sind
 pos Aufgedeckt[21] [2];
};
//---------------------------------------------------------------------------
#endif

Danke in voraus

Nur mal als Ansatz: In der Abfragemethode für "Schummeln" drehst du alle (noch liegenden) Karten um (müsste irgendwo existieren, schließlich mußt du die geratenen Karten auch umdrehen), wartest ein paar Sekunden und drehst die Karten wieder zurück.

-- keine Frage gestellt
 ++ Originalcode
--- Kompletter Code
+++ Codetags
 -- keine Einrückung
  - keine cpp-Tags
  + "voraus" richtig geschrieben

und C++ Sytnaxhighlighting wäre noch nett

rate mal wofür die cpp tags sind