In this chapter, you will learn how to create a new computer game called the Ruby Typing Challenge game. This Ruby script will demonstrate how to apply conditional logic to analyze user input through the development of a computer typing test that evaluates the player’s typing skills.

The Ruby Typing Challenge game begins displaying a welcome screen as shown in Figure 4.1.

Figure 4.1. The welcome screen for the Ruby Typing Challenge game.

Next, the game prompts the player for permission to begin the test as demonstrated in Figure 4.2. The player is instructed to respond with a y/n answer.

Figure 4.2. Player confirmation is required to begin taking the test.

If the player decides not to take the typing test, the screen shown in Figure 4.3 displays and the game will end once the player presses the Enter key.

Figure 4.3. The player has elected not to take the test.

If, on the other hand, the player elects to take the typing test, the instructions shown in Figure 4.4 display.

Figure 4.4. Instructions provide the player with information needed to understand how to take the test.

Next, the first of a series of five sentences is presented as demonstrated in Figure 4.5. In response, the player must type the sentence exactly as shown and then press the Enter key.

Figure 4.5. An example of one of the Ruby Typing Test game’s typing challenges.

As soon as the player presses the Enter key, the game analyzes the player’s input to determine whether it exactly matches the game’s sentence. If the player’s input is identical to the game’s sentence, the screen shown in Figure 4.6 displays. If the player makes one or more typing mistakes, a different message displays notifying the player that she has failed to correctly type the sentence.

Figure 4.6. The player has correctly typed the challenge sentence.

The game’s sentences grow longer as the test progresses. Once the player has typed in all five sentences, the game analyzes the player’s score and displays a message indicating whether or not the player has passed the test as demonstrated in Figure 4.7.

Figure 4.7. To pass the test the player must correctly type at least three sentences.

Once the player presses the Enter key, the screen showing the score is dismissed. Finally, a message displays thanking the player for taking the time to take the typing test as shown in Figure 4.8.

Figure 4.8. The game ends after thanking the player for taking the time to play.

Using Ruby, you can create scripts that consist of a series of statements that are executed in sequential order, one after the other, without any alteration in the logical flow of the scripts. However, while this approach may work well with small scripts that perform simple tasks, scripts that process sequentially are not well suited to tasks that involve any level of complexity. For example, as you have already seen in all the game scripts that you have worked on in this book, some level of conditional execution is almost always required. This execution might involve prompting the player for permission to play a game and then either ending or continuing the game based on an analysis of the player’s response.

People use conditional logic all the time. Therefore, from a programming standpoint, it is a relatively easy concept to understand. For example, every morning people around the globe awake and must make a decision as to whether or not to go to work. Based on that decision, different courses of action must be taken. For example, take a look at Figure 4.9, which visually outlines the conditional logic involved in selecting from two alternatives.

Figure 4.9. Choosing between different courses of action.

This same basic logic can easily be applied to the development of a computer program or script. For example, take a look at Figure 4.10.

Figure 4.10. A graphical representation of the conditional logic used to determine whether or not to start game play.

Hint

Figures 4.9 and 4.10 are both examples of simple flowcharts. A flowchart is a tool used to graphically represent some or all of a script’s logical flow. Flowcharts are often created by programmers to outline the overall design of the logic involved in designing a computer program or script prior to beginning work on it. By first creating a flowchart, programmers provide themselves with a high-level outline of the overall logic involved. This gives programmers the ability to focus on the overall process required to create the program and helps to identify logical errors in the program’s design before investing time in program development and testing.

Flowcharts are often used in large projects involving the combined efforts of many programmers. Once created, flowcharts can be used to identify different parts of a program or project, making the division of work easier while also helping to ensure that each programmer has a good understanding of how the part of the program or project he is assigned fits into the overall scheme of things.

As you can see, Figure 4.10 outlines two separate and distinct courses of action, of which only one will be followed, based on the user’s response as to whether or not to begin game play. The logic outlined in the flowchart can be directly translated into script statements, as demonstrated here:

puts "Would you like to play a game? (y/n) "
answer = STDIN.gets
answer.chop!

if answer == "n"
  puts "Sorry to hear that. Please return and play again soon."
else
  puts "OK, let's play!"
  .
  .
  .
