Shuffle A Sequentially Ordered Deck Of Playing Cards Using C#

INTRODUCTION

A long time customer of mine, who was also a gambling fan, asked me to create a non-wagering version of the Texas Hold’Em poker game. At this time, I was just beginning to learn C# coding. I needed to move away from the C++ programming code I had done for years and learn this more modern and robust software development platform. I thought this would be a “low pressure way to get my C# sea legs”. The example I will discuss is for a 6 player Texas Hold’Em poker game including the dealer. This logic has also been expanded to include 9 and 10 player games.

THE FORM’S “LOAD” EVENT FIRES THE CARD DECK SHUFFLING CODE

Upon entering the 6 player Windows Forms form in the application, the “Load” event is triggered to start the card deck shuffling code. But first, we need to do some initialization chores as detailed in the code snippet below:

private void LoadModule(object sender, System.EventArgs e)
{
// declare local variables.
int stopvar, b, c, d, setmark;
string card1, card2, currdir;
// get current working directory of game installation
currdir = Directory.GetCurrentDirectory();
currdir = currdir.Substring(0, currdir.Length - 9);
// set boundaries of form.
this.SetBounds(1, 1, 1800, 1800);
// set the start position of the form to the center of the screen.
this.StartPosition = FormStartPosition.CenterScreen;
// assign sequential playing card designators to ‘cardvault’
// character array.
cardvault[0] = "2C";
cardvault[1] = "2S";
cardvault[2] = "2H";
cardvault[3] = "2D";
cardvault[4] = "3C";
cardvault[5] = "3S";
cardvault[6] = "3H";
cardvault[7] = "3D";
cardvault[8] = "4C";
cardvault[9] = "4S";
cardvault[10] = "4H";
cardvault[11] = "4D";
cardvault[12] = "5C";
cardvault[13] = "5S";
cardvault[14] = "5H";
cardvault[15] = "5D";
cardvault[16] = "6C";
cardvault[17] = "6S";
cardvault[18] = "6H";
cardvault[19] = "6D";
cardvault[20] = "7C";
cardvault[21] = "7S";
cardvault[22] = "7H";
cardvault[23] = "7D";
cardvault[24] = "8C";
cardvault[25] = "8S";
cardvault[26] = "8H";
cardvault[27] = "8D";
cardvault[28] = "9C";
cardvault[29] = "9S";
cardvault[30] = "9H";
cardvault[31] = "9D";
cardvault[32] = "10C";
cardvault[33] = "10S";
cardvault[34] = "10H";
cardvault[35] = "10D";
cardvault[36] = "JC";
cardvault[37] = "JS";
cardvault[38] = "JH";
cardvault[39] = "JD";
cardvault[40] = "QC";
cardvault[41] = "QS";
cardvault[42] = "QH";
cardvault[43] = "QD";
cardvault[44] = "KC";
cardvault[45] = "KS";
cardvault[46] = "KH";
cardvault[47] = "KD";
cardvault[48] = "AC";
cardvault[49] = "AS";
cardvault[50] = "AH";
cardvault[51] = "AD";
// initialize the character array ‘shufflevault’ that
// will hold the shuffled card order.
for (a = 0; a < 52; a++) shufflevault[a] = " ";
// create object for random number generator for
// a specified number range.
Random RandomNumber = new Random();
// using the above object, generate a random number
// between 1 and 51.
setmark = RandomNumber.Next(1, 51);
}

Notice the card deck character array “cardvault”, is in sequential order beginning with the lowest value of “2” and then increasing to the highest value of “Ace”. Also, all four suites of a specific playing card are grouped together, in other words – “AC, AS, AH, AD” translates to “Ace of Clubs, Ace of Spades, Ace of Hearts and Ace of Diamonds”. The same methodology applies to all the other cards.

BEGIN SHUFFLING THE CARD DECK

I use 2 nested “do-while” loops to shuffle the sequentially ordered playing card deck. The outer do-while loop cycles through all 52 cards in the sequentially ordered card deck. With each pass through the outer do-while loop, a random number between 1 and 51 is generated.

The inner do-while loop does the actual shuffling of the playing cards, using the randomly generated number, that is stored in the variable “setmark”. Then the random number is assigned to a variable, “c”. The random number is decremented and that is assigned to a variable, “d”. The inner do-while loop will cycle around while the “stopvar” variable is 0 and the variable “d” is greater than or equal to 0 and the variable “c” is less than or equal to 51.

