Kortspil Klok-kabale

Det kommer an på hvordan det program du har nu ser ud, så det var måske en ide at poste det.
Det oplage var at have et array med 13 elementer der gemmer kort for hver position. Hver element i arrayet må være i stand til at gemme flere kort.

(Jeg synes at jeg er stødt på dette spørgsmål for ganske nyligt i et andet forum.)

Jeg har valgt at dele spillet i flere dele, så her er koden til den dele mit spørgsmål vedrører.

#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

extern int Deck[52];
extern char CardValue[][3];
int Table[37][13];

void LaggeKort()
{
   
    for (int t=0; t<13; t++)
    {
        Table[0][t]= Deck[t];
        cout << CardValue[Table[0][t]] << " ";
    }
   
    getch();
}

Jeg går ud fra at Deck er kort med numre 0, 1, 2 .. 51 ?

Du skal for hver bunke (Table) vide hvor mange der er i bunken, lad os kalde dem "int Num[13]", denne sættes til 0 når der er et kort i bunken og tælles derpå op.

Når du ligger det næste kort i bunke x skal du:
Checke om Table[Num[x]][x] % 13 == x, hvis den er det skal alle fra Table[][x] lægges tilbage til Deck, ellers skal Num[x] tælles én op, og kortet puttes i Table[Num[x]][x].

Det var måske mere logisk hvis du byttede om på de to index'er i Table.

Jeg forstår ikke hvorfor der er 3 værdier i CardValue og hvorfor det er et 2d array.

Jeg har lavet en komplet løsning, men jeg går ud fra at det er en skole opgave, så jeg poster den ikke før du beder om den.

Jeg vil bede dig, om du gider  vise mig koden. Du kan også sende den til mig på mail: fadalo@ofir.dk

Here we go:

#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
#include <vector>
#include <string>
#include <windows.h>
#include <list>
#include <iomanip>
#include <sstream>

HANDLE StdOut = GetStdHandle(STD_OUTPUT_HANDLE);
HANDLE StdIn = GetStdHandle(STD_INPUT_HANDLE);

void BlandKort();
const char *CardColor[4] =
{
  "Spar", "Ruder", "Kloer", "Hjerter"
};

class CardValueClass
{
public:
  CardValueClass(int aIniVal)  : Color(CardColor[aIniVal/13]), Value(aIniVal%13 + 1)
  {}

  std::string Color;
  int Value;
};

std::ostream & operator << (std::ostream &os, const CardValueClass &aCardValue)
{
  os << aCardValue.Color << "-" << aCardValue.Value;
  return os;
}

void GotoXY(int x, int y);
void GetXY(int &x, int &y);
WORD GetAttrib();
WORD GetChar();
void OutStrXY(int x, int y, const std::string &str, WORD attr);
std::vector<CardValueClass >CardValue;
typedef std::list<int >DeckType;
DeckType Deck;
std::vector<std::vector<int> >Pile;
WORD NormAttrib;
void ClearLine(int y);
void DrawCard(int idx, int card);

int main()
{
  int j;
  std::cout << "Program start" << std::endl;
  Pile.resize(13);
  srand(time(0));

  BlandKort();
  NormAttrib = GetAttrib();
  for(j = 0; j < 20; j++)
      ClearLine(j);

  for(j = 0; j < 13; j++)
  {
      GotoXY(0, j);
      DeckType::iterator it = Deck.begin();
      DrawCard(j, *it);
      Pile[j].push_back(*it);
      Deck.pop_front();
  }
  bool Done;
  do
  {
      ClearLine(15);
      GotoXY(0, 15);
      std::cout << Deck.size() << " cards left, Hit key to continue";
      GetChar();
      Done = true;
      for(j = 0; j < 13 && !Deck.empty(); j++)
      {
        if(Pile[j].back()%13 != j)
        {
            DeckType::iterator it = Deck.begin();
            if((*it)%13 == j)
            {
              std::copy(Pile[j].begin(), Pile[j].end(), std::back_inserter(Deck));
              Pile[j].clear();
            }
            GotoXY(0, j);
            Pile[j].push_back(*it);
            DrawCard(j, *it);
            Deck.pop_front();
            Done = false;
        }
      }
  }
  while(!Done && !Deck.empty());
  ClearLine(15);
  GotoXY(0, 15);

  Done = true;
  for(j = 0; j < 13; j++)
    if(Pile[j].back()%13 != j)
        Done = false;
  if(Done)
  {
      std::cout << "Program slut, du vandt!" << std::endl;
  }
  else
  {
      std::cout << "Program slut, du tabte!" << std::endl;
  }

  return 0;
}