end

Here, the puts method is executed and passed a text string that is used to display a message that prompts the player to respond with a value of y or n to indicate whether to continue game play. The player indicates her decision by keying in the appropriate response and pressing the Enter key.

The key point to understand regarding the application of conditional programming logic is that when it comes right down to it, all that is happening is an evaluation of whether a tested condition is true or false. Based on the result of the analysis, the appropriate set of program statements is then executed.

Ruby provides programmers with access to several ways of applying conditional logic, each of which is designed to address a specific type of situation. A list of available options for applying conditional logic is outlined here.

Up to this point in the book, all the comparison operations that have been demonstrated have used the == comparison operator. Like other modern programming languages, Ruby provides programmers with access to a range of comparison operators. For example, instead of setting up a comparison test that evaluates whether one value is equal to another, you might want to know whether one value is greater than or less than another value. This type of analysis uses comparison operators. Table 4.1 provides a list of the comparison operators supported by Ruby.

The rest of this chapter will provide you with examples of how to work with the comparison operators shown in Table 4.1.

One quick and easy way that Ruby allows you to integrate conditional logic into your Ruby scripts is through the use of conditional logic modifiers. Using Ruby’s modifiers, you can append a conditional check onto the end of other Ruby statements to control the conditional execution of the statement.

print "Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!

puts "You must be 18 or older to play this game!" if answer.to_i < 18

print "Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!

puts "You must be 18 or older to play this game!" unless answer.to_i > 17

Using if and unless expressions, you can spread out conditional statements over multiple lines, making these forms of conditional tests even more powerful than their modifier equivalents. As such, you can use conditional expressions to group together and control the execution of large numbers of statements, making your scripts easier to read and maintain.

if condition then
  statements
elsif condition then
  statements
.
.
.
else
  statements
end if

Replacing if Modifiers with if Expressions

To better understand how to work with this powerful and extremely useful expression, you need to see examples of it in action. Earlier in this chapter, the following example was presented to demonstrate the use of the if modifier.

print "Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!

puts "You must be 18 or older to play this game!" if answer.to_i < 18

Using the if expression, this example could be rewritten as shown here.

print "Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!

if answer.to_i < 18 then
  puts "You must be 18 or older to play this game!"
end

As you can see, this version of the example is more longwinded than the if modifier example. However, as demonstrated in the next code block, you can use the if expression to include any number of statements inside the opening if and closing end statements, allowing the conditional execution of any number of statements.

if answer.to_i < 18
  puts "You must be 18 or older to play this game!"
  puts "Goodbye."
  exit
end

Hint

Note the use of the exit method in the previous example. The exit method is provided by the kernel class. This method forces the immediate termination of a Ruby script.

Creating Single-Line if Expressions

As has been stated, the syntax support of the if expression is very flexible, allowing for many formats. For example, the following example demonstrates how to format an if expression that fits on a single line.

x = 10
if x == 10 then puts "x is equal to 10" end

When used in this format, the if expression is very similar to the if modifier, except that in the case of the if modifier, the conditional logic that is executed is appended to the end of the statement instead of being defined at the beginning of the statement as demonstrated here.

x = 10
puts "x is equal to 10" if x == 10

Providing an Alternative Course of Action

In addition to executing one or more script statements when a test condition evaluates as being true, you can modify an if expression to execute one or more statements in the event the test condition evaluates as being false. To accomplish this, you need to add the optional else keyword to the expression as demonstrated here.

x = 10
if x == 10 then
  puts " x is equal to 10"
else
  puts " x does not equal 10"
end

Here, either of two puts statements executes depending on whether or not the value assigned to x is equal to 10.

Checking for Alternative Conditions

There will be times when you will need to examine a series of conditions to find out which one of them evaluates as being true. One way of accomplishing this is to define a series of statements as demonstrated here.

if x == 10 then puts "x is 10"  end
if x == 15 then puts "x is 15"  end
if x == 20 then puts "x is 20"  end
if x == 25 then puts "x is 25"  end

The objective of these statements is to find out which of four possible values has been assigned to x. If you prefer, you could use the if expression’s optional elsif keyword to rewrite this example as shown here.

