4. Probleme bei einem MemorySpiel

Probleme bei einem MemorySpiel

  • M

    ich habe ein MemorySpiel erstellt, muss aber jetzt noch eine sogenannte Schummelfuntion einbauen. D.h. alle Felder die noch zugedeckt sind (Bildindex 21) müssen über den Timer2 für wenige Sekunden angezeigt werden und danach wieder umgedreht werden. So das an dem Spielfeld selbst nicht geändert wird. Ich habe mir dazu überlegt das ich ein globales Feld benötige das den aktuellen Zustand des Feldes "SpielFeld" zwischenspeichert. Dieses globale SpielFeld nenne ich der einfachheit "SpielFeldCopy". Die Schummelfunktion soll durch ein klicken auf den Button1 gestartet werden.

    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

    0
  • G

    Und dein Problem ist jetzt was?

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

    0
  • M

    Ich möchte wenn ich den Button1 drücke erreichen das alle noch verdeckten Karten einmal über eine Timerfunktion "Timer2" aufgedeckt und dann wieder zugedeckt werden. Quasi eine Schummelfunktion. Das Spielfeld oder das Spiel selbst darf daduch aber nicht verändert werden. Ist kompliziert ...cih weiss. Hoffe trotzdem auf rege Hilfe.

    0
  • L

    ich bezweifel, dass sich da jemand findet, der sich in deinen code reinarbeitet, nur um dir ne aufdeckfunktion zu schreiben.. Versuchs doch einfach selber oO

    0
  • C

    Dieser Thread wurde von Moderator/in HumeSikkins aus dem Forum C++ in das Forum Borland C++ Builder (VCL/CLX) verschoben.

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

    Dieses Posting wurde automatisch erzeugt.

    0
  • D

    Dein Ansatz mit dem Kopieren ist doch nicht schlecht. Woran hapert es denn direkt?

    0
  • R

    @Mr.Blond: Sieht mir verflixt nach einer Aufgabe aus 'Heft 10' aus. Wenn du meinen kompletten Code als Anregung - aber auch wirklich nur als Anregung !!! - haben möchtest, mail mich an...

    0
Anmelden zum Antworten