When working with double-quoted strings, Ruby recognizes a number of escape characters that, when found, are automatically replaced with the appropriate corresponding operation. For example, Ruby supports escape characters that execute tab and new line operations. By embedding these escape characters within double-quoted strings, you can exercise detailed control over the manner in which Ruby renders the strings when it displays them. Table 3.1 provides a list of escape characters that you can use to exercise control over text formatting within strings.

To get a good understanding of how to work with escape characters, it helps to see a few examples.

puts "1 2 3 4 5"

When executed, this statement results in the following output.

1 2 3 4 5

Now, let’s reformat this example by embedding a series of escape characters.

puts "	1 	2 	3 	4 	5"

This time when you execute the statement, the following output is displayed.

1   2   3   4   5

As you can see, by embedding the escape character, you can perform tab operations that affect how the string is displayed. Now, look at this next example.

puts "
1 
2 
3 
4 
5"

This time the escape character has been placed before each number in the text string. Since this escape character is the equivalent of a new line operation, when executed this statement produces the following output.

1
2
3
4
5

Hint

You will get the chance to work with escape characters again when you work on this chapter’s game project, the Ruby Virtual Crazy 8 Ball game.

String interpolation, also referred to as variable substitution, is performed by embedding a text string inside other strings using the #{} characters. Interpolation is the process of substituting the value of an expression or variable inside a string. To see how this works, look at the following statements.

totalScore = 100
puts "Game over. Your score is #{totalScore}."

When executed, these two statements produce the following output.

Game over. Your score is 100.

As you can see, the value stored in the totalScore variable has been substituted into a pre-specified location in the text string. As has been stated, interpolation also works with expressions.

totalScore = 100
bonusPoints = 50
puts "Game over. Your score is #{totalScore + bonusPoints}."

When executed, these statements generate the following output.

Game over. Your score is 150.

As you can see, Ruby added together the values of totalScore and bonusPoints and then substituted the resulting value into the text string in place of the specified expression.

Hint

You will get the chance to work with variable substitution again when you work on this chapter’s game project, the Ruby Virtual Crazy 8 Ball game.

Earlier in the chapter, you learned how to perform string interpolation. As an alternative to string interpolation, you could achieve the same results using string concatenation. Concatenation is the process of joining two strings together to form a new string. Concatenation is performed using the + string method. To see how concatenation works, consider the following example.

totalScore = 100
puts "Game over. Your score is " + totalScore.to_s + "."

Here, three strings have been concatenated together. The first string is "Game over. Your score is ". The second string was created by converting the numeric value of totalScore to a string using the to_s method, and the third string is ".". When executed, this statement generates the following output:

Game over. Your score is 100.

Here is another example of how to concatenate strings together. This time, in addition to concatenating the two strings, the escape character has been included to control the format of the resulting new string.

story = "Welcome to Ruby Programming for the Absolute Beginner"
author = "by Jerry Lee Ford, Jr."
puts story + "

" + author

When executed, these statements generate the following output.

Welcome to Ruby Programming for the Absolute Beginner

by Jerry Lee Ford, Jr.

In addition to creating new strings by concatenating existing strings together, you can also create new strings by multiplying existing strings. This is accomplished using the String class’s * method.

x = "Happy birthday to you. " * 3
puts x

Here, the text string "Happy birthday to you. " is repeated three times as shown here:

Happy birthday to you. Happy birthday to you. Happy birthday to you.

Another commonly performed string operation is to compare two strings to see whether they are equal. This is accomplished using the equality operator (= =). You have already seen examples of string comparisons numerous times in this book. For example, look at the following statements.

puts "Would you like to hear a few funny jokes? (y/n) "
answer = STDIN.gets
answer.chop!

if answer = = "n"  #See if the player elected not to play

Here, the user is prompted to enter a value of y or n. The user’s input is then captured as answer, which is then used in the last statement to determine whether the value of answer is equal to the value of "n".