if x == 10 then puts "x is 10"
elsif x == 15 then puts "x is 15"
elsif x == 20 then puts "x is 20"
elsif x == 25 then puts "x is 25"
end

Hint

If you need to execute more than one statement when a matching condition is found, you would need to reformat the previous example as shown here.

if x == 10 then
  puts "x is 10"
elsif x == 15 then
  puts "x is 15"
elsif x == 20 then
  puts "x is 20"
elsif x == 25 then
  puts "x is 25"
end

You could also include the optional else keyword to provide an alternative course of action should none of the preceding tests evaluate as being true.

if x == 10 then puts "x is 10"
elsif x == 15 then puts "x is 15"
elsif x == 20 then puts "x is 20"
elsif x == 25 then puts "x is 25"
else puts "The value of x is unknown"
end

Trick

If you want to save a few keystrokes when keying in your script statements, Ruby allows you to replace the then keyword with the : character as demonstrated here.

if x == 10 : puts "x is 10"
elsif x == 15 : puts "x is 15"
elsif x == 20 : puts "x is 20"
elsif x == 25 : puts "x is 25"
end

print "Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!

if answer.to_i < 18
  puts "You must be 18 or older to play this game!"
end

print "Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!

unless answer.to_i > 17
  puts "You must be 18 or older to play this game!"
end

In addition to the if and unless modifiers and expressions, Ruby also provides you with access to the case block as a means of comparing a series of expressions against a single expression to see whether any of the expressions being evaluated result in equivalent value. Although you can accomplish the same thing using an if expression that includes a series of elsif statements, the case block is better suited for situations where you need to compare a single condition to a whole range of possible matches. The syntax for the case block is outlined here:

case expression
  when value
    statements
       .
       .
       .
  when value
    statements
  else
    statements
end

As you can see, the case block includes one or more when statements. The expression that is evaluated is compared to the value associated with one or more when statements. If a match occurs with one of the with statements, any statements associated with that when statement are executed. If none of the when statements matches the value of the expression being evaluated, the statements belonging to the optional else statement (if present) are executed.

Trick

As is the case with the if expression, you can replace the then keyword with a colon (:).

As a quick example of how to set up a case block, take a look at the following statements.

x = 10

case x

  when 1
    puts "*"
  when 5
    puts "*****"
  when 10
    puts "**********"
  else
    puts "No stars"

end

Here, the value assigned to x is compared to a series of values specified in a case block. Since the value of x is 10, the puts "**********" will be executed. Had none of the when statements contained a matching value, the puts statement associated with the else keyword would have executed. In most cases, you will find that it takes fewer lines of code to set up a case block than an equivalent if expression using multiple elsif keywords.

If you want, you can omit the specification of an expression on the open case statement when setting up a case block as demonstrated here.

puts "
Welcome to the vacation calculator!

"

print "How many years have you worked for the company? 

: "
answer = STDIN.gets
answer.chop!
answer = answer.to_i

case
  when (answer.between?(1, 5))
    puts "You are entitled to 1 week of vacation per year."
  when (answer.between?(6, 10))
    puts "You are entitled to 2 weeks of vacation per year."
  when (answer.between?(11, 15))
    puts "You are entitled to 3 weeks of vacation per year."
  when (answer.between?(16, 20))
    puts "You are entitled to 4 weeks of vacation per year."
  else
    puts "You are entitled to 5 weeks of vacation per year."
End

Here, a series of unique expressions has been specified for each when statement. The statements belonging to the first expression that evaluates as true will be executed and the rest of the statements are skipped.

Trick

Note the use of the between? method in each of the expressions in the previous example. Each of Ruby’s numeric classes supports this method, which returns a value of true or false depending on whether or not a number is within a specified range.

Ruby provides you with an additional option, known as the ternary operator (?:), available for setting up conditional logic. Using the ternary operator, you can evaluate the value of two different expressions and make variable assignments as a result of that comparison. The syntax required to work with the ternary operator is

variable = expression ? true_result : false_result

Here, variable is assigned the value returned by the statement. expression represents the expression that is evaluated. true_result is the value that is assigned if the expression evaluates as true and false_result is the value returned if the expression evaluates as being false. To get a better understanding of how to work with the ternary operator, take a look at the following example.

print "