class RandIntClass
{
public:
  RandIntClass() {}
  int operator() (int aRange)
  {
      return rand() % aRange;
  }
};

void BlandKort()
{
  int T[52], i;

  for(i = 0; i < 52; i++)
  {
    T[i] = i;
    CardValue.push_back(CardValueClass(i));
  }
  RandIntClass RandInt;
  std::random_shuffle(T, &T[52], RandInt);
  std::copy(T, &T[52], std::back_inserter(Deck));
}

void GotoXY(int x, int y)
{
  COORD c;
  c.X = (short )x;
  c.Y = (short )y;
  SetConsoleCursorPosition(StdOut, c);
}

void GetXY(int &x, int &y)
{
  CONSOLE_SCREEN_BUFFER_INFO ConsoleScreenBufferInfo;
  GetConsoleScreenBufferInfo(StdOut, &ConsoleScreenBufferInfo);
  x = ConsoleScreenBufferInfo.dwCursorPosition.X;
  y = ConsoleScreenBufferInfo.dwCursorPosition.Y;
}

WORD GetAttrib()
{
  CONSOLE_SCREEN_BUFFER_INFO ConsoleScreenBufferInfo;
  GetConsoleScreenBufferInfo(StdOut, &ConsoleScreenBufferInfo);
  return ConsoleScreenBufferInfo.wAttributes;
}

WORD GetChar()
{
  DWORD NumEventsRead;
  INPUT_RECORD InputRecord;

  while(1)
  {
    if(!ReadConsoleInput(StdIn, &InputRecord, 1, &NumEventsRead))
      return 0;
    if(InputRecord.EventType & KEY_EVENT && InputRecord.Event.KeyEvent.bKeyDown)
    {
      if(InputRecord.Event.KeyEvent.wVirtualKeyCode != VK_CONTROL &&
        InputRecord.Event.KeyEvent.wVirtualKeyCode != VK_MENU  &&
        InputRecord.Event.KeyEvent.wVirtualKeyCode != VK_SHIFT)
      {
        return InputRecord.Event.KeyEvent.wVirtualKeyCode;
      }
    }
  }
}

void OutStrXY(int x, int y, const std::string &str, WORD attr)
{
  ClearLine(y);
  DWORD NumWritten;
  SetConsoleTextAttribute(StdOut, attr);
  GotoXY(x, y);
  WriteConsole(StdOut, str.c_str(), str.size(), &NumWritten, 0);
}

void ClearLine(int y)
{
  const char Empty[] = "                                                                                ";
  GotoXY(0, y);
  SetConsoleTextAttribute(StdOut, NormAttrib);
  DWORD NumWritten;
  WriteConsole(StdOut, Empty, 80, &NumWritten, 0);
}

void DrawCard(int idx, int card)
{
  std::stringstream os;
  os << std::setw(2) << (idx + 1) << " " << CardValue[card];
  if(idx == card%13)
      OutStrXY(0, idx, os.str(), FOREGROUND_GREEN);
  else
      OutStrXY(0, idx, os.str(), FOREGROUND_RED);
}

vil du ikke være venlige og hjælpe mig med, hvordan jeg får programmet til lægge kort 37 gang. Forstået på den måde, programmet lægge de første 13 kort, vi kan blive ved at lægge kort 37 gang. Og hvordan kan jeg få den til at kontrollere, om det kort, der ligger på pladsen i forvejen er rigtig.

Ps. efter min eksempel.

Kan du ikke poste hele din kode, så skal jeg nok tilføje næste del.
Har du tilføjet et array til at holde styr på hvor mange kort der er i hver bunke?

her er hoveddelen.

#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
#include "cardvalue.h"
using namespace std;


extern int Deck[52];    //Global variabel

void BlandKort();

void LaggeKort();

