A constant is a descriptive name assigned to a known value that does not change throughout the execution of a program. Programmers use constants in situations where the data used by an application is known in advance and not subject to change. For example, a mathematical application might store the value of pi (3.14) in a constant at the beginning of the program and then reference it in various locations throughout the rest of the application. Since pi is a numeric constant and is not subject to change, it is a good candidate for assignment to a constant.

By assigning a value to a constant, as opposed to a variable, you eliminate the possibility of accidentally modifying it when the application is run. In addition, constants generally require less memory than variables, making programs slightly more efficient in terms of resources consumed. Simpler BASIC dialects, including Just BASIC, do not support the use of constants. However, most robust BASIC dialects, including Visual Basic and REALbasic, do.

Hint

To define a constant in programming languages such as Visual Basic, C++, and REALbasic, you use the const keyword.

const defaultScore As Integer = 100

Here, a constant named defaultScore has been defined as an integer and assigned a value of 100. Because you can assign a descriptive name to a constant, they help make program code easier to understand. For example, the above statement might be used to set the default score assigned to players at the beginning of a computer game. By using this descriptive name you help to reference your document whenever this value is used. This is a lot more meaningful than simply embedding the number 100 repeatedly in different code statements. In addition, code maintenance is simplified through the use of constants. In this scenario, all a programmer would have to do to change the default score is modify this value one time in the const declaration statement.

Many programming languages, such as Visual Basic, also provide programmers with access to a collection of pre-defined constants. For example, instead of controlling the display of text using carriage returns by inserting Chr$(13) into strings as is done in Just BASIC, Visual Basic lets programmers reference built-in constants like Control Chars.Cr (carriage return) and ControlChars.CrLf (carriage return and line feed).

Any time you have a piece of data to keep track of and modify, such as the value of a player’s score during gameplay, you need to store it in a variable. A variable is a pointer to a location in memory (address) where a value is stored. In most programming languages, including Just BASIC, a value (string or numeric) is assigned to a variable using the equals operator (=), as demonstrated here:

initialScore = 0
confirmMsg$ = "Are you sure you want to quit?"

The first statement shown creates a variable named initialScore and assigns it a numeric value of zero. The second statement creates a string variable named confirmMsg$ and assigns a text string of "Are you sure you want to quit?" to it. In addition to allowing you to create your own variables, many programming languages provide programmers with access to special variables. A special variable is a variable that is predefined by the programming language and can be referenced at any time during program execution. Table 4.1 provides a listing of Just BASIC special variables.

You may remember from Chapter 3, “Creating Graphical User Interfaces,” that special variables like BackgroundColor$, ListboxColor$, ComboboxColor$, TextboxColor$, TexteditorColor$, and ForegroundColor$ let you specify the colors used when rendering windows and controls and that DisplayHeight, DisplayWidth, WindowHeight, and WindowWidth can all be used to affect the size of application windows.

Variables are generally all that you need in order to effectively define and manipulate a few pieces of data at a time. However, some applications involve the manipulation and storage of a large amount of related information. For these applications, arrays are typically used to handle data storage. An array is an index list of data stored and managed as a unit. Data stored in an array is accessed by specifying the name of the array and the index position of the data to be stored or retrieved.

Suppose you want to create an online contact list for all your friends and associates. One way of doing this is to save a list of contacts and their phone numbers in a text file and then write a program that opens that file and reads this list into an array. Once loaded into an array, you could use data stored in the array to populate a combobox or listbox control.

Just BASIC provides support for single-dimension and double-dimension arrays. A single-dimension array is a list of data such as user names. A two-dimensional array is like a table or an Excel spreadsheet with rows and columns. Other programming languages like Visual Basic, REALbasic, and C++ support arrays with even more dimensions.

While Just BASIC support for data manipulation is limited to variables and one- or two-dimensional arrays, other programming languages provide additional ways of storing and retrieving data. For example, Perl allows programmers to define hashes, sometimes referred to as associated arrays, in which data is stored in key-value pairs, where each data element stored in a hash is assigned a unique key. Data can then be retrieved from the hash by referencing its associated key. REALbasic provides a similar storage mechanism, which is a dictionary to store key-value pairs.