Enter your age and press Enter:  "
answer = STDIN.gets
answer.chop!
answer = answer.to_i

result = answer < 18 ? "denied!" : "approved!"

puts "

Your access has been " + result + "

"

Here, the user is prompted to enter her age. The statement that contains the ternary operator evaluates the expression answer < 18. If the user enters a value of 17 or less, the expression evaluates as true, and a value of "denied!" is assigned to a variable named result. On the other hand, if the user enters a value that is 18 or higher, the expression evaluates as being false and a value of "approved!" is assigned to result.

Some situations require more complicated analysis than can be accomplished using an individual conditional modifier expression. In these situations, you may need to perform one conditional evaluation based on the result of another evaluation. One way of addressing this type of challenge is to embed one conditional statement inside another through a process called nesting. To get a better understanding of how nesting works, take a look at the following example.

redStatus = "Go"
blueStatus = "Go"
greenStatus = "Go"

if redStatus == "Go" then
  if blueStatus == "Go" then
    if greenStatus == "Go" then
      puts "All systems are go. Prepare for launch!"
    end
  end
end

Here, a series of three if expressions has been set up. If the first expression evaluates as false, the remaining if expressions are skipped. Otherwise, the second if expression is executed. If the second if expression proves false, the third if expression is skipped. Otherwise, it is executed. Nesting also works just as effectively for unless expressions.

Trap

Although there is no limitation on how deeply you can nest conditional statements within one another, going more than two or three deep will result in script code that is difficult to read and maintain.

Like most modern programming languages, Ruby also supports the use of a number of logical, or Boolean, operators. These operators are listed in Table 4.2.

As you can see, the and and && operators are essentially identical. The only difference between the two is that the and operator has a higher level of precedence than the && operator. Likewise, the or and || operators work identically, the only difference being precedence, with or having higher precedence than ||. The and and && operators evaluate the second operand only if the first operand is true. The or and || operators evaluate the second operand only if the first operand is false.

To get a better understanding of how to work with these operators, let’s look at a few examples. For starters, take a look at the following statements.

print "Enter your age and press Enter:  "
reply = STDIN.gets
reply.chop!
reply = reply.to_i

puts "You are eligible to play this game!" if reply >= 18 && reply <= 65

Here, the if modifier at the end of the last statement uses the && operator to determine whether the value assigned to reply is both greater than or equal to 18 and less than or equal to 65. If both expressions evaluate as true, the puts statement executes. Otherwise, the puts statement is skipped.

Hint

If you want, you can enclose expressions within parentheses to make things easier to understand as demonstrated here:

puts "You are eligible to play this game" if (reply >= 18) && (reply <= 65)

Next, let’s look at an example that uses the || operators.

print "What is your rank?: "
rank = STDIN.gets
rank.chop!
rank = rank.to_i

puts "Access is permitted." if rank == 1 || rank == 3

Here, the last statement shown above uses the || operator to determine if the value assigned to rank is equal to 1 or to 3. If either (or both) or these expressions proves true, the associated puts statement executes. If neither expression proves true, the puts statement is skipped.

This final example demonstrates how to work with the ! operator, which negates or reverses the value returned from a conditional expression.

randomNo = 1 + rand(10)

print "What number am I thinking of? 

:  "
answer = STDIN.gets
answer.chop!

puts "Wrong! My number was " + randomNo.to_s if ! (answer.to_i == randomNo)

Here, a random number between 1 and 10 is generated using the rand method and assigned to a variable named randomNo. The user is then prompted to try and guess the randomly generated number. The player’s answer is then converted to an integer and compared to the value or randomNo. If these two values are not equal, the associated puts statement executes. Otherwise, it does not execute.

Okay, now it is time to turn your attention back to the development of this chapter’s game project, the Ruby Typing Challenge game. As you work on creating this script, focus on the conditional expression to control the script’s overall controlling logic and its use in evaluating the accuracy of the player’s typing.

#--------------------------------------------------------------------------
#
# Script Name: TypingChallenge.rb
# Version:     1.0
# Author:      Jerry Lee Ford, Jr.
# Date:        October 2007
#
# Description: This Ruby script demonstrates how to apply conditional logic
#              in order to analyze user input and control script execution
#              through the development of a computer typing test that
#              evaluates the player's typing skills.
#
#--------------------------------------------------------------------------

