3. memory spiel schummel funktion

memory spiel schummel funktion

  • ?

    Hallo hab da ein memory spiel funktz wunderbar, wollte noch so ein button zum schummeln einbauen damit alle karten für paar sek. sichtbar werden, könnt ihr mir helfen. hier ist die code

    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

    0
  • C

    Nett sieht's aus - aber ich hab' keine Lust, mich durch diesen Code jetzt durchzukauen, um die richtige Einfügestelle zu finden.
    Wenn du Probleme hast, dann bitte mit genauer Angabe, was (und wo) nicht funktioniert)

    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.

    0
  • F

    Mein Postreview:

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

    und C++ Sytnaxhighlighting wäre noch nett 😉

    0
  • G

    Checker&Murckser schrieb:

    und C++ Sytnaxhighlighting wäre noch nett 😉

    rate mal wofür die cpp tags sind

    0
  • ?

    TForm1 kennt der C++-Standard irgendwie nicht. Könnte es sich vielleicht um
    GUI-Programmierung mit Borland handeln. 😃 😉 😃

    0
  • ?

    Das ist mit C++Builder 6 geschrieben

    0
Anmelden zum Antworten