Work the Shell - Calling All Functions, and Some Math Too!

 in
Shuffle off to the next step in creating a shell script Blackjack game.

If you've been keeping track of my column, you'll know that we're building a Blackjack game as a shell script. Why? Because most shell scripts are far too boring to study without nodding off, so considering all the nuances of shell script programming within the context of a game just sounds more fun!

My last column talked about how to shuffle a deck of cards, as portrayed in a program with a simple array of 52 values, 1-52. There are some interesting nuances to the shuffle problem. Let's start there. Then we'll look at how to turn an arbitrary 1-52 value into a familiar rank and suite from a deck of cards.

The Shuffle Function

If you've been writing shell scripts since the dawn of UNIX, you might not have realized that modern shells now support functions and procedures, just like a “real” programming language. For any block of code that you plan on executing more than once, it's the way to go.

Here's the shuffle code, written as a shell function:

function shuffleDeck
{
   count=1

   while [ $count -le 52 ]
   do
      pickCard
      newdeck[$count]=$picked
      count=$(( $count + 1 ))
   done
}

This builds an array called newdeck, which is actually the shuffled deck (in the last column we showed deck, which was an array of cards in linear order), and it uses some basic shell math with the $(( )) notation to save spawning a subshell to invoke expr for each increment of the count variable.

I said that shell scripts are robust programming environments and that might be a tiny bit of hyperbole, really. Eagle-eyed readers will notice that the pickCard function returns its value by setting a global variable, picked, which isn't really optimal programming strategy. But it works, and pragmatism is an important part of any good approach to software development, isn't it?

The full pickCard function is key to making this work, but it is too long to include here, so grab it from the LJ FTP site for your reading pleasure (ftp.linuxjournal.com/pub/lj/listings/8774.tgz).

With the shuffleDeck function written and an initializeDeck function, as shown here:

function initializeDeck
{
   card=1 while [ $card -le 52 ] do
      deck[$card]=$card card=$(( $card + 1 ))
   done
}

it's easy to do the rudiments of shuffling the deck and dealing out two cards for the player and two for the dealer:

initializeDeck shuffleDeck

echo "** Player's hand: ${newdeck[1]}, ${newdeck[3]}"
echo "** Dealer's hand: ${newdeck[2]}, ${newdeck[4]}"

Let's run this and see what kind of results we get:

$ ./blackjack.sh
** Player's hand: 22, 49
** Dealer's hand: 11, 8
$ ./blackjack.sh
** Player's hand: 19, 32
** Dealer's hand: 49, 10
$ ./blackjack.sh
** Player's hand: 44, 23
** Dealer's hand: 46, 11

Displaying cards as a numeric value from 1-52 is not the most friendly, so let's turn our attention to the display of the card values in the familiar rank and suite of a traditional deck of playing cards.

Math Games to Identify Rank and Suite

A deck of cards is composed of 52 cards, split evenly into four suites of 13 cards. The order of the suites doesn't matter (in Blackjack, at least), but the rank does. Indeed, the goal of the game is have a summary rank value of 21 points without going any higher.

The rank of a card is the remainder of the numeric card value divided by 13. In math terms, this is called the modulus and can be computed thusly:

rank = cardvalue % 13

To put this into proper shell notation, we'll again use the $(( )) shortcuts and end up with:

rank=$(( $card % 13 ))

Getting the suite should be simple too; it's the other half of the division. In other words, if the card value is 17, then 17/13 = 1, meaning it's suite #1, and 17%13 = 4. Since we'd like to have our suites in the range of 1-4, rather than 0-3, however, we'll need to add one to the equation. Further, the 13th of each card is the same suite as the earlier 12, so we'll also have to subtract one before we do the division (card #13 would be suite #1 if we just calculated 13/13, but if we calculate 12/13 for that, we'll correctly identify it as part of suite #0).

This is very confusing, so here's the equation instead:

suite="$(( ( ( $card - 1) / 13 ) + 1))"

Much clearer, right? Seriously, you can experimentally verify that this works correctly. The important edge cases are value=1, value=12, value=13 and value=14. If you can get those right, you're good for all values in the deck.

Once we've identified the rank and suite of a card, we just have to do a bit of fancy footwork to turn numbers into words:

case $suite in
 1 ) suite="Hearts"  ;;
 2 ) suite="Clubs"    ;;
 3 ) suite="Spades"  ;;
 4 ) suite="Diamonds" ;;
 * ) echo "Bad suite value: $suite"; exit 1
esac

______________________

Dave Taylor has been hacking shell scripts for over thirty years. Really. He's the author of the popular "Wicked Cool Shell Scripts" and can be found on Twitter as @DaveTaylor and more generally at www.DaveTaylorOnline.com.

Comments

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

SUIT/SUITE

Anonymous's picture

AARGH - four SUITs of cards... a SUITE of rooms... where's your editor!

White Paper
Linux Management with Red Hat Satellite: Measuring Business Impact and ROI

Linux has become a key foundation for supporting today's rapidly growing IT environments. Linux is being used to deploy business applications and databases, trading on its reputation as a low-cost operating environment. For many IT organizations, Linux is a mainstay for deploying Web servers and has evolved from handling basic file, print, and utility workloads to running mission-critical applications and databases, physically, virtually, and in the cloud. As Linux grows in importance in terms of value to the business, managing Linux environments to high standards of service quality — availability, security, and performance — becomes an essential requirement for business success.

Learn More

Sponsored by Red Hat

White Paper
Private PaaS for the Agile Enterprise

If you already use virtualized infrastructure, you are well on your way to leveraging the power of the cloud. Virtualization offers the promise of limitless resources, but how do you manage that scalability when your DevOps team doesn’t scale? In today’s hypercompetitive markets, fast results can make a difference between leading the pack vs. obsolescence. Organizations need more benefits from cloud computing than just raw resources. They need agility, flexibility, convenience, ROI, and control.

Stackato private Platform-as-a-Service technology from ActiveState extends your private cloud infrastructure by creating a private PaaS to provide on-demand availability, flexibility, control, and ultimately, faster time-to-market for your enterprise.

Learn More

Sponsored by ActiveState