Other programming languages like Visual Basic and C++ support the use of structures, which allow programmers to define a collection of related variables stored within an array. This allows loosely related data such as customer names, phone numbers, and addresses to be stored together and referenced individually or as a group. Object-oriented programming languages, like REALbasic, C++, and Visual Basic, also allow programmers to store data using custom classes, which can be used as a template to create objects where data can be stored.

In short, different programming languages support different data storage and retrieval options over and above variables and arrays. Still, variables and arrays are by far the most commonly used means of storing and manipulating data. As such, Just BASIC provides an excellent platform from which to experience and learn to work with both.

A local variable can only be accessed within the scope in which it has been created. For example, a variable used inside a subroutine can only be accessed from within that subroutine. By default, variables used outside of functions and subroutines in Just BASIC programs are not visible inside functions and subroutines. Likewise, a variable used inside a function or subroutine is not accessible outside of that function or subroutine. The following example demonstrates how to create a local variable within a subroutine.

sub TestSub
  msg$ = "Hi!"
  notice msg$
end sub

A local variable only exists within the scope in which it is created. If two subroutines were added to the same program and both contain a reference to variables named msg$, Just BASIC would treat each instance of that variable in both subroutines as being entirely different variables. If you wanted both subroutines to be able to access the same variable, then you would want to declare that variable as being global, as explained in the next section.

Variables declared as global can be accessed from anywhere within a Just BASIC program.

Hint

Special variables, such as BackgroundColor$, ForegroundColor$, DisplayHeight, DisplayWidth, WindowHeight, and WindowWidth, are always global, accessible from anywhere in your Just BASIC programs.

To declare a variable as global you use the global command, which has the following syntax.

global variable1, variable2,... variableN

As you can see, you can declare any number of variables as being global by specifying a comma-separated list of variable names. For example, the following statements declare a variable named totalScore as being global and then assign a value to that variable.

global totalScore
totalScore = 0

Trick

In general, it is a good idea to limit the scope of your variables whenever possible. This conserves memory and eliminates the possibility of accidentally changing a variable’s value from a different location within your application (which can happen when using global variables).

Using the val() function, you can convert a string that begins with a number or that represents a number into its numeric equivalent. If the string being analyzed cannot be evaluated to a number, a value of 0 is returned. The val() function has the following syntax.

val(expression)

expression can be a literal string or a variable. To get a better understanding of how the val() function works, take a look at the following example.

apples$ = "25"
oranges = 5

apples = val(apples$)
fruit = apples + oranges

print "You have "; fruit; " pieces of fruit."

Here, a string variable named apples$ has been assigned a string value of 25 and a numeric variable named oranges has been assigned a value of 5. Next, the val() function is used to convert the string value assigned to apples$ to its numeric equivalent. The numeric values of apples and oranges are then added together and the results are assigned to a variable named fruit, which is then displayed.

Using the str$() function, you can convert a numeric value into its string equivalent. The str$() function has the following syntax.

str$(expression)

To get a better understanding of how the str$() function works, take a look at the following example:

oranges = 20
oranges$ = str$(oranges)
print "You have " + oranges$ + " oranges" 'error

Here, a numeric variable named oranges is assigned a value of 20. Next, the str$() function is used to convert the numeric value assigned to oranges to a string value of "20", which is then assigned to oranges$. This value is then displayed as part of a concatenated string in the last statement.

Hint

Concatenation is the process of joining two or more strings together to create a new string. Different programming languages use different concatenation characters. For example, in Visual Basic, the & character is used to concatenate strings together.

Trick

Strings are created by enclosing text within a pair of matching double-quotation marks. If you need to include a double-quotation mark within a string, you might be tempted to try something like the following:

print "Tom told Bob to "run" but he wouldn't."

However, Just BASIC will flag this statement as a syntax error. The work-around for this situation in Just BASIC is to use the chr$() function, as demonstrated here:

print "Tom told Bob to " + chr$(34) + "run" + chr$(34) + " but he
wouldn't."

As you can see, chr$(34) evaluates to a value of a double quote, thus allowing you to insert double quotation marks within your text strings.

Other programming languages provide different ways of inserting special characters into text strings. For example, when displaying a text string in a Perl script, you can precede any character that you want to be interpreted literally with the character.

As with all the previous Just BASIC applications that you have worked on in this book, let’s begin by adding a few comment statements to the beginning of the program file in order to document the overall purpose of the application and provide a little information about its author.