int main(int argc, char* argv[])
{
    cout << "Program start\n";
   
    while(!kbhit())
    {
        rand();       
    }
    getch();

    BlandKort();

    for(int i=0; i<4; i++)
    {
        for(int j=0; j<13; j++)
        {
            cout <<CardValue[Deck[(i*13)+j]] << "  ";
        }
        cout << endl;
    }
   
    cout << "Program slut\n";
    getch();

    LaggeKort();

    return 0;

}

Her kommer blandkort delen:
#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;


int Deck[52];    //Global variabel


void BlandKort()
{
    int Tal;
    bool TalNyt;

    for (int i=0; i<52; i++)
    {
        do
        {
            Tal = rand()%52;

            TalNyt = true;
            if(Tal == Deck[0])   
            {
                TalNyt = false;
            }
//            else
//            {
//                TalNyt = TRUE;
//            }

        } while (!TalNyt);
        Deck[i] = Tal;
    }

}

og her er læggekort delen:

#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

extern int Deck[52];
extern char CardValue[][3];
int Table[37][13];


void LaggeKort()
{
   
    for (int t=0; t<13; t++)
    {
        Table[0][t]= Deck[t];
        cout << CardValue[Table[0][t]] << " ";
    }
   
    getch();
}

Og her er indholdet i Cardvalue.h:

/ Name: cardvalue.h

#if !defined(CARDVALUE_H_INCLUDED_)
#define CARDVALUE_H_INCLUDED_

