Using the File class’s directory? method, you can determine if a resource is a file or something else (file, socket, pipe, etc.). This method supports the following syntax.

File.directory?(Name)

Name represents the name and path of the resource to be checked. To get a better feel for how to work with the directory? method, look at the following example.

if File.directory?("TestDir") then
  puts "It's a folder."
else
  puts "It is something else."
end

Here, the current working directory? method is used to determine whether TestDir is a file or a folder. The directory? method returns a value of true if the specified resource is a folder and value of false if it is not. Based on the results of the analysis, one of two text messages is displayed.

The File class also contains a method named file?, which can be used to determine whether a resource is a file or something else. As you can see from the following syntax, the file? method is very similar to the directory? method.

File.file?(Name)

Name represents the name and path of the resource to be checked. To get a better feel for how to work with the file? method, look at the following example.

if File.file?("Hello.txt") then
  puts "It's a file."
else
  puts "It is something else."
end

Here, the example looks for a file named Hello.txt located in the current working directory.

Before reading from a file or overwriting an existing file with a new file, you may want to first check to see if the file has anything in it. Based on this analysis, you could avoid trying to read from an empty file or decide to write new data to the end of a file in append mode instead of overwriting any existing data.

To determine if a file has any data in it, you can use the File class’s size method, which has the following syntax. This method returns a count of the specified file’s size in bytes.

File.size(Name)

Name represents the name and path of the resource to be checked. To get a better feel for how to work with the size method, look at the following example.

puts "File Hello.txt is " + File.size("Hello.txt").to_s + " bytes in size."

Here, a text string is displayed that shows the size of a file named Hello.txt located in the current working directory.

In addition to the size method, you can also use the size? method to determine the size of a file. The syntax for this method is shown next. This method returns the size of the file, in bytes. However, if the file is empty, a value of nil is returned instead.

File.size?(Name)

Name represents the name and path of the resource to be checked. To get a better feel for how to work with the size method, look at the following example.

if File.size?("Hello.txt") > 0 then
  puts "Processing file"
else
  puts "File processing skipped"
end

Here, the size? method is used to determine whether a file should be processed. If the size of the file is greater than zero bytes, it is processed. Otherwise it is not processed.

Ruby gives you the ability to list the contents in a folder using the Dir class’s entries method, which returns the contents of the list as an array. You can then iterate through the array and work with each individual file or folder as necessary. The entries method has the following syntax.

Dir.entries(Name)

Name represents the name and path of the directory to be processed. To get a better feel for how to work with the entries method, look at the following example.

puts Dir.entries(".")

Here, the puts method is used to display the contents of the current working directory, as provided by the entries method. When executed, this statement will display output similar to that shown here.

c:Ruby_scripts>test
.
..
BlackJack.rb
Crazy8Ball.rb
NumberGuess.rb
RPS.rb
RubyJoke.rb
SupermanQuiz.rb
TallTale.rb
Test.rb
TypingChallenge.rb
WordGuess.rb

Hint

In Ruby, the . character can be used as a shortcut for representing the current working directory.

You can also produce a list of all the files stored in a folder using the Dir class’s foreach method, as demonstrated here:

Dir.foreach(".") do |resource|
  puts resource
end

Here, a loop has been set up that iterates through every file and folder stored in the current working directory. The advantage of using the foreach method in this manner is that it provides you with the ability to take multiple actions against folder contents by allowing you to place as many statements as you want inside the loop.

Let’s begin the creation of the Ruby Blackjack game by starting up your favorite text or script editor and creating a new Ruby script file. Save this file with a file name of Blackjack.rb and store it in the same folder as the rest of your Ruby script files.

Okay, now let’s add the usual list of comment statements to the beginning of the script file to document the script file and explain what it does. To do this, add the following statements to the end of the script file.

#--------------------------------------------------------------------------
#
# Script Name: BlackJack.rb
# Version:     1.0
# Author:      Jerry Lee Ford, Jr.
# Date:        October 2007
#
# Description: This Ruby game is a virtualized casino card game in which
#              the player competes against the dealer (computer) in an
#              effort to build a hand that comes as close as possible to 21
#              without going over.
#
#--------------------------------------------------------------------------

The Ruby Blackjack game will make use of two custom classes, which will provide you with access to collections of methods required to control user interaction and the overall execution of the game. The code statements for the script’s first class, the Screen class, are shown next and should be added to the end of the script file.

#Define a class representing the console window
class Screen

  def cls  #Define a method that clears the display area
    puts ("
" * 25)  #Scroll the screen 25 times
    puts "a"  #Make a little noise to get the player's attention
  end

  def pause    #Define a method that pauses the display area
    STDIN.gets  #Execute the STDIN class's gets method to pause script
                #execution until the player presses the Enter key
  end

end

The Screen class defines two methods. The cls method writes 25 blank lines to the console window and then plays a beep sound. The pause method pauses script execution whenever it is called and waits for the player to press the Enter key.

The Game class contains eight methods, which provide you with control over the game’s execution. To begin the creation of the Game class, append the following statements to the end of the script file.

#Define a class representing the Ruby Blackjack game
class Game

end

The first method defined in the Game class is display_greeting. It is responsible for displaying the game’s welcome message. The statements that make up this method are shown next and should be inserted inside the Game class’s opening and closing statements.

#This method displays the game's opening message
def display_greeting

  Console_Screen.cls  #Clear the display area

  #Display a welcome message
  print "			Welcome to the Ruby Blackjack Game!" +
  "













Press Enter to " +
             "continue. "

  Console_Screen.pause     #Pause the game

end

The next method defined in the Game class is the display_instructions method. This method displays the game instructions using a series of text strings. The statements that make up this method are shown next and should be added to the Game class definition, immediately after the display_greeting method.

#Define a method to be used to display game instructions
def display_instructions

  Console_Screen.cls       #Clear the display area
  puts "INSTRUCTIONS:

"  #Display a heading

  #Display the game's instructions
  puts "This game is based on the Blackjack card game. In this"
  puts "game the player and dealer are each dealt an initial card. The"
  puts "player is then prompted to draw additional cards. The player"
  puts "may draw as many additional cards as desired, as long as the"
  puts "player's hand remains less than 21. If the player's hand goes"
  puts "over 21, the player busts and the dealer automatically"
  puts "wins. Once the player decides to hold, it becomes the dealer's"
  puts "turn. The dealer will continue to add new cards to its hand"
  puts "until the value exceeds 17 or the dealer busts. Once the"
  puts "dealer's hand is complete, the game analyzes the player's hand"
  puts "and the dealer's hand to determine the results of the game."
  puts "






"
  print "Press Enter to continue. "
  Console_Screen.pause      #Pause the game

end

The next method defined in the Game class is the play_game method, which is responsible for managing an individual round of play. The statements that make up this method are shown next and should be added to the end of the class definition, immediately after the display_instructions method.

#Define a method to control game play
def play_game

  Console_Screen.cls       #Clear the display area

  #Assist the player and dealer with an initial starting card
  playerHand = get_new_card
  dealerHand = get_new_card

  #Call the method responsible for dealing new cards to the player
  playerHand = complete_player_hand(playerHand, dealerHand)

  #If the player has not busted, call the method responsible for managing
  #dealer's hand
  if playerHand <= 21 then
    dealerHand = play_dealer_hand(dealerHand)
  end

  #call the method responsible for determining the results of the game
  determine_winner(playerHand, dealerHand)

end

This method begins by calling on the get_new_card method two times to assign an initial card to both the player’s and dealer’s opening hand. Since the player always goes before the dealer, the complete_player_hand method is called next and is passed the value of the player’s and dealer’s hand as an argument. The complete_player_hand method is responsible for adding new cards to the player’s hand until the player busts or decides to stick with the cards currently in her hand, after which it returns a value representing the current value of the player’s hand. This value is then examined to see if it exceeds 21, in which case the player has gone bust. If the player has not gone bust, the play_dealer_hand method is called and passed the current value of the dealer’s hand as an argument. The play_dealer_hand method is responsible for playing out the dealer’s hand and then returning the result of that hand. The last statement in the player_game method calls up on the determine_winner method, passing it the current value of the player’s and dealer’s hands. The determine_winner method analyzes these two arguments to determine the result of the game.

The next method to be added to the Game class is the get_new_card method, whose statements are shown here:

#Define a method responsible for dealing a new card def
get_new_card

  #Assign a random number from 1 to 13 as the value of the card being
  #created
  card = 1 + rand(13)

  #A value of 1 is an ace, so reassign the card a value of 11
  return 11 if card == 1

  #A value of 10 or more equals a face card so reassign the card a value
  #of 10
  return 10 if card >= 10

  return card  #Return the value assigned to the new card

end

When called, this method generates a random number from 1 to 13, which it assigns to a variable named card. If the value of card is set equal to 1, the card is considered to be an ace. As such, the value of card is reassigned a value of 11. On the other hand, if the value of card is greater than or equal to 10, it is assumed that the card is either a 10 or a face card (Jack, Queen, or King) and as such the value of card is set equal to 10. Once the value assigned to card is finally established, it is returned back to the statement that called upon the method to execute.

The next method defined in the Game class is the complete_player_hand method, which is responsible for assisting the player in completing her hand. The statements that make up this method are shown next and should be added to the end of the class definition, immediately after the get_new_card method.

#Define a method responsible for dealing the rest of the player's hand
def complete_player_hand(playerHand, dealerHand)

  loop do  #Loop forever

    Console_Screen.cls  #Clear the display area

    #Show the current state of the player's and dealer's hands
    puts "Player's hand: " + playerHand.to_s + "

"
    puts "Dealer's hand: " + dealerHand.to_s + "





"
    print "Would you like another card? (Y/N) "

    reply = STDIN.gets  #Collect the player's answer
    reply.chop!  #Remove any extra characters appended to the string

    #See if the player decided to ask for another card
    if reply =~ /y/i then
      #Call method responsible for getting a new card and add it to the
      #player's hand
      playerHand = playerHand + get_new_card
    end

    #See if the player has decided to stick with the current hand
    if reply =~ /n/i then
      break  #Terminate the execution of the loop
    end

    if playerHand > 21 then
      break  #Terminate the execution of the loop
    end

  end

  #Return the value of the player's hand
  return playerHand

end

This method is passed two arguments, playerHand and dealerHand, which represent the current value of the player’s and dealer’s hands. The value of both hands is displayed and the player is then asked if she would like another card. If the player elects to add another card to her hand, the value assigned to playerHand is incremented, adding the result returned by the get_new_card method to the value of playerHand. The player may add as many cards as desired to her hand, provided that the total value of her hand does not exceed 21. Once the player busts or decides not to draw more cards, the method ends by returning the current value of the player’s hand back to the statement that called upon the method to execute.

The next method defined in the Game class is the play_dealer_hand method, which is responsible for completing the dealer’s hand. The statements that make up this method are shown next and should be added to the end of the class definition, immediately after the complete_player_hand method.

#Define a method responsible for managing the dealer's hand
def play_dealer_hand(dealerHand)

  loop do  #Loop forever

    #If the value of the dealer's hand is less than 17 then give the
    #dealer another card
    if dealerHand < 17 then
      #Call method responsible for getting a new card and add it to the
      #dealer's hand
      dealerHand = dealerHand + get_new_card
    else
      break  #Terminate the execution of the loop
    end

  end

  #Return the value of the dealer's hand
  return dealerHand

end

This method takes as an argument the current value of the dealer’s hand. The method then repeatedly calls upon the get_new_card method, adding new cards to the dealer’s hand until the total value of the dealer’s hands exceeds 17, at which time the method returns the current value of the dealer’s hand to the calling statement and then ends.

The next method defined in the Game class is the determine_winner method, which is responsible for determining the results of the game. The statements that make up this method are shown next and should be added to the end of the class definition, immediately after the play_dealer_hand method.

#Define a method responsible for analyzing the player's and dealer's
#hands and determining who won
def determine_winner(playerHand, dealerHand)

  Console_Screen.cls  #Clear the display area

  #Show the value of the player's and dealer's hands
  puts "Player's hand: " + playerHand.to_s + "

"
  puts "Dealer's hand: " + dealerHand.to_s + "





"

  if playerHand > 21 then  #See if the player has busted
    puts "The Player busts!

"
    print "Press Enter to continue."
  else  #See if the player and dealer have tied
    if playerHand == dealerHand then
      puts "Tie!

"
      print "Press Enter to continue."
    end
    #See if the dealer has busted
    if dealerHand > 21 then
        puts "The Dealer busts!

"
        print "Press Enter to continue."
    else
      #See if the player's hand beats the dealer's hand
      if playerHand > dealerHand then
        puts "The Player wins!

"
        print "Press Enter to continue."
      end
      #See if the dealer's hand beats the player's hand
      if playerHand < dealerHand then
        puts "The Dealer wins!

"
        print "Press Enter to continue."
      end
    end
  end

  Console_Screen.pause        #Pause the game

end

This method is passed two arguments, representing the current value of the player’s and dealer’s hands. It then displays both of these values and, using a series of nested if statements, determines the overall result of the game. Based on the analysis, the method displays an appropriate message.

The last method to be added in the Game class is the display_credits method. This method is responsible for displaying the game’s credits, including the author’s URL. The statements that make up this method are shown next and should be added to the end of the Game class.

#This method displays information about the Ruby Blackjack game
def display_credits

  Console_Screen.cls  #Clear the display area

  #Thank the player and display game information
  puts "		     Thank you for playing the Ruby Blackjack game.



"
  puts "
			 Developed by Jerry Lee Ford, Jr.

"
  puts "				  Copyright 2007

"
  puts "			URL: http://www.tech-publishing.com









"

end

Now that both of the script’s custom classes have been defined, it is time to initialize instances of both classes. This is done by appending the following statements to the end of the script file.

# Main Script Logic -----------------------------------------

Console_Screen = Screen.new  #Instantiate a new Screen object
BJ = Game.new  #Instantiate a new Game object

#Execute the Game class's display_greeting method
BJ.display_greeting

answer = ""  #Initialize variable and assign it an empty string

In addition to instantiating the Console_Screen and BJ objects, these statements call upon the Game class’s display_greeting method, which is responsible for prompting the player for permission to start the game, and then define a variable named answer, which will be used to manage the execution of a loop.

The following script statements are responsible for prompting the player for permission to begin the game and should be added to the end of the script file.

#Loop until the player enters y or n and do not accept any other input
loop do

  Console_Screen.cls  #Clear the display area

  #Prompt the player for permission to start the game
  print "Are you ready to play Ruby Blackjack? (y/n): "

  answer = STDIN.gets  #Collect the player's answer
  answer.chop!  #Remove any extra characters appended to the string

  #Terminate the loop if valid input was provided
  break if answer =~ /y|n/i

end

These statements are controlled by a loop that runs forever. Upon each iteration of the loop, the player is prompted for permission to start a new round of play. Any input other than a y or n is ignored. Once valid input is provided, a break command is executed, terminating the loop and allowing the rest of the script to execute.

The rest of the statements that make up the Ruby Blackjack game are shown next and should be appended to the end of the script file. These statements are responsible for managing the overall execution of the game.

#Analyze the player's answer
if answer == "n"  #See if the player wants to quit

  Console_Screen.cls  #Clear the display area

  #Invite the player to return and play the game some other time
  puts "Okay, perhaps another time.

"

else  #The player wants to play the game

  #Execute the Game class's display_instructions method
  BJ.display_instructions

  playAgain = ""  #Initialize variable and assign it an empty string

  loop do  #Loop forever

    #Execute the Game class's play_game method
    BJ.play_game

    loop do  #Loop forever

      Console_Screen.cls  #Clear the display area
      #Find out if the player wants to play another round
      print "Would you like to play another hand? (y/n): "

      playAgain = STDIN.gets  #Collect the player's response
      playAgain.chop!  #Remove any extra characters appended to the string
      #Terminate the loop if valid input was provided
      break if playAgain =~ /n|y/i

end

#Terminate the loop if valid input was provided
break if playAgain =~ /n/i

end

#Call upon the Game class's determine_credits method
BJ.display_credits

end

These statements are controlled by a large if code block. The script statements that are executed depend on the player’s input. If the player decides not to play the game, a message is displayed encouraging the player to return and play another time. If, on the other hand, the player decides to play, the Game class’s display_instructions method is executed. Next, a loop executes that repeatedly calls upon the Game class’s play_game method. Each time the play_game method finishes executing, control returns to the loop, which prompts the player to play again. The player may play as many times as she wants. Once she decides to stop playing, a break command is executed, terminating the loop and allowing the display_credits method to execute.