' *************************************************************************
'
' Script Name: AskMustafa.bas (The Ask Mustafa Game)
' Version:     1.0
' Author:      Jerry Lee Ford, Jr.
' Date:        March 1, 2007
'
' Description: In this Just BASIC game the player is challenged to
'              interrogate Doctor Evil's evil assistant Mustafa in order to
'              determine the location of the doctor.
'
' *************************************************************************

Since this application does not use a text window, let’s also add the following statement to the end of the program file to instruct Just BASIC not to generate the default mainwin window.

nomainwin 'Suppress the display of the default text window

The Ask Mustafa game will begin by displaying a welcome screen that introduces the game and provides the player with a little background information. Add the following code statements to the end of the program file to generate this window and manage its interaction with the player.

Hint

Even though you may be tempted not to key in the comment statements that are provided as part of the code statements shown below, go ahead and do so. These statements provide detailed step-by-step documentation of every code statement and make the program code easier to read and understand.

'Define two global variables to keep track of player guesses
global previousSelection$, consecutiveGuesses

WindowWidth = 600 'Set the width of the application windows to 600 pixels
WindowHeight = 480 'Set the height of the application windows to 480 pixels

BackgroundColor$ = "white" 'Set the window's background color to white
ForegroundColor$ = "black" 'Set the window's background color to black

'Use variables to store text strings displayed in the window

IntroMsg1$ = "A S K   M U S T A F A"
IntroMsg2$ = "Copyright 2007"
IntroMsg3$ = "Welcome to the Ask Mustafa game. In this game, you play " _
  + "the role of a secret agent who has captured Mustafa, an evil doer " _
  + "employed by Doctor Evil for the purpose of taking over and ruling " _
  + "the world. Your task is to interrogate Mustafa and get him to tell " _
  + "you where Doctor Evil is hiding."

'Define the format of statictext controls displayed on the window
statictext #main.statictext1, IntroMsg1$, 135, 50, 330, 32
statictext #main.statictext2, IntroMsg2$, 380, 90, 300, 14
statictext #main.statictext3, IntroMsg3$, 100, 180, 400, 100

'Define the format of button controls displayed on the window
button #main.button " Play ", PrepareGame, UL, 220, 360
button #main.button " Quit ", CloseMain, UL, 305, 360


'Open the window with no frame and a handle of #main
open "Ask Mustafa" for window_nf as #main

'Set the font type, size, and properties for each of the static controls
print #main.statictext1, "!font Arial 24 bold"
print #main.statictext2, "!font Arial 8"
print #main.statictext3, "!font Arial 12"

'Pause the application to wait for the player's instruction
wait

The first code statement shown above declares two global variables, previousSelection$ and consecutiveGuesses. These variables will be used to keep track of the player’s last guess (so that it can be compared against her current guess) and to keep count of the number of times in a row that the most recently asked question has been asked.

The next four statements set the width and height of the application window as well as its foreground and background colors. The next three statements assign text strings to three string variables. The value of these variables is then displayed in three static text controls that follow. Next, two button controls are defined, one labeled Play and the other labeled Quit. A subroutine named PrepareGame is called whenever the player clicks on the button labeled Play and a subroutine named CloseMain is called when the player clicks on the Quit button.

The open command is then used to open a window with a handle of #main. Next, three print statements are executed, specifying different font type, size, and property characteristics for each of the window’s statictext controls. Finally, the wait command is executed, pausing the game in order to wait for the player’s input.

The code statements that make up the PrepareGame subroutine are shown next and should be added to the end of the program file. This subroutine is called and executed whenever the player clicks on the button labeled Play located on the #main window.

'This subroutine is called when the Play button is clicked and is
'responsible for starting gameplay
sub PrepareGame handle$
  close #main    'Close the #main window
  call PlayGame  'Switch to the [PlayGame] static handle

end sub

As you can see, this subroutine begins with the keyword sub followed by the name assigned to the subroutine (PrepareGame) and then a parameter named handle$. This parameter represents the name of the control that has called the subroutine.

The subroutine itself consists of two statements. The first statement closes the #main window and the second statement uses the call command to execute a subroutine named PlayGame. The PlayGame subroutine is responsible for collecting player guesses and determining Mustafa’s responses.

The code statements that make up the CloseMain subroutine are shown next and should be added to the end of the program file. This subroutine is called whenever the player clicks on the Quit button located on the #main window. It consists of a single statement, which uses the close command to close the #main window.

