A VB.NET Version of the Spider Solitaire Game

• Download source - 6 MB

Introduction

The program implements the standard two-deck version of Spider. This version is called Redback. The classes that represent cards, stacks of cards, and move history could be reused for other card based solitaire games since the specific game logic is on the tableau form.

Background

RedBack is modelled on the Windows 3.1 shareware game Arachnid that my wife loved to play. This game didn't work under Windows 95 - it would load but the cards wouldn't show - so I wrote my version as a learning exercise in Visual Basic object based programming.

In 2004, I converted the game from VB6 to VB.NET, using the 1.1 .NET framework. I added more spider graphics plus an option to hide the pictures for the arachnophobic.

In keeping with the original name, I called my version RedBack after an infamous Australian spider. It is a close relative of the Black Widow.

I recently redid the graphics and tidied up the code for this article.

Redback has some irregular features that I added at my wife's request:

• You can undo moves and deals right back to the beginning of the game.
• You can make moves simply by clicking the card you want to move.

Creating the graphics

The first version used the card graphics that came with early Windows 3.1 solitaire games. By today's standards, they are too small, and scaling them up reduced the image quality. I created the card faces by running an old deck of cards through a sheet-feed scanner. I then processed the images using Paint.Net. I added a two pixel wide black border with rounded corners. Initially, the corner areas outside the border were white and they looked bad on the screen. I didn't feel like going back and manually resetting those few pixels to transparent. That would have required 52 x 4 separate edits working at the pixel level. Instead, I added code to make the offending pixels transparent.

Public Sub CleanUpCorners(ByRef bmp As System.Drawing.Bitmap, color As Drawing.Color)
    Dim limits() As Integer = {7, 5, 4, 3, 2, 1, 1}
    For y As Integer = 0 To 6
        For x As Integer = 0 To limits(y) - 1
            bmp.SetPixel(x, y, color)
            bmp.SetPixel(bmp.Width - 1 - x, y, color)
            bmp.SetPixel(x, bmp.Height - 1 - y, color)
            bmp.SetPixel(bmp.Width - 1 - x, bmp.Height - 1 - y, color)
        Next
    Next
End Sub
'
' How to invoke
bmp = New Bitmap(clsResources.GetImage("c" + .GetImageIndex(.Suit, .Rank).ToString()))
CleanUpCorners(bmp, System.Drawing.Color.Transparent)

It is not perfect, because the pixels are changed before the image gets scaled.

I wanted a spider themed background so I obtained some Australian spider photographs from an Australian expert on spiders, with his permission, of course. These are used to create a tiled background image. There is a menu option labelled "I hate spiders" to turn off this beautiful background feature. I didn't want to implement this menu option, but my wife was adamant.

Building Blocks

Tableau

The tableau is a standard VB.NET form. It has a panel control for the splash screen, eight panel controls for completed suits, and ten panels for the cards that are dealt. It also has 104 picture boxes to hold card images. They could more easily be created at run-time but this was a legacy from the original VB6 version.

Playing Card object

This is a card game, so it needs a class that represents a single card. The class Card represents an instance of a card. It declares public Enums to define the possible decks, suits and ranks. It also has these properties

Rank As RankSet
Size as CardSize
FaceUp As Boolean
Playable As Boolean
Clickable As Boolean
Dragable As Boolean
Left As Single
Top As Single
Stack As Stack
StackPosition As Short
Image As System.Windows.Forms.PictureBox

The class clsCard also needs to respond to events on the Image, a standard PictureBox. The requisite events are Mouse_Down, Mouse_Up and Mouse_Move. In Spider, you can move stacks of cards of the same suit as a group. Initially, moving multiple cards with a drag and drop operation resulted in horrible flickering. The solution was very simple. Just set the form property DoubleBuffered to True.

Stack object

Solitaire card games involve moving cards from one stack of cards to another stack of cards. The class clsStack represents a stack of cards. It inherits from CollectionBase, and I haven't updated it to use a generic list object.

Internally, it now uses a Dictionary object to store cards. It exposes the following properties:

Left
Top
SmallHorizontalSpace
LargeHorizontalSpace
SmallVerticalSpace
LargeVerticalSpace
VerticalSpacing
HorizontalSpacing
StackKey                ' Enum denoting which stack is represented. Values are STOCK, PILE1 thru PILE10, and HOME1 thru HOME10
TOS                     ' Top of Stack index
Open                    ' Stack can be played to

The class implements methods for each EnumMoveType and for going back one move and back one deal. It would not need changing to cater to a different game.

Stacks object

This is a collection object that holds sets of stack objects. It provides a way to iterate through a collection of stacks.

Dealer object

 

This object deals cards in pseudo random order. It implements a DealCard method and a CardsLeft property. Its most important method is DealCard. It looks like this:

Public Function DealCard(ByVal faceUp As Boolean) As Card
    Dim deck As Card.DeckSet
    Dim suit As Card.SuitSet
    Dim rank As Card.RankSet
    Dim card As Card = Nothing
    If Me.CardsLeft = 0 Then
        Return Nothing
        Exit Function
    End If
    Select Case _DealMode
        Case EnumDealMode.RANDOM_DEAL
            Do
                deck = GetRandom(Card.DeckSet.DECK_ONE, _Decks - 1)
                rank = GetRandom(Card.RankSet.LOWEST_RANK + 1, Card.RankSet.HIGHEST_RANK - 1)
                suit = GetRandom(Card.SuitSet.LOWEST_SUIT + 1, Card.SuitSet.HIGHEST_SUIT - 1)
            Loop Until _CardRecords(deck, rank, suit).Dealt = False
            _Seq = _Seq + 1
            _CardRecords(deck, rank, suit).Dealt = True
            _CardRecords(deck, rank, suit).Seq = _Seq
            card = _Cards.Item(CStr(deck) & "." & CStr(rank) & "." & CStr(suit))
            card.FaceUp = faceUp
    End Select
    DealCard = card
End Function

The function selects a random card based on deck, suit and rank. If that card has already been dealt, it tries again. It is game independent.

Move Logging object

Since the RedBack version of Spider implements unlimited undos and deal undos, it needs to track every move and provide methods to undo them. This class handles that complexity.

The class also exposes these two Enums:

Public Enum MoveTypeSet
    START_DEAL
    END_DEAL
    START_MOVE
    END_MOVE
    MOVE_CARD_FROM_PILE_TO_LIST
    MOVE_CARD_FROM_LIST_TO_PILE
    TURN_CARD_FACE_UP
End Enum
Public Enum ReplayTypeSet
    UNDO_ONE_MOVE
    DEAL_1
    DEAL_2
    DEAL_3
    DEAL_4
    DEAL_5
End Enum

Each move is logged so it can be reversed by an undo. Here is the logic that logs a valid card click. It logs the removal of a card from a stack, its placement on a new stack, and whether the newly exposed card needs to be turned face up.

_Log.StartMove()
Stop_Redraw()
For cardIndex = oldPile.Count To startIndex Step -1
    moved = moved + 1
    cardsToMove(moved) = oldPile.RemovedCard
    _Log.MoveCardFromPileToList((oldPile.StackKey))
Next cardIndex
For cardIndex = moved To 1 Step -1
    pile.AddCard(cardsToMove(cardIndex))
    _Log.MoveCardFromListToPile((pile.StackKey))
Next cardIndex
If Not oldPile.TopCard Is Nothing Then
    If oldPile.TopCard.FaceUp = False Then
        oldPile.TurnUpTopCard()
        _Log.TurnCardFaceUp((oldPile.StackKey))
    End If
End If
pile.Refresh()
oldPile.Refresh()
_Log.EndMove()
Start_Redraw()

Game Logic

The actual game logic is implemented on the form. This may not be the best place to put it; a configurable game engine would be better. However, that was where it was in the original VB6 version so that is where it lives now. The first step is creating the initial tableau or starting position. RedBack calls a method called StartGame to get things underway. It shows a splash screen, which is just a Panel control. It needs to be dismissed before anything can happen. StartGame then instantiates and populates a stack for the STOCK, ten stacks for the playable columns and eight stacks to receive completed suits. To reduce screen flicker, it encloses this operation between calls to Stop_Redraw and Start_Redraw.

Public Declare Function LockWindowUpdate Lib "user32" (ByVal hwndLock As Integer) As Integer
'
' API calls to stop Windows refreshing during complex operations. Not so necessary when form.DoubleBuffered is set to true.
Public Sub Stop_Redraw()
    LockWindowUpdate(Me.Handle)
End Sub
Public Sub Start_Redraw()
    LockWindowUpdate(0)
End Sub

Once the game is initialized, it waits for the player to click or drag cards. These events are handled in the Card class. The MouseMove event has to deal with the fact that there may be cards of the same suit on top of the card being dragged.

It invokes a method in the Card class called MoveCardsOnTop. This methods looks for the cards on top and moves them along with the selected card. It uses SetBounds to move elements, rather than setting left and top in two separate statements.

Here is the method.

Private Sub MoveCardsOnTop()
    Dim pile As Stack
    Dim cardIndex As Short
    Dim verticalSpace As Single
    pile = Me.Stack
    verticalSpace = pile.VerticalSpacing
    For cardIndex = Me.StackPosition + 1 To pile.Count
        With pile.Card(cardIndex).Image
            .SetBounds(Me.Image.Left + pile.HorizontalSpacing, Me.Image.Top + verticalSpace, 0, 0, Windows.Forms.BoundsSpecified.x Or Windows.Forms.BoundsSpecified.y)
        End With
        verticalSpace += pile.VerticalSpacing
    Next cardIndex
End Sub

The Card MouseUp event has to decide whether it is responding to a drag and drop event, or a click event. It does it by timimg the duration betweem the original MouseDown event and the MouseUp event. If the duration is less than 0.2 seconds, it assumes it is responding to a click event. In either case, it invokes methods on the form to process the event. Here is the event code.

Private Sub _imgCard_MouseUp(ByVal eventSender As System.Object, ByVal eventArgs As System.Windows.Forms.MouseEventArgs) Handles _CardImage.MouseUp
    Dim newTime As Double
    If Not _Playable Then
        Exit Sub
    End If
    newTime = Microsoft.VisualBasic.DateAndTime.Timer
    If (newTime - _MouseDownTime) < 0.2 Then
        _Moving = False
    End If
    If _Moving Then
        _Moving = False
        frmTableau.ProcessCardDrop(Me)
    Else
        frmTableau.ProcessCardClick(Me)
    End If
    _MouseDown = False
End Sub

The frmTableau.ProcessCardClick method processes a card click. It goes through the various actions it can take to respond to a card click. If it is the Stock pile, then it deals another row onto the column stacks. If a complete suit has been selected, then it moves the suit to a Home pile. Otherwise, it looks for a matching suit and rank. If it doesn't find that, it looks for a matching suit. If it doesn't find that, it looks for an empty column. If the search it unsuccessful, it returns. Otherwise, it makes the move and finishes up. The move logic is done using methods of the Stack object. Here is the logic:

moved = 0
For cardIndex = oldPile.Count To startIndex Step -1
    moved = moved + 1
    cardsToMove(moved) = oldPile.RemovedCard
    _Log.MoveCardFromPileToList((oldPile.StackKey))
Next cardIndex
For cardIndex = moved To 1 Step -1
    pile.AddCard(cardsToMove(cardIndex))
    _Log.MoveCardFromListToPile((pile.StackKey))
Next cardIndex
If Not oldPile.TopCard Is Nothing Then
    If oldPile.TopCard.FaceUp = False Then
        oldPile.TurnUpTopCard()
        _Log.TurnCardFaceUp((oldPile.StackKey))
    End If
End If

Resizing

Some versions of Spider have a problem when too many cards are added to a column stack and they disappear off the bottom of the board and become unreachable. To overcome that, Redback lets the player choose between large, medium and small card sizes.

Animation

The beta tester, a.k.a my wife, wanted to see the cards being dealt when the stock was clicked. I added a method for moving a card wth animation. Getting smooth animation without flickering proved to be a bit of a challenge. In the case of this code, I suspect the underlying problem is that there are so many controls on the form. Every screen paint probably iterates though all these controls to see if they need to be repainted. The solution was to disable the form during the animation.

I also added animation to the card click, so you can see the card move to its selected destination. This is the animation method.

Private Sub AnimateMove(oldPile As Stack, startIndex As Integer, pile As Stack, cumVertOffSet As Integer, throttle As Integer)
    Dim left As Integer
    Dim top As Integer
    '
    ' Work out how many steps there are from source pile to target pile. Throttle increases the number of steps.
    Dim steps As Integer = Math.Max(Math.Abs(oldPile.LeftPos - pile.LeftPos), Math.Abs(oldPile.Top - pile.Top)) / throttle
    Select Case _Speed
        Case SpeedSet.FAST
            steps = Math.Min(_FastTHrottle, steps)
        Case SpeedSet.MEDIUM
            steps = Math.Min(_MediumThrottle, steps)
        Case SpeedSet.SLOW
            steps = Math.Min(_SlowThrottle, steps)
    End Select
    '
    ' Locate the left and top co-ordinates in the target pile
    Dim leftTarget As Integer = If(pile.Count = 0, pile.LeftPos, pile.TopCard.Image.Left)
    Dim topTarget As Integer = If(pile.Count = 0, pile.Top, pile.TopCard.Image.Top) + cumVertOffSet
    '
    ' Get the card to move and its co-ordibates
    Dim card As Card = oldPile.ThisCard(startIndex)
    Dim leftSource As Integer = card.Image.Left
    Dim topSource As Integer = card.Image.Top
    '
    ' Calculate how far to move on each iteraction
    Dim leftInc As Integer = (leftTarget - leftSource) / steps
    Dim topInc As Integer = (topTarget - topSource) / steps
    With card.Image
        left = .Left
        top = .Top
        '
        ' Critical step. If this isn't done, the animation flickers badly
        Me.Enabled = False
        '
        ' Iterate through the steps
        For i As Integer = 1 To steps
            '
            ' On last step, force card to target location
            If i = steps Then
                left = leftTarget
                top = topTarget
            Else
                left += leftInc
                top += topInc
            End If
            '
            ' Slow things down
            Thread.Sleep(1)
            '
            ' Move the card
            .SetBounds(left, top, .Width, .Height, Windows.Forms.BoundsSpecified.X Or Windows.Forms.BoundsSpecified.Y)
            '
            ' Ensure it is visible
            .BringToFront()
            .Refresh()
            '
            ' Let Windows do its thing
            Application.DoEvents()
        Next
        '
        ' Reset the card position
        card.Top = topTarget
        card.LeftPos = leftTarget
        '
        ' Re-enable the tableau.
        Me.Enabled = True
    End With
End Sub

Help

I created a help file for the VB6 version using Robohelp. When I tried to update it, I found I didn't have RoboHelp installed anymore. So, I created a simple HTML help file. It looks better than the old .CHM file.

Using the code

This code uses intermediate VB.NET coding techniques. As such, it should be relatively easy for an intermediate developer to adapt the code for other or additional solitaire games. The Card, Stack, Dealer, and LogMove classes are not specific to Spider solitaire and could be used without change in another game.

Some mail servers reject zip files containing files with with the extension .vb. After you extract the files from the zip file, change the extension of .vbsrc files to .vb.

Points of Interest

The ability to click a card and have it move to the most obvious location speeds up the game. Unlimited undos remove the frustration of playing one of the more challenging Solitaire games. The spider backgrounds are a novelty that most players will turn off.

History

First Version for Code-Project