Ich hoffe das da jemand durchblickt.
Ich hänge mal den kopletten Code an. Das Formular lege ich erstmal nicht bei.
Ich denke mal an diesesn beiden Funktionen hapert es:

void __fastcall TForm1::Button1Click(TObject *Sender)
{
if (Timer1->Enabled==0){
        SpielFeldCopy= SpielFeld;
         for (int i =0; i<7; i++)
                for (int j = 0; j<6; j++){
                        if(Aufgedeckt[SpielFeldCopy[i+1][j+1]][0]==21){
                        SpielFeldCopy.KarteOeffnen(i,j);
                        }
                }
         }
         Timer2->Enabled=1;
}
DrawGrid1->Repaint();

}

void __fastcall TForm1::Timer2Timer(TObject *Sender)
{
Timer2-Enabled=0;
SpielFeldCopy.SchliesseKarten();

}

Hier einmal der komplette Code mit Header Dateien:

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::DrawGrid1DrawCell(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::DrawGrid1DblClick(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){
        // keine Karte offen
        if (SpielFeld.SpielFeld[x][y]==22)
                SpielFeld.KarteOeffnen(x,y);
}else
if (SpielFeld.OffeneKarten==1 && SpielFeld.player ==0){
        // 1 Karte bereits offen
        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]);
if (SpielFeld.Paare[0] >10)
        Label5->Caption="Der Mensch hat gewonnen!";
if (SpielFeld.Paare[1] >10)
        Label5->Caption="Der Computer hat gewonnen!";
DrawGrid1->Repaint();

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

void __fastcall TForm1::Button1Click(TObject *Sender)
{
if (Timer1->Enabled==0){
        SpielFeldCopy= SpielFeld;
         for (int i =0; i<7; i++)
                for (int j = 0; j<6; j++){
                        if(Aufgedeckt[SpielFeldCopy[i+1][j+1]][0]==21){
                        SpielFeldCopy.KarteOeffnen(i,j);
                        }
                }
         }
         Timer2->Enabled=1;
}
DrawGrid1->Repaint();

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

void __fastcall TForm1::Timer2Timer(TObject *Sender)
{
Timer2-Enabled=0;
SpielFeldCopy.SchliesseKarten();

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

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;
        TLabel *Label5;
        TTimer *Timer2;
        TButton *Button1;
        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);
        void __fastcall Timer2Timer(TObject *Sender);
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

memory.cpp:

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

#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
USEFORM("hauptformular.cpp", Form1);
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
        try
        {
                 Application->Initialize();
                 Application->CreateForm(__classid(TForm1), &Form1);
                 Application->Run();
        }
        catch (Exception &exception)
        {
                 Application->ShowException(&exception);
        }
        catch (...)
        {
                 try
                 {
                         throw Exception("");
                 }
                 catch (Exception &exception)
                 {
                         Application->ShowException(&exception);
                 }
        }
        return 0;
}
//--------------------------------------------

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 wurden
        pos Aufgedeckt[21][2];
};
//---------------------------------------------------------------------------
#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[i][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++;
}
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!=-1){
                        x1=Aufgedeckt[i][0].x;
                        y1=Aufgedeckt[i][0].y;
                        x2=Aufgedeckt[i][1].x;
                        y2=Aufgedeckt[i][1].y;
                        found=1;
                }
        }
        found=(found && random(3));
        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[InitFeld[x1][y1]][0].y==y1)){
                        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)

Ich hoffe das mir jemand helfen kann.

MFG

Angelus

btw:
Bitte sprachspezifische Tags benutzen, hier wären zB C/C++ Tags sinnvoller.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.