'When called, this subroutine closes the application's #main window
sub CloseMain handle$

  close #main

end sub

The PlayGame subroutine, shown next, is responsible for displaying the #play window, which is where the game is actually played. It lists questions from which the player can select and displays answers provided on behalf of Mustafa.

'This subroutine accepts player guesses and displays Mustafa's answers
sub PlayGame

  WindowWidth = 600 'Set the width of the window to 600 pixels
  WindowHeight = 480 'Set the height of the window to 480 pixels

  BackgroundColor$ = "White" 'Set the window's background color to white
  ForegroundColor$ = "Black" 'Set the window's foreground color to black
  'The following array contains a list of questions that the player can ask
  'Mustafa to answer
  questions$(0) = "Where is Dr. Evil?"
  questions$(1) = "Can you give me directions to Dr. Evil's lair?"
  questions$(2) = "So, have you seen Mini-Me lately?"
  questions$(3) = "I want to build an evil headquarters. Where's a " _
    + "good spot?"
  questions$(4) = "I found Dr. Evil's wallet. What address should I " _
    + "mail it to?"
  questions$(5) = "Dr. Evil ordered a pizza. Where should I deliver it?"

  loadbmp "copyimage", "C:imageshat.bmp" 'Load the specified bitmap
                                           'file into memory

  'Add a graphicbox control to the #play window
  graphicbox #play.gbox, 340, 20, 216, 216

  'Use variables to store text strings displayed in the window
  Instructions1$ = chr$(34) + "It does not matter what you ask me! I " _
    + "will tell you nothing, you impudent son of a goat!" + chr$(13) _
    + chr$(13) + "I can withstand hours of interrogation without" _
    + " breaking a sweat." + chr$(13) +  chr$(13) + "Go ahead, ask me" _
    + " your questions, you won't get any information from me." + chr$(34)
  Instructions2$ = "Select a question:"
  Instructions3$ = "Mustafa's Answer:"

  'Define the format of statictext controls displayed on the window
  statictext #play.statictext4 Instructions1$, 20, 40, 280, 170
  statictext #play.statictext5 Instructions2$, 20, 260, 280, 14
  statictext #play.statictext6 Instructions3$, 330, 260, 280, 14

  'Add a listbox control to the #play windows and load the contents of
  'the questions$() array into it
  listbox #play.listbox, questions$(), doubleClick, 20, 280, 300, 80

  'Define the format of button controls displayed on the window
  button #play.button1 "  Hint  ", GetHint, UL, 220, 380
  button #play.button2 "  Quit  ", ClosePlay, UL, 305, 380
  'Add a texteditor control to the #play window (used to display Mustafa's
  'answers)
  texteditor #play.texteditor, 330, 280, 240, 80

  'Open the window with no frame and a handle of #play
  open "Ask Mustafa" for window_nf as #play

  'Set the font type and size for the specified statictext control
  print #play.statictext4, "!font Arial 12"

  'Use the flush command to prevent the contents of the graphicbox control
  'from being overwritten when the window is first generated
  print #play.gbox, "flush"

  'Display the pre-loaded bitmap image in the graphicbox control
  print #play.gbox, "drawbmp copyimage 1 1"

  'Use the flush command to prevent the contents of the graphicbox control
  'from being overwritten if the user opens or moves another window on top
  'of the #play window
  print #play.gbox, "flush"

  'Pause the application to wait for the player's instruction
  wait

end sub

The first four statements set the window’s width, height, background, and foreground colors. An array named questions$() is then created and populated with six items. Each item represents a question that the player can select. The loadbmp command is then used to load a bitmap image into memory. This image will be used at the end of the subroutine to display a picture of Mustafa’s trademark Turkish hat (a fey) on the application window. Next, a series of three string variables are created and then used by three statictext controls to display text.

Hint

You will find a copy of the hat.bmp image file along with the source code for the Ask Mustafa game on this book’s companion website (www.courseptr.com/downloads).

Next, a listbox control is added to the #play window. The elements stored in the questions$() array are loaded into this control. To select one of the questions listed in the control (in order to ask Mustafa a question), the player must double-click on it. When this occurs, the doubleClick subroutine is called. Next, two button controls and a texteditor control are added to the window, which is then opened. A series of print statements follow that set font size and type and display the bitmap image previously loaded into computer memory. To display the bitmap image, the drawbmp command is used. In addition, the flush command is also used. This command prevents the bitmap image from disappearing in the event that the player opens or moves another window on top of the bitmap image.