Trap

String comparisons are performed using the == operator and not the = operator. Because they are similar, it is easy to get them mixed up. To see what I mean, start up a new irb session, and execute the statements shown here:

irb(main):001:0> x = 1
=> 1
irb(main):002:0> y = 2
=> 2
irb(main):003:0> puts "x and y are equal" if x = y
x and y are equal
=> nil

Here, x has been set equal to 1 and y has been set equal to 2. The puts statement displays a text string message only in the event that the values of x and y are equal. Therefore, when the puts statement is executed, it would seem to make sense that nothing would be displayed. However, this is not the case. Instead, the test string "x and y are equal" is displayed. To find out why, execute the commands shown here:

irb(main):004:0> x
=> 2
irb(main):005:0> y
=> 2

As you can see, the value of x is set equal to 2 as expected. However, the value of y has also been set to 2 and not to 1. The reason is because there is an error in the puts statement that was previously executed. It used the equals assignment operator (=) and not the equals comparison operator (==). As a result, instead of comparing x and y, the puts statements assigned the value of y to x.

Now, to prove that the above explanation is accurate, execute the following statements using the irb.

irb(main):001:0> x = 1
=> 1
irb(main):002:0> y = 2
=> 2
irb(main):003:0> puts "x and y are equal" if x == y
=> nil

This time, things went as expected and the test string was not displayed because the values of x and y were different.

In addition to creating text strings by embedding them inside matching quotation marks, you can also create text strings by embedding text inside the %q{ and } characters or the %Q { and } characters. Embedding characters inside the %q{ and } characters creates a string that is equivalent to a single-quoted string. Embedding characters inside the %Q{ and } characters creates a string that is equivalent to a double-quoted string.

The advantage of using the %q{ and } and %Q{ and } characters in place of quotation marks is that these characters allow you to create strings that span multiple lines, as demonstrated here:

story = %Q{Once upon a time there were
three children named Alexander, William,
and Molly.}

Using the %q{ and } and %Q{ and } characters to define strings, there is no practical limit as to the length of your text strings. In addition, strings created using the %Q{ and } characters provide the same support for escape characters and interpolation as do double-quoted strings.

Trick

When creating multiline text strings, you can replace the opening and closing brackets with any matching set of characters you want. For example, the following example uses the %q[ and ] characters to define a string.

story = %q[Once upon a time there were
three children named Alexander, William,
and Molly.]

The important thing to remember when deciding which characters you want to substitute when creating a string is to make sure that those characters do not also appear inside the string text; otherwise, Ruby will get confused and things will not work correctly.

Ruby scripts use this object-orientedness to define real-world concepts like files, folders, and network resources, or perhaps things like people, automobiles, and animals. Once they’re defined, you can interact with and control objects and define relationships between objects.

Objects are defined as classes using the syntax outlined here:

class ClassName
  statements
end

class is a keyword that tells Ruby that a new class is being defined. ClassName is the name that is being assigned to the new class. You must assign a capital letter as the first character of every class definition. statements is a placeholder for one or more script statements that define class attributes (properties) and methods. end is a keyword that identifies the end of the class definition. For example, the following statements begin the outline of a class named Automobile.

class Automobile

end

A Class definition represents a template that can be used to create or instantiate individual objects. In the case of the preceding example, the class represents the logical definition of an automobile. The end keyword marks the end of the class definition.

Within the class definition, you can define one or more attributes that describe characteristics associated with the class. For example, you might want to define class attributes such as model and color to the Automobile class. Class attributes, also referred to as properties, are defined inside the class using the attr_accessor keyword using the syntax outlined here:

attr_accessor : attribute1, :attribute2, ...

attr_accessor is a keyword that identifies a list of one or more object properties. Each property is preceded by the colon character. Successive properties are separated from each other with a comma. There is no limit to the number or properties that you can define. The following example demonstrates how to assign two properties to the Automobile class.