While cycling through the inner do-while loop, as many as 2 indexes in the shuffled order card deck character array “shufflevault” may be updated. Using the “c” and “d” variables as array indexes, “shufflevault[c]” and/or “shufflevault[d]” may be updated with “cardvault[b]” if the following conditions are met.

Using the variable “c” as an array index in the character array “shufflevault”, it will be updated with the value in the character array “cardvault” using the outer do-while loop variable “b” as its index if “shufflevault[c]” is empty. The outer do-while loop variable “b” will be incremented and the variable “stopvar” will be set to 1.

Using the variable “d” as an array index in the character array “shufflevault”, it will be updated with the value in the character array “cardvault” using the outer do-while loop variable “b” as its index if “shufflevault[d]” is empty and the “stopvar” variable is still set to 0. The outer do-while loop variable “b” will be incremented and the variable “stopvar” will be set to 1.

The variable “c” will be incremented and the variable “d” will be decremented before the inner do-while loop cycles around and repeats its logic.

// begin the outer loop to shuffle the cards in the deck,
// which is also the character array ‘cardvault’.
b = 0;
do
{
// initialize inner loop variable for stopping
// the processing.
stopvar = 0;
// get the randomly generated number and assign to
// the variable ‘c’.
c = setmark;
// decrement the number in ‘c’ and assign to the
// variable ‘d’.
d = c - 1;
do
{
// if the space in the ‘c’ index of the character
// array ‘shufflevault’ is empty, then assign the
// contents of ‘cardvault[b]’ to ‘shufflevault[c]’.
// increment the outer loop variable ‘b’ by one, then
// assign one to the inner loop stop variable, ‘stopvar’.
if (shufflevault[c] == " ")
{
shufflevault[c] = cardvault[b];
b++;
stopvar = 1;
}
// if the space in the ‘d’ index of the character
// array ‘shufflevault’ is empty and the
// ‘stopvar’ variable is still zero, then assign the
// contents of ‘cardvault[b]’ to ‘shufflevault[d]’.
// increment the outer loop variable ‘b’ by one, then
// assign one to the inner loop stop variable, ‘stopvar’.
if (shufflevault[d] == " " && stopvar == 0)
{
shufflevault[d] = cardvault[b];
b++;
stopvar = 1;
}
// increment ‘c’ variable and decrement
// the ‘d’ variable.
c++;
d--;
// what this does is assign or "shuffle" playing cards from
// their sequential positions to random positions in the "deck"
// by incrementing 'c' and decrementing 'd' while 'd' is greater
// than or equal to 0 and 'c' is less than or equal to 51.
// then the inner loop is exited and a new random number is selected
// between 1 and 51 and the process is repeated while the 'b' variable
// is less than 52 in the outer loop.
// end the inner loop.
} while (d >= 0 && c <= 51 && stopvar == 0);
// generate a random number between 1 and 51.
setmark = RandomNumber.Next(1, 51);
// end the outer loop.
} while (b < 52);

DEAL TWO SHUFFLED CARDS TO EACH OF SIX PLAYERS

Now that the sequentially ordered card deck in the character array “cardvault” has been “shuffled” into the character array “shufflevault”, it is time to deal 2 shuffled playing cards to each of the 5 players and the dealer. I use 6 character arrays denoted as "player1vault", "player2vault", "player3vault", "player4vault", "player5vault" and "player6vault" as seen in the code snippet below to receive the 2 character codes for specific playing cards from the “shufflevault” character array at specified indexes.

Also, I use a variable I call “placeindeck” that marks the spot where undistributed playing cards begin in the shuffled card deck. After dealing 2 playing cards to each of 6 players, the 13th card in the deck (denoted by 12 in the code) will be the next undistributed card to be used since the first dealt card starts at index 0 in the character array “shuffledeck”. Another variable I use is called “p1”, which is initialized to 0. This means the hold cards have not yet been revealed. After they have, the “p1” variable will be set to 1.

Next, the shuffled card deck indexes for the dealer are initialized (a = 5 and b = 11) as noted below. Also, the string variables for holding the bitmap image file names of playing cards in the current directory are set to “” for the string variables, card1 and card2. After testing for the 2 character code in “shufflevault[a]”, the current directory is concatenated to the specific bitmap image file name that corresponds to the 2 character code in the “if-then” logic comparison. This concatenated expression will be assigned to the “card1” string variable. Likewise with “shufflevault[b]” and “card2”.