Hint

loadbmp, drawbmp, and flush are all examples of graphic commands. You will learn more about how to work with graphics in Chapter 9, “Working with Sound and Graphics.”

The doubleClick subroutine, shown next, is responsible for keeping track of each question asked by the player and for generating answers on behalf of Mustafa.

'This subroutine processes player questions and generates Mustafa's
'answers
sub doubleClick handle$

  'Retrieve the question selected by the player
  #play.listbox "selection? choice$"

  'check to see if this is the first time in a row that this question has
  'been asked
  if previousSelection$ <> choice$ then

    print #play.texteditor, "!cls"  'Clear the texteditor control

    'Display the specified answer
    print #play.texteditor, "Stop asking questions. I don't know anything!"

    consecutiveGuesses = 1  'Reset the variable used to keep track of
                            'consecutively asked questions to 1

  else  'The question has been asked at least twice in a row
    print #play.texteditor, "!cls"  'Clear the texteditor control
    'Display the specified answer

    print #play.texteditor, "Your questions are making my head hurt. " _
      + chr$(13) + "I beg you to stop!"
    consecutiveGuesses = consecutiveGuesses + 1  'Increment the variable
                                                 'used to keep track of
                                                 'consecutively asked
                                                 'questions by 1

    if consecutiveGuesses = 3 then  'The player has asked the same question
                                    '3 times in a row

      print #play.texteditor, "!cls"  'Clear the texteditor control

      'Display the specified answer
      print #play.texteditor, "All right, I can't take it anymore! Dr. " _
      + "Evil " + chr$(13) + "is on Evil Island, 50 miles east of the New " _
      + "Jersey" + chr$(13) + "coast. Please leave me alone with my shame."

    end if

  end if

  previousSelection$ = choice$  'Save the player's choice so that it can
                                'be compared against when the player
                                'makes a new guess

  wait

end sub

The first statement in this subroutine determines which listbox entry the player selected and assigns its value to a variable named choice$. Next, an if...else...end if code block executes. It is responsible for analyzing the value of previousSelection$ and choice$ to see if they are different. If their values are not equal, then this is the first time that the player has asked this question. If these two variables’ values are equal, the question has been asked at least twice in a row. If this is the case, the value of consecutiveGuesses is checked to see if it is equal to 3, in which case it is time for Mustafa to break down and give away Doctor Evil’s location. If this is only the second time in a row that the same question has been asked, Mustafa instead responds by telling the player that his head is beginning to hurt (indicating that the player’s line of questioning is starting to have an effect). Mustafa’s answers are displayed inside the texteditor control using play statements.

Hint

You will learn all about if...else...end if code blocks in Chapter 5, “Making Decisions with Conditional Logic.”

If, after playing for a while, the player cannot figure out how to get Mustafa to yield Doctor Evil’s location, she can get a hint by clicking on the button labeled Hint (located on the #play window). When this happens, the code statements located inside the GetHint subroutine are executed. The code statements for this subroutine are shown here and should be added to the end of the program file.

'This subroutine is called when the player clicks on the Hint button
sub GetHint handle$

  'Get confirmation before displaying a hint
  confirm "Hints are for wimps! Are you sure you want one?"; answer$

  if answer$ = "yes" then  'The player clicked on Yes

    'Display the hint
     notice "Ask Mustafa" + chr$(13) + "Mustafa hates repetition. Ask " _
       + "him the same question over again and he'll start giving you " _
       + "the information you want."

  end if

end sub

Before displaying the hint, the subroutine executes the confirm command, displaying a popup dialog window that requires that the player re-confirm the decision to see the hint message. If the player clicks on the button labeled Yes, the notice command is used to display the hint in a popup dialog window. Otherwise, the hint is not shown and gameplay resumes.

The last subroutine in the program file is the ClosePlay subroutine. It is called when the player clicks on the button labeled Quit (located on the #play window).

'This subroutine is called when the Quit button is clicked and is
'responsible for closing the #play window and ending the game
sub ClosePlay handle$

  close #play
  end

end sub

This subroutine consists of two statements. The first statement closes the #play window and the second statement executes the end command, terminating the application’s execution.