# Creating a “Card Wars” Game in .NET

CodeGuru content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

## Introduction

Hello again! As you may know, I always endeavour to write about topics that are interesting and fun. As you may also know: I love games—in another life, I would have been a game developer, but so much has changed since I have tried getting into the gaming development environment.

If you have been following my articles (or at least some!), you would know that I have written about a lot of games, mostly games involving logic. Lately, I have been writing about card games, because, well, there are only so many other games I can cover and remember. Today’s topic also covers a card game known as Card Wars.

## Card Wars

With Card Wars, you have to win all cards. In the beginning of the game, the card deck gets divided among the players. The players should place all their cards facing downwards; this creates a stack for each of the players. The players should reveal their cards simultaneously. The player with the highest card wins the battle. The winning player takes the card that lost.

If the cards shown are of the same value, a little face-off or a mini-war happens. The players should then place their next cards face down and then another card face-up. The player with the highest card wins the war and takes the other player’s card. When a player runs out of cards, he or she loses.

## Our Project

The little application that you will create today is very basic, which is the best way to learn game logic. If you do not understand how certain games work in the background and the logic to make it work, programming any game is difficult. We’ll make this a two-player game, for simplicity’s sake.

Open Visual Studio and create a Console application in either VB.NET or C#.

In the Main method of your application, create the following variables:

C#

```        int intUCard;
int intCCard;
int intUTot = 0;
int intCTot = 0;
int intSuit;
int intCount = 0;

string strUSuit;
string strCSuit;
string strUCard;
string strCCard;
string strResult = "";
```

VB.NET

```      Dim intUCard As Integer
Dim intCCard As Integer
Dim intUTot As Integer = 0
Dim intCTot As Integer = 0
Dim intSuit As Integer
Dim intCount As Integer = 0

Dim strUSuit As String
Dim strCSuit As String
Dim strUCard As String
Dim strCCard As String
Dim strResult As String = ""
```

Here, I created objects to hold the User’s and Computer’s chosen cards and totals. The other variables include the chosen suit and result. Still in the Main method, add the last few variables.

C#

```         string[] strCardNames = { "Ace", "2", "3", "4", "5", "6",
"7", "8", "9", "10", "Jack", "Queen", "King" };
string[] strCardSuits = { "Clubs", "Diamonds", "Hearts",

string[] strDrawnCards = new string[52];

int[] intDeck = new int[52];
```

VB.NET

```      Dim strCardNames As String() = {"Ace", "2", "3", "4", "5", _
"6", "7", "8", "9", "10", "Jack", "Queen", "King"}
Dim strCardSuits As String() = {"Clubs", "Diamonds", _

Dim strDrawnCards As String() = New String(51) {}

Dim intDeck As Integer() = New Integer(51) {}
```

The last few variables contain the card names, suit, a Deck object, and a variable to host the drawn cards. Add the following line of code inside your Main method:

C#

`         Shuffle(ref intDeck);`

VB.NET

`      Shuffle(intDeck)`

This line calls the procedure named Shuffle. Let’s add it now.

C#

```      private static void Shuffle(ref int[] Deck)
{

int c;

Random rndCards = new Random();

for (c = 0; c < 52; c++)
{

Deck[c] = rndCards.Next(1, 52);

}

}
```

VB.NET

```   Private Sub Shuffle(ByRef Deck As Integer())

Dim c As Integer

Dim rndCards As Random = New Random()

For c = 0 To 52 - 1

Deck(c) = rndCards.[Next](1, 52)

Next

End Sub
```

Aptly named, the Shuffle sub procedure stores the cards inside the deck at randomly generated locations. Back in the Main method, add the next For loop underneath the call to the Shuffle procedure.

C#

```         for (int x = 0; x < 26; x++)
{
intUCard = ChooseCard(intDeck, ref intCount, out
intSuit);
strUSuit = strCardSuits[intSuit];
strUCard = strCardNames[intUCard];

intCCard = ChooseCard(intDeck, ref intCount, out
intSuit);
strCSuit = strCardSuits[intSuit];
strCCard = strCardNames[intCCard];

if (intUCard > intCCard)
{

intUTot += 1;
strResult = "User wins.";

}

else if (intUCard < intCCard)
{

intCTot += 1;
strResult = "Computer wins.";

}

else if (intUCard == intCCard)
{

intUTot += 1;
intCTot += 1;

strResult = "Tie.";

}

Console.WriteLine("Deal #{0}", x + 1);

Console.WriteLine("User: {0} of {1}", strUCard,
strUSuit);
Console.WriteLine("Computer: {0} of {1}", strCCard,
strCSuit);
Console.WriteLine("{0}", strResult);
Console.WriteLine("User Score: {0}", intUTot);
Console.WriteLine("Computer Score: {0}", intCTot);

}
```

VB.NET

```      For x As Integer = 0 To 25

intUCard = ChooseCard(intDeck, intCount, intSuit)
strUSuit = strCardSuits(intSuit)
strUCard = strCardNames(intUCard)

intCCard = ChooseCard(intDeck, intCount, intSuit)
strCSuit = strCardSuits(intSuit)
strCCard = strCardNames(intCCard)

If intUCard > intCCard Then

intUTot += 1
strResult = "User wins."

ElseIf intUCard < intCCard Then

intCTot += 1
strResult = "Computer wins."

ElseIf intUCard = intCCard Then

intUTot += 1
intCTot += 1

strResult = "Tie."

End If

Console.WriteLine("Deal #{0}", x + 1)
Console.WriteLine("User: {0} of {1}", strUCard, strUSuit)
Console.WriteLine("Computer: {0} of {1}", strCCard, _
strCSuit)
Console.WriteLine("{0}", strResult)
Console.WriteLine("User Score: {0}", intUTot)
Console.WriteLine("Computer Score: {0}", intCTot)

Next
```

The loop loops 26 times, which is 52 divided by 2. Each player (you and the computer) has 26 cards. With the help of the ChooseCard method, a card gets chosen for each player and then the score gets calculated based on the parameters I mentioned earlier. The result of the game gets displayed after each hand. Add the ChooseCard method now.

C#

```      private static int ChooseCard(int[] Deck, ref int count,
out int Suit)
{
int Card;

Card = Deck[count];

count++;

Suit = (Card - 1) % 4;

return (Card - 1) / 4 + 1;

}
```

VB.NET

```   Private Function ChooseCard(ByVal Deck As Integer(), ByRef _
count As Integer, <Out> ByRef Suit As Integer) _
As Integer

Dim Card As Integer

Card = Deck(count)
count += 1

Suit = (Card - 1) Mod 4
Return (Card - 1) / 4 + 1

End Function
```

The ChooseCard method also technically generates a random number based on a calculation that the player will receive.

Running the application will result in what’s shown in Figure 1.

Figure 1: Running the game

## Conclusion

Each card game has the same components; how you use and manipulate them depends on the logic that goes with the game. Be on the lookout for another game coming soon. Until then, happy coding!

Hannes DuPreez
Ockert J. du Preez is a passionate coder and always willing to learn. He has written hundreds of developer articles over the years detailing his programming quests and adventures. He has written the following books: Visual Studio 2019 In-Depth (BpB Publications) JavaScript for Gurus (BpB Publications) He was the Technical Editor for Professional C++, 5th Edition (Wiley) He was a Microsoft Most Valuable Professional for .NET (2008–2017).