// deal 2 cards to each of six players from the
// ‘shufflevault’ character array, which is also
// the shuffled card deck.
// player1vault, or player 1, receives shuffled cards from
// from indexes 0 and 6 in the ‘shufflevault’
// shuffled card deck, so to speak.
player1vault[0] = shufflevault[0];
player1vault[1] = shufflevault[6];
// player2vault, or player 2, receives shuffled cards from
// from indexes 1 and 7 in the ‘shufflevault’
// shuffled card deck.
player2vault[0] = shufflevault[1];
player2vault[1] = shufflevault[7];
// player3vault, or player 3, receives shuffled cards from
// from indexes 2 and 8 in the ‘shufflevault’
// shuffled card deck.
player3vault[0] = shufflevault[2];
player3vault[1] = shufflevault[8];
// player4vault, or player 4, receives shuffled cards from
// from indexes 3 and 9 in the ‘shufflevault’
// shuffled card deck.
player4vault[0] = shufflevault[3];
player4vault[1] = shufflevault[9];
// player5vault, or player 5, receives shuffled cards from
// from indexes 4 and 10 in the ‘shufflevault’
// shuffled card deck.
player5vault[0] = shufflevault[4];
player5vault[1] = shufflevault[10];
// player6vault, or player 6, is the dealer. the cards
// assigned to the dealer will be used to
// to designate ‘card1’ and ‘card2’ as noted
// below. They come from indexes 5 and 11 in the
// ‘shufflevault’ shuffled card deck.
player6vault[0] = shufflevault[5];
player6vault[1] = shufflevault[11];
// the ‘placeindeck’ variable marks the spot in the
// shuffled deck where the undistributed cards begin.
placeindeck = 12;
// this variable is initially set to 0 meaning the hold
// cards have not been revealed; set to 1 afterwards.
p1 = 0;
// initialize shuffled deck indexes for dealer and variables for
// holding bitmap image file names of dealer's cards.
a = 5;
b = 11;
card1 = "";
card2 = "";
// here, the path or current directory is concatenated to
// the bitmap file name associated with the 2 character code
// contained in the ‘a’ index of the ‘shufflevault’ variable.
// this in turn is assigned to ‘card1’.
if (shufflevault[a] == "2C")
{
card1 = currdir + "2_clubs.bmp";
}
if (shufflevault[a] == "2S")
{
card1 = currdir + "2_spades.bmp";
}
if (shufflevault[a] == "2H")
{
card1 = currdir + "2_hearts.bmp";
}
if (shufflevault[a] == "2D")
{
card1 = currdir + "2_diamonds.bmp";
}
.
.
.
.
.
.
// here, the path or current directory is concatenated to
// the bitmap file name associated with the 2 character code
// contained in the ‘b’ index of the ‘shufflevault’ variable.
// this in turn is assigned to ‘card2’.
if (shufflevault[b] == "2C")
{
card2 = currdir + "2_clubs.bmp";
}
if (shufflevault[b] == "2S")
{
card2 = currdir + "2_spades.bmp";
}
if (shufflevault[b] == "2H")
{
card2 = currdir + "2_hearts.bmp";
}
if (shufflevault[b] == "2D")
{
card2 = currdir + "2_diamonds.bmp";
}
.
.
.
.
.
.
(remaining code for setting up the playing screen follows…..)

CONCLUSION

C# is one of the most modern and versatile programming languages for most any project. To view the entire code for this Windows Forms form “Load” event, please visit my Jazztime in C# Sharp Archive web page. From the list box near the bottom, please click the selection described as “January 1, 2013 Through March 31, 2013” and you will be redirected to the page containing the code listing. I have used C# for a number of application development projects. Please see the rest of my website to learn more about my developer skills as well as my computer repair services.

3 Comments

Join the conversation! Your thoughts help the community grow.

peraiah vallambotla11y ago
HI where is the code for setbounds() method and where we declare the array cardvault. Please provide the complete data.
Douglas Miller12y ago
that's an interesting idea....
Sam Hobbs12y ago
Thank you for describing your code in such detail. An alternative algorithm for shuffling cards is to randomly pick a card and move the chosen card from the unshuffled to the shuffled. The unshuffled deck would decrease in size therefore the range of random numbers would also decrease.