# 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

#Define a class representing the typing test
class Test

end

#This method displays the 8-ball greeting message
def display_greeting

  Console_Screen.cls  #Clear the display area

  #Display a welcome screen
  print "		 Welcome to the Ruby Typing Challenge game!" +
  "












Press Enter to " +
             "continue. 

: "

Console_Screen.pause       #Pause the game

end

#Define a method to be used to present test instructions
def display_instructions

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

"  #Display a heading

  #Display the game's instructions
  puts %Q{    This test consists of a series of 5 typing challenges.
  Each challenge sentence is presented one at a time. To respond
  correctly, you must retype each sentence exactly as shown and press
  the Enter key. Your grade will be displayed at the end of the test.
  









  Press Enter to continue.

}

  Console_Screen.pause       #Pause the game

End

#Define a method to be used to present typing challenges
def present_test(challenge)

  Console_Screen.cls       #Clear the display area
  print challenge + "

: "  #Display the challenge sentence
  result = STDIN.gets  #Collect the player's input
  result.chop!         #Remove the end of line marker

  #Analyze the player input and see if it is correct
  if challenge == result then

    #Keep track of the number of correctly retyped challenge sentences
    $noRight += 1
    Console_Screen.cls       #Clear the display area
    #Keep the player informed
    print "Correct!

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

  else

    Console_Screen.cls       #Clear the display area
    #Keep the player informed
    print "Incorrect!

Press Enter to continue."
    Console_Screen.pause       #Clear the game

  end

end

#Define a method to be used to display test results
def determine_grade

  Console_Screen.cls       #Clear the display area

  #To pass the test the player must correctly retype 3 sentences
  if $noRight >= 3 then

    #Inform the player of the good news
    print "You retyped " + $noRight.to_s + " sentence(s) correctly. "
    puts "You have passed the typing test!

Press Enter to continue."

  else  #The player has failed the test

    #Inform the player of the bad news
    print "You retyped " + $noRight.to_s + " sentence(s) correctly. "
    puts "You have failed the typing test!

Press Enter to continue."

  end

end

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

# Initialize global variable that will be used to keep track of the number
#of correctly retyped sentences
$noRight = 0

Console_Screen = Screen.new  #Instantiate a new Screen object
Typing_Test = Test.new        #Instantiate a new Test object

#Execute the Test object's display_greeting method
Typing_Test.display_greeting

#Execute the Screen object's cls method in order to clear the screen
 Console_Screen.cls

#Prompt the player for permission to begin the test
print "Would you like to test your typing skills? (y/n)

: "

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

#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 test
  print "Would you like to test your typing skills? (y/n)

: "

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

end

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

else  #The player wants to take the test

end

Console_Screen.cls  #Clear the display area

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

"

#Execute the Test object's display_instructions method
Typing_Test.display_instructions

#Display typing challenges and grade each answer by calling on the
#Test object's present_test method
Typing_Test.present_test "In the end there can be only one."
Typing_Test.present_test "Once a great plague swept across the land."
Typing_Test.present_test "Welcome to Ruby Programming for the Absolute" +
" Beginner."
Typing_Test.present_test "There are very few problems in the world " +
"that enough M&Ms cannot fix."
Typing_Test.present_test "Perhaps today is a good day to die. Fight " +
"beside me and let us die together."

#Notify the player of the results by executing the Test object's
# determine_grade method
Typing_Test.determine_grade

Console_Screen.pause       #Pause the game

Console_Screen.cls  #Clear the display area
#Thank the player for taking the typing test
puts "Thank you for taking the Ruby Typing Challenge.

"

In this chapter you learned different ways of implementing conditional logic in your Ruby scripts. This included learning how to work with if and unless modifiers and expressions. This chapter showed you how to use the ternary operator to perform conditional analysis. You also learned how to use the case statement to match one value up against a range of possible options and to use different types of logical operations to perform different types of comparisons. Last, you learned how to combine and negate logical comparison operations using Ruby Boolean operators.

Now, before you move on to Chapter 5, “Working with Loops,” I suggest you set aside a little extra time to make a few improvements to the Ruby Typing Challenge game by implementing the following list of challenges.