class Automobile
 attr_accessor :model, :color
end

The first property specifies the model or type of automobile being defined and the second property will be used to store the color of the automobile.

At this point, the Automobile class represents a functional class definition that is ready to be used as the basis for instantiating scripts objects, which is accomplished using the syntax outlined here:

variableName = ClassName.new

variableName is the name of a variable that will be used to store and refer to the object, and ClassName is the name of the class being used to create the new object. new is a method that initiates the creation of the new object. Using the above syntax, you can create a new object as shown here:

superCar = Automobile.new

When executed, this statement creates a new object named superCar using the Automobile class as its template. Once instantiated, you can assign values to the object’s properties, as demonstrated here.

superCar.model = "Edsel"
superCar.color = "Red"

Once defined, you can reference object property values as shown here.

puts "Super car is the car of tomorrow. It is based on the " +
"original #{superCar.model} design."

When executed, this statement displays the text string shown here:

Super car is the car of tomorrow. It is based on the original Edsel design.

If you want, you can modify the value assigned to a property by reassigning another value as demonstrated here.

superCar.model = "Mustang"

In order to control your objects, you need to define class methods. You can then use the methods to programmatically interact with any object you instantiate. Ruby methods are defined using the following syntax.

def methodname(arguments)
   Statements
end

methodname is the name to be assigned to the new method. arguments is a comma-separated list of parameters passed to the method for processing. Within the method, the parameters are treated as local variables. Statements is a placeholder representing one or more statements that will be executed whenever the method is called. To get a better feel for how to define a custom method, take a look at the following example.

class Automobile

 attr_accessor :model, :color

  def honk
     puts "Honk!!!"
  end
end

As with properties, you can interact with object methods by specifying the name of the class, followed by a period and then the name of the method.

The following statements demonstrate how to create a new object based on the Automobile class and how to execute the class’s honk method.

myCar = Automobile.new
myCar.honk

One of the primary benefits of object-oriented programming is its ability to allow programmers to model the creation of classes (and therefore objects) based on real-life concepts like automobiles, tools, people, or anything else you can imagine. In real life, objects often have relationships with one another. For example, you have a father from whom you inherited certain qualities. You may have children to whom you will pass on certain attributes. In addition, you may have brothers or sisters with whom you share common attributes.

By supporting an object-oriented process known as inheritance, Ruby allows you to use one class definition as the basis for creating another class definition. In this case, the new or child class is created as a copy of the original or parent class. You can create as many child instances as you want. If necessary, you can modify the characteristics of the child class to suit your particular needs.

Thanks to inheritance, you can define classes that model real-life concepts. For example, you might define a generic automobile class that defines all of the basic properties associated with a car and which includes all of the methods required to control the car. And then you can use this class as a template for creating a whole series of child subclasses, each of which might represent an individual make and model of a car. For example, the class definition for a simple car is outlined here:

class Automobile

 attr_accessor :model, :color

  def honk
     puts "Honk!!!"
  end
end

Here, an Automobile class has been defined that contains two property definitions, model and color, and a method named honk. If you want, you can use the Automobile class as the basis for defining a new class. Once way of doing this would be to copy and paste the Automobile class and then to rename it as shown here:

class Edsel

 attr_accessor :model, :color

  def honk
     puts "Honk!!!"
  end
end

Creating a new class in this manner is highly inefficient because it results in two nearly identical sets of code that must be maintained. Should you later want to make a change in the class by adding another property, you have to make the modification twice, once for the Automobile class and again for the Edsel class. Instead of doing things this way, a much better way of creating another, related class of cars would be to base the new Edsel class on the Automobile class, taking advantage of object inheritance as demonstrated here:

class Edsel < Automobile

end

Here the superclass operator was used to create a new class named Edsel, which is modeled on the Automobile class. The Edsel class inherits all of the properties and methods in the Automobile class. Not only does this require less code, but this approach also reduces the chance of making typing errors since there is less to type in. In addition, if you should later decide to make a fundamental change that would affect all the car-related classes, all you have to do is make that change in the Automobile class and any child classes (or subclasses) will automatically inherit the change as well. There is no limit to the number of child classes that you can create from a parent class. Therefore, if you need to expand your product line to include a second type of car, you could easily do so as demonstrated here:

class Mustang < Automobile

end

Here, a new Mustang class has been created. It automatically inherits all the properties and methods of the Automobile class. Ruby allows you to modify child classes as necessary to customize them to match up to whatever changes need to be made to differentiate the child class from it parent class. For example, take a look at the following statements.

class Explorer < Automobile

 attr_accessor :transmission

 def breaks
    puts "... screech!"
  end

end

Here, a new Explorer class has been defined based on the Automobile class. In addition to inheriting all of the Automobile's properties and methods, the Explorer class has been modified to include a new property and a new method that is unique unto itself.

Hint

This book has shown you how to use a number of different methods. In most cases, you’ve been told which class the method is associated with. However, for methods like puts, chop!, and print, you’ve simply been shown how to use them without any explanation of where they come from. These methods are just a few of the methods stored in the Kernel module. A module is a container used to group classes, methods, and constants. This module is a component of the Object class. Methods belonging to the Object class are made available to every Ruby object.

Normally when you work with a method, you do so by specifying the name of the class where the method resides followed by a period and then the method name, as demonstrated here:

pause = STDIN.gets

When working with methods belonging to the Kernel module, you can simply specify the method’s name, as demonstrated here:

puts "Well, hello there."

Alternatively, if you want to be specific, you could rewrite the preceding statement as shown here:

Kernel.puts "Well, hello there."

As you can see, x is assigned to the Fixnum class. However, if you reassign a value too large to fit into that class, Ruby will automatically, or implicitly, convert x to Bignum, as demonstrated here:

irb(main):007:0> x = 1000000000000000
=> 1000000000000000
irb(main):008:0> x.class
=> Bignum

If you then assign a string as the value of x, Ruby will again change the object’s class, as demonstrated here:

irb(main):009:0> x = "Hello"
=> "Hello"
irb(main):010:0> x.class
=> String

In addition to implicitly changing or coercing an object from one class to another, Ruby also provides you with the ability to explicitly coerce objects from one class to another. You might need to do this if you have written a script that collects and processes user input. By default, any input provided by the user will be treated by Ruby as a string, even if the input that was provided was a number. For example, consider the following example.

irb(main):001:0> answer = STDIN.gets
10
=> "10
"

Hint

The previous example collects user input by executing the STDIN class’s gets method. This method pauses the console session and waits for the user to provide input, which is then assigned the specified variable.

As you can see, the value entered by the user was the number 10. Ruby appended the characters to the end of the user’s input when the Enter key was pressed. Executing the following command, remove the trailing /n characters, ensuring that the value assigned to answer is exactly what the user entered.

irb(main):002:0> answer.chop!
=> "10"

Trick

When the user presses the Enter key to submit her input, Ruby automatically appends an end of line marker to the end of the input. In this example, the presence of the end of line marker has no impact on the example.

The end of line marker can easily be removed from the answer variable using the chop! method. When executed, this method removes the last character from a specified string. If the string ends with the characters, the chop! method will remove both characters.

Using this method, you can easily remove the /n characters from any input provided by the user, as demonstrated here:

answer = STDIN.gets
answer.chop

If you now try to perform addition using the input, you will run into an error because Ruby is unable to explicitly convert a value of “10” to 10.

irb(main):003:0> x = 5 + answer
TypeError: String can't be coerced into Fixnum
        from (irb):3:in '+'
        from (irb):3
irb(main):004:0>

To prevent this type of error from occurring and to get the results you expect, you can explicitly force the conversion of an object’s type using different conversion methods. For example, you could use the to_i method to return the value stored in answer to an integer.

irb(main):005:0> x = 5 + answer.to_i
=> 15
irb(main):006:0>

As you can see, once explicitly converted, the error no longer occurs and the expected result is attached. If you prefer, you can use the tp_f method to convert a string to a floating point number. Going in the opposite direction, you can use the to_s method to convert any numeric value to a string, as demonstrated here:

irb(main):001:0> x = 5
=> 5
irb(main):002:0> y = 4
=> 4
irb(main):003:0> z = x + y
=> 9

In this example, two variables are defined and assigned values of 5 and 4, which are then added together and assigned to a variable named z. Using the to_s method, you can instruct Ruby to treat the values assigned to x and y as strings instead of numeric values, as demonstrated here:

irb(main):004:0> z = x.to_s + y.to_s
=> "54"
irb(main):005:0>

This time, instead of adding two numeric values together, Ruby coerces x and y into strings and concatenates both strings together to form a new string that is then assigned to a variable named z. If you use the class method to check on the z variable’s class type assignment, you will see that it has been set to String.

irb(main):006:0> z.class
=> String
irb(main):007:0>

In Ruby, variable names are case sensitive. This means that to Ruby, totalcount and TotalCount are two separate variables. Ruby has a few rules that you need to be familiar with regarding the naming of variables. These rules are listed here:

Following these rules, each of the following variable names would be regarded by Ruby as valid.

The variable names shown in Table 3.3, on the other hand, are not considered by Ruby to be valid.

As you have already seen many times, variable value assignments in Ruby are made using the equals assignment operator (=), as demonstrated here:

x = 10

Here an integer value of 10 has been assigned to a variable named x. Use the equals assignment operator to also modify a variable’s value by assigning it the results of an expression, as demonstrated here:

x = 1
x = x + 1

Here, a variable named x is assigned an initial value of 1. Then the value assigned to x is modified by assigning the values returned from the expression x + 1 to x. As a result the value of x was incremented by 1.

Incrementing a variable’s value is a common task. To help make it easier to perform, you can use the += operator, as demonstrated here:

x += 1

The += operator provides a shorthand way of incrementing a variable’s value of a specified amount. In the case of the previous example, the value of x is incremented by 1.

In Ruby, variable access depends on the scope that has been set for that variable. Scope is a term that describes the areas within a script where a variable can be seen and accessed. Ruby supports three different scopes, as outlined in Table 3.4.

In Ruby, variable scope is indicated by the characters you use at the beginning of the variable name. As Table 3.4 shows, a variable whose name begins with the $ character is a global variable, and a variable that begins with a lowercase letter or the underscore character is a local variable. For this book, you will only need to worry about working with local and global variables.

Local variables are variables that have a limited scope. For example, as Table 3.4 shows, any variable whose name begins with a lowercase letter and that is defined inside a method is accessible only within that method. For example, the following statements show a method named Add_Stuff. This method accepts two arguments, x and y, which are local variables within the method and thus not accessible outside of the method.

def Add_Stuff(x, y)
   puts x + y
end

If you key this example into the irb and then execute it by passing the method arguments of 3 and 4, a result of 7 will be displayed.

irb(main):004:0> Add_Stuff(3, 4)
7

However, if you attempt to access either the x or the y variable from outside of the method, as demonstrated next, an error will occur.

irb(main):005:0> puts x
NameError: undefined local variable or method 'x' for main:Object
        from (irb):5

Global variables can be accessed from anywhere within a Ruby script and are created by making the first character of the variable name a $, as demonstrated here:

$x = 1000

The $x variable will be accessible from anywhere within the Ruby script that it is defined in. You will see an example of how to use global variables later in this chapter’s game project, the Ruby Virtual Crazy 8 Ball game.

The development of the Ruby Virtual Crazy 8 Ball game will be completed in 10 steps, as outlined here:

Remember to follow along carefully and not to skip any steps or parts of steps as you work your way through this exercise. Specifically, look out for typos and make sure that you do things in the correct order.

Step 2: Documenting the Script and Its Purpose

Once you have created your new script file, the next step is to add the following comment statements to it. These statements provide a high-level description of the game and its purpose.

#--------------------------------------------------------------------------
#
# Script Name: Crazy8Ball.rb
# Version:     1.0
# Author:      Jerry Lee Ford, Jr.
# Date:        October 2007
#
# Description: This Ruby script demonstrates how to work with variables
#              and to generate random numbers in order to create a fortune
#              telling game that provides randomly selected answers to
#              player questions.
#
#--------------------------------------------------------------------------

Hint

To get as much value as possible out of the script’s opening documentation statements, modify them to suit your own needs. For example, you might want to consider including a place for your URL if you have a website. In addition, you might want to add a space for recording changes, game instructions, or anything else that you think would be useful.

# Define custom classes ---------------------------------------------------

#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

Step 4: Defining a Ball Class

The script’s second class is named Ball. It serves as a template that the script will use to instantiate an object that represents a virtual 8 ball. As such, the class defines a number of properties and methods required to operate and interact with the 8 ball.

#Define a class representing the 8 ball
class Ball

  #Define class properties for the 8 ball
 attr_accessor :randomNo, :greeting, :question, :goodbye

 #Define a method to be used to generate random answers
 def get_fortune
    randomNo = 1 + rand(6)

    #Assign an answer based on the randomly generated number
    case randomNo
        when 1
         $prediction = "yes"
        when 2
         $prediction = "no"
        when 3
         $prediction = "maybe"
        when 4
         $prediction = "hard to tell. Try again"
        when 5
         $prediction = "unlikely"
        when 6
         $prediction = "unknown"
      end

    end

   #This method displays the 8 ball greeting message
   def say_greeting
      greeting = "		 Welcome to the Virtual Crazy 8 Ball game!" +
      "












Press Enter to " +
                "continue. 

: "
     print greeting
    end

   #This method displays the 8 ball's primary query
   def get_question
      question = "Type your question and press the Enter key. 

: "
     print question
    end

   #This method displays the 8 ball answers
   def tell_fortune(randomAnswer)
     print "The answer is " + randomAnswer + ". 

: "
    end

   #This method displays the 8 ball's closing message
   def say_goodbye
     goodbye = "Thanks for playing the Virtual Crazy 8 Ball game!

"
    puts goodbye
  end

end

The class definition begins by specifying four class properties. The randomNo property will be used to store a random number between 1 and 6. The greeting property will be used to store a text string containing the game’s welcome message. The question property will be used to store a text string that will be used to notify the player when it is time to ask a question. The goodbye property will be used to store a text string that holds the game’s closing message.

In addition to the four class properties, the class also defines five methods. The first method is named get_fortune and is responsible for randomly selecting one of six possible answers to the player’s questions. It accomplishes this task using the rand method, which retrieves a random number in the form of an integer.

Hint

The rand method returns a random number between 1 and the specified upper limit. Therefore rand(6) returns a number that is greater than 0 and less than 6. Adding 1 to this number results in a range of number from 1 to 6.

The randomly generated number, stored in randomNo, is used in a case code block that assigns a text string representing one of six 8 ball answers to the $prediction global variable.

Hint

A case code block is a structure for implementing conditional logic. It compares a single value, in this case randomNo, to a series of possible matching values, as specified by one or more when statements. You will learn more about how to work with the case code block in Chapter 4, “Implementing Conditional Logic.”

The next method defined is the say_greeting method, which assigns a text string to the class’s greeting property and then uses the print method to display that string. The get_question method comes next. It assigns a text string to the class’s question property and then uses the print method to display that string. The tell_fortune method is then defined. It accepts a single argument, which is assigned to a local variable named randomAnswer. This variable is then used to formulate a text statement that is displayed using the print method. The last method that is defined is the say_goodbye method, which assigns a text string to the class’s goodbye property and then uses the print method to display that string.

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

Console_Screen = Screen.new  #Initialize a new Screen object
Eight_Ball = Ball.new  #Initialize a new Ball object

Console_Screen.cls  #Clear the display area

Eight_Ball.say_greeting  #Call method responsible for greeting the player

Console_Screen.pause  #Pause the game

Step 7: Prompting for Confirmation to Continue

Once the player dismisses the 8 ball’s greeting message, the game sets up a loop that requires the player to provide confirmation of her intention to play. This will provide the player the chance to cancel game play in the event the game was started by accident. The script statements responsible for performing this task are shown next and should be added to the end of the script file.

answer = ""  #Initialize variable that is used to control the game's first
             #loop

#Loop until the player enters y or n and do not accept any other input.
until answer == "y" || answer == "n"

  Console_Screen.cls  #Clear the display area

 #Prompt the player for permission to begin the game
  print "Would you like to have your fortune predicted? (y/n)

: "

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

end

The first statement initializes a variable that will be used to control the execution of the loop that follows, in which a series of script statements have been embedded. The loop has been set up to execute until the player enters a value of y or n when prompted for confirmation. By using a loop to control the execution of the embedded statements, you are able to validate the player’s input. If the player responds by keying in anything other than a y or n, the loop will execute again, re-prompting the player to provide valid input.

Hint

A loop is a structure that permits a set of statements to be executed repeatedly a preset number of times or until a specified condition occurs. You will learn all about Ruby’s support for loops in Chapter 5, “Working with Loops.”

Step 8: Analyzing the Player’s Response

The next step in the development of the game is to further analyze the input that the player has provided. This is accomplished by adding the following conditional logic statements to the end of the script file.

#Analyze the player's response
if answer == "n"  #See if the player elected not to play

else  #The player has elected to play the game

end

Hint

The rest of the statements in the script will either be embedded within these statements or placed immediately after them. These statements control the high-level conditional logic for the script. The statements that you embed between the first two statements will execute when the player responds with a reply of n when asked for permission to play the game. The statements that you embed between the last two statements will execute when the player responds with a reply of y.

Console_Screen.cls  #Clear the display area

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

"

#Initialize variable that is used to control the game's primary loop
gameOver = "No"

#Loop until the player decides to quit
until gameOver == "Yes"

  Console_Screen.cls  #Clear the display area

  #Call upon the method responsible for prompting the player to ask a
  #question
  Eight_Ball.get_question

 #Call upon the method responsible for generating an answer
  Eight_Ball.get_fortune

  Console_Screen.pause  #Pause the game

  Console_Screen.cls  #Clear the display area

  #Call upon the method responsible for telling the player the 8 ball's
  #answer
  Eight_Ball.tell_fortune $prediction

  Console_Screen.pause  #Pause the game

  Console_Screen.cls  #Clear the display area
 #Find out if the player wants to ask another question
 print "Press Enter to ask another question or type q to quit. 

: "

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

  #Analyze the player's response
  if answer == "q"  #See if the player elected not to play
    gameOver = "Yes"  #The player wants to quit
  end

end

Console_Screen.cls  #Clear the display area

#call upon the method responsible for saying goodbye to the player
Eight_Ball.say_goodbye

Okay, that’s it. Go ahead and save your Ruby script. Assuming that you have followed along carefully and that you did not make any typing mistakes when keying in the code statements that make up the script file, everything should work as expected. If you run into any errors, read the resulting error messages carefully to ascertain what went wrong. If necessary, go back and review the script and look for mistyped or missing scripts statements.

Hint

If you really run into trouble when creating your version of the Ruby Virtual Crazy 8 Ball game, you can go to this book’s companion website at www.courseptr.com/ downloads and download the source code for this game and then compare it to your script file to see where things went wrong.