char CardValue[][3] =
{    "HE", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9", "HT", "HJ", "HQ", "HK",
    "RE", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "RT", "RJ", "RQ", "RK",
    "KE", "K2", "K3", "K4", "K5", "K6", "K7", "K8", "K9", "KT", "KJ", "KQ", "KK",
    "SE", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9", "ST", "SJ", "SQ", "SK"};

#endif  //!defined(CARDVALUE_H_INCLUDED_)

En loop der lægger de resterende kort, udføres efter LaggeKort():

    for(j = 1; j < 4; j++)
    {
      for(i = 0; i < 13; i++)
      {
          if(Table[NumKort[i]][i] % 13 == i)
          { // This pile is OK
            std::cout << "  ";
          }
          else
          {  // Add a card, todo move table to deck if new card is OK
            NumKort[i]++;
            Table[NumKort[i]][i] = Deck[13*j + i];
            cout << CardValue[Table[NumKort[i]][i]] << " ";
          }
      }
      std::cout << std::endl;
    }

Bemærk at hvis det kort der lægges er rigtigt skal dem der ligger der puttes til enden af Deck.

NumKort er laves med "int NumKort[13];", de sættes til 0, f.ex. i LaggeKort()

Så vidt jeg kan se virker din BlandKort ikke, jeg har brugt denne:

void BlandKort()
{
    int T1, T2, T;
    for(T = 0; T < 52; T++)
      Deck[T] = T;
    for (int i=0; i< 52*10; i++)
    {
      T1 = rand()%52;
      T2 = rand()%52;
      T = Deck[T1];
      Deck[T1] = Deck[T2];
      Deck[T2] = T;
    }
}

Hvad mener du med "En loop der lægger de resterende kort, udføres efter LaggeKort():
Og med hensyn til det her "Så vidt jeg kan se virker din BlandKort ikke" mærkligt når jeg prøver den kører den fint.

Hvad gør jeg forkert her:

#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

extern int Deck[52];
extern char CardValue[][3];
extern int table[37][13];

int NumKort[13];

void Bunken();

{

for(j = 1; j < 4; j++)
    {
      for(i = 0; i < 13; i++)
      {
          if(Table[NumKort[i]][i] % 13 == i)
          { // This pile is OK
            std::cout << "  ";
          }
          else
          {  // Add a card, todo move table to deck if new card is OK
            NumKort[i]++;
            Table[NumKort[i]][i] = Deck[13*j + i];
            cout << CardValue[Table[NumKort[i]][i]] << " ";
          }
      }
      std::cout << std::endl;
    }

Den første loop er en loop der lægger de resterende (de sidste 3*13 = 39) kort fra bunken, med det forbehold jeg nævnte.

Så vidt jeg kan se får jeg det samme kort flere gange når jeg bruger din BlandKort funktion.

det er mærkeligt, det kører fint hos mig.
Når jeg kører det her i gennem kommer der to fejl frem.

#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

extern int Deck[52];
extern char CardValue[][3];
extern int table[37][13];

int NumKort[13];

void Bunken();

{

for(j = 1; j < 4; j++)
    {
      for(i = 0; i < 13; i++)
      {
          if(Table[NumKort[i]][i] % 13 == i)
          { // This pile is OK
            std::cout << "  ";
          }
          else
          {  // Add a card, todo move table to deck if new card is OK
            NumKort[i]++;
            Table[NumKort[i]][i] = Deck[13*j + i];
            cout << CardValue[Table[NumKort[i]][i]] << " ";
          }
      }
      std::cout << std::endl;
    }

cpp(29) : error C2447: missing function header (old-style formal list?)
cpp(51) : fatal error C1004: unexpected end of file found

Der skal ikke være ; efter Bunken()
Der mangler en } til slut.

Jeg puttede koden ind i main efter kaldet til BlandKort.

Problemet med din BlandKort er at du kun checker det nye tal op mod det første tal i Deck. Man kan løse det med:

void BlandKort()
{
    int Tal;
    bool TalNyt;

    for (int i=0; i<52; i++)
    {
        do
        {
            Tal = rand()%52;

            TalNyt = true;
            for(int j = 0; j < i; j++)
              if(Deck[j] == Tal)
                TalNyt = false;
        }
        while (!TalNyt);
        Deck[i] = Tal;
    }
}

hvordan får jeg programmet til at skriv om kabalen er gået op eller ikkke.

Du laver en loop over alle Table[] og checker om det sidste kort er rigtigt.
Eller du checker om der kun er et kort i hver Table[]
Eller du checker om der er netop 39 kort i Deck når du er færdig.

Og så udskriver du det.

Jeg har prøvet mig frem, men jeg kan ikke komme videre

Hvor langt er du kommet?
Har du lavet Bunken funktionen eller implementeret den loop jeg beskrev "29/11-2004 22:48:29" ?
Har du lavet det om så man tager kortene fra Table[] tilbage til Deck når et kort lægges rigtigt ?

mener du det her
"Har du lavet det om så man tager kortene fra Table[] tilbage til Deck når et kort lægges rigtigt?" Jeg har ikke lavet noget ændringer i den kode du vist mig.
#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

extern int Deck[52];
extern char CardValue[][3];
extern int Table[37][13];

int NumKort[13];
int i;
int j;

void Bunken()

{
   

    for(j = 1; j < 4; j++)
    {

    for(i = 0; i < 13; i++)
    {
    if(Table[NumKort[i]][i] % 13 == i)
    {  // This pile is OK
            cout << "  ";
    }
    else
    { 
      // Add a card, todo move table to deck if new card is OK
            NumKort[i]++;
            Table[NumKort[i]][i] = Deck[13*j + i];
            cout << CardValue[Table[NumKort[i]][i]] << " ";
    }
    }
            cout << endl;
    }
    getch();
}

Virker koden ovenfor ?

Du skal:
1: Udvide Deck[] så der bliver plads til de kort der puttes bag i bunken (man kunne godt genbruge plader men det er lettere at putte dem bag i Deck[]).

2: Tilføje en variabel der er index på det sidste kort i Deck[], sættes til 52 ved start, tælles op når der lægges et kort tilbage til Deck, kortet puttes ind i Deck[] i dette index. Jeg ville nok kalde den SidsteKort.

3: Lave en variabel der tæller det øverste/første kort i Deck[], Når du tager et kort fra Deck[] tages det fra dette index, og index'et tælles en op. Jeg ville måske kalde den FoersteKort.

Når FoersteKort == SidsteKort er der ikke flere kort i Deck[] og du har tabt.

I else delen af Bunken() skal du:
Checke om Deck[FoersteKort]%13 == i, hvis den er det:
1: Puttes alle kort fra Table[][i] tilbage til Deck[SidsteKort].
2: SidsteKort tælles en op for hver kort i Table[][i].
3: NumKort[i] sættes til 0.

Derpå:
Flyttes Deck[FoersteKort] over i Table[NumKort[i]][i]
NumKort[i] tælle en op.
FoersteKort tælles en op.

NumKort[i]++;
            Table[NumKort[i]][i] = Deck[13*j + i];
            cout << CardValue[Table[NumKort[i]][i]] << " ";
// Her skal tilføjes, at hvis det nu lagte kort er rigtig, skal de øvrige kort i den bunke flyttes tilbage i Deck.
hvordan gør jeg det.

Og hvordan får jeg programet til at "rykker kortene op" i Deck, hver gang jeg tager en der fra.

Du kan bruge memmove(Deck, &Deck[1], 51*sizeof(int)); til at flytte alle kort én ned i bunken.

Ellers prøv at læse mit sidste indlæg igen.

Som koden ser ud nu, lægger der MAX. 52 kort, men ikke altid 52 kort.Det skal ændres, så jeg lægger kort indtil der ikke er flere i Deck.

Jeg har ændret det her:

    {
    if(Table[NumKort[i]][i] % 13 == 51)"Her har jeg ændret i med 51"
    {  // This pile is OK
            cout << "  ";   
    }
    else
    { 
      // Add a card, todo move table to deck if new card is OK
            NumKort[i]++;
            Table[NumKort[i]][i] = Deck[13*j+i];
            cout << CardValue[Table[NumKort[i]][i]] << " ";
   
    memmove(Deck, &Deck[1], 51*sizeof(int));


Er der noget forkert i det jeg har lavet.

Den første ændring forstår jeg ikke.

Du skal have en tæller der tæller hvor mange kort der er i Deck, lad os kalde den NumInDeck

Hvis du bruger memmove metoden skal du altid tage Deck[0], derved kommer else delen til at se ca. sådan ud:

if(Deck[0]%13 == i)
{  // Dette kort kommer til at ligge på rigtig plads
  for(int y = 0; y < NumKort[i]; y++)
    Deck[NumInDeck++] = Table[y][i];
  NumKort[i] = 0; 
}
Table[NumKort[i]][i] = Deck[0];
NumKort[i]++;
memmove(Deck, &Deck[1], 51*sizeof(int));
NumInDeck--;

Du skal så ændre loopen udenom så den kører sålænge der NumInDeck er større end 0, og ikke kun kører 3 gange. Dette check skal du også have i den loop der kører fra 0 til 13, da du kan risikere at du løber ud for kort midt i en runde.

Jeg vil lige have styre på den her først.

//Alle kort rykkes op i bunken
   
    for (int i=0; i<51; i++)   
    {
    Deck[i]= Deck[i+1];

er det ok.

Ja, Det er ok.

Det er det gør det samme som: memmove(Deck, &Deck[1], 51*sizeof(int));

Med hensyn til den her

for(i = 0; i < 13; i++)
    {
    if(Table[NumKort[i]][i] % 13 == i)
    {  // This pile is OK
            cout << "  ";

Hvis jeg kører koden, så kommer der ikke de 52 kort frem på skærmen. Der mangler nogle gang 2 eller 3 kort. Hvis jeg sætter at 13==51 så kommer aller kortene frem.

Den kører loop'en 3 gange så den lægger 3*13 kort (+ de 13 fra føreste gang), medmindre et kort ligger rigtigt, så springer den den bunke over og der kommer derved til at mangle nogle.

"Du skal have en tæller der tæller hvor mange kort der er i Deck"
Er det her i orden.


extern int Deck[52];
extern char CardValue[][3];
extern int Table[37][13];
extern void Bunken();
extern NumKort[13];
extern void LaggeKort();
extern int i;
int NumInDeck= 52; // antal kort i deck


void AntalKort()
{


if(Deck[0]%13 == i)
{  // Dette kort kommer til at ligge p? rigtig plads
  for(int x = 0; x < NumKort[i]; x++)
    Deck[NumInDeck++] = Table[x][i];
  NumKort[i] = 0;
 
}

else
{
Table[NumKort[i]][i] = Deck[0];
NumKort[i]++;

Deck[i]= Deck[i+1];
NumInDeck--;
cout <<"Antal kort tilbage i Deck"<< endl;

cout << Table[NumKort[i]][i] << " ";
 
            cout << endl;
    }
    getch();
}

Med hensyn til det her.

"Du skal så ændre loopen udenom så den kører sålænge der NumInDeck er større end 0, og ikke kun kører 3 gange. Dette check skal du også have i den loop der kører fra 0 til 13, da du kan risikere at du løber ud for kort midt i en runde."

Jeg er ikke med hvordan det skal gøres.

Du skal også udføre else delen hvis if delen er sand (dvs fjerne else { } ), ellers tages kortet ikke ud af Deck

Du skal køre en loop med Deck[i] = Deck[i+1]; for i = 0 til NumInDeck - 1

Du skal lave noget i stil med:
bool AllSet = false;
while(NumInDeck && !AllSet)
{
  AllSet = true;
  for(i = 0; i < 13 && NumInDeck; i++)
  {
    if(Deck[0]%13 == i)
    {
      ... 
    }
    else
    {
        AllSet = false;
    }
    // koden fra else delen ovenfor
  }
}

Hvis du hopper ud af loopen fordi AllSet == true har du vundet.

"Du skal også udføre else delen hvis if delen er sand (dvs fjerne else { } ), ellers tages kortet ikke ud af Deck"

det vil sige at bare slette

}
    else
    {

Table[NumKort[i]][i] = Deck[0];
NumKort[i]++;

Deck[i]= Deck[i+1];
NumInDeck--;

Ja, med de bemærkninger jeg anførte før.
Dvs i else skal du have AllSet = false;, det der står indenfor else {} skal flyttes ned efter else {...}

Når jeg kører det her.

bool AllSet= false;

void AntalKort()
{
if(Deck[0]%13 == i)
{  // Dette kort kommer til at ligge p? rigtig plads
  for(int x = 0; x < NumKort[i]; x++)
    Deck[NumInDeck++] = Table[x][i];
  NumKort[i] = 0;
}

while(NumInDeck && !AllSet)
{
  AllSet = true;
  for(i = 0; i < 13 && NumInDeck; i++)
  {
    if(Deck[0]%13 == i)
    {
     
    }
    else
    {
        AllSet = false;
    }   
Table[NumKort[i]][i] = Deck[0];
NumKort[i]++;

Deck[i]= Deck[i+1];
NumInDeck--;
cout <<"Antal kort tilbage i Deck"<< endl;

cout << Table[NumKort[i]][i] << " ";

            cout << endl;
    }
    getch();
}

}
udskriver den "Antal kort tilbage i deck" er 0.
den gør udskriver det flere gang, ca 10-20 gang

Det du har i den første if skal flyttes ned i den anden if

Du mangler loopen der flytter alle kort én ned i Deck (nu flytter du kun det første)

Er den så i orden nu?

int NumInDeck= 52; // antal kort i deck
bool AllSet= false;



void AntalKort()
{

    while(NumInDeck && !AllSet)
{
        AllSet = true;
    for(i = 0; i < 13 && NumInDeck; i++)
  {
    if(Deck[0]%13 == i)
    {
    for(int y = 0; y < NumKort[i]; y++)
        Deck[NumInDeck++] = Table[y][i];
        NumKort[i] = 0;
        cout << "  ";
    }
    else
    {
        AllSet = false;
    }

        Table[NumKort[i]][i] = Deck[0];
        NumKort[i]++;
        NumInDeck--;
    {
    for (int i=0; i<51; i++)   
    {
        Deck[i]= Deck[i+1];
    }

   
        cout <<"Antal kort tilbage i Deck"<< endl;

        cout << Table[NumKort[i]][i] << " ";

   
        cout << endl;
    }
    getch();


}

}
}

Det ser ok ud. Virker det?

den udskriver det her ud

Antal kort i deck
14
den skifter hver gang man kører det i gennem.

men den udskriver antal kort i Deck over 50 gang, med to forskellige værdier
fx 15 kommer frem ca. 25 og 34 ca. 25-30 gang
Er der ikke noget galt

Måske er der noget galt. Men jeg vil gerne se hele programmet for at checke.

hvad betyder AllSet

AllSet bliver sat til true inden loopen, hvis der er en bunke hvor kortet ikke ligger rigtigt bliver den sat til false. Så hvis den er true efter loopen ligger kortene rigtigt og du har vundet.