TI Codes: TI-84 Plus Technology

Write a Simple Guessing Game

The guessing game includes several components:

1. Variable N and randInt() used to pick the number to guess.

2. A Repeat loop that repeatedly asks for a guess until the player guesses correctly.

3. The Prompt command used to get a guess from the player.

4. If conditionals and Disp used to tell the player if their guess is too high or too low.

5. Variable M and Disp used to track and report how many guesses the player made.

Try putting the simple guessing game together. You’ll create a new program called GUESS, then type the code into your calculator. Remember that you can find almost all of the programming commands that you’ll need in the program commands menu, under the [PRGM]key. The sole exception is randInt(, which is in the Prob tab of the Math (MATH) menu.

How the Guessing Game Works

The diagram below is a flowchart of how the program works. If you haven’t seen a flowchart before, you read it by following the arrows around the diagram, beginning at START and ending at Stop. If you spend a minute comparing this diagram to the code for [PRGM]GUESS, you’ll see that each block corresponds to 1-3 lines of the program

Line-by-line, here’s how it works:

:randInt(1,50)➔N

Pick a random number between 1 and 50, and store that to variable N. Each time the program gets a new guess from the player, it will compare it to N to check if it’s correct.

:0➔M

Store the number of guesses made so far to variable M. Each time the player makes another guess, the program will add 1 to M, then display M at the very end of the program.

:Repeat G=N

Repeat the code between this Repeat command and the corresponding End command until G=N. In this program, G is the guess from the user, and N is the target number, so the loop ends when the guess is equal to the number the player is trying to guess. One special quirk of Repeat: it only checks the condition (G=N) after it has completed an entire run through the loop. Therefore, we don’t have to initialize G by storing a value like 0 to it before the loop starts. If we were using a While loop, we would have to initialize G, because While checks the condition before it starts running the loop.

:Prompt G

Ask the player for a value for G, then store the number the player types into variable G

:If G>N

:Disp "TOO HIGH"

If the guess G is larger than the target number N, display TOO HIGH so the player knows to guess lower. The If command will run the next line of the program if the condition (G>N) is true; otherwise, it will skip it.

:If<><>

:Disp "TOO LOW"

Similarly, if the guess G is smaller than the target number N, display TOO LOW. If G=N, the loop won’t have finished yet, but neither Disp command will run, because G is not greater than N, and G is also not less than N.

:M+1➔M

Add 1 to the number of guesses made.

:End

End the loop and check the Repeat condition. If the condition G=N is false, run the loop again, starting at Repeat. If it’s true, continue with the following code after the End.

:Disp "CORRECT AFTER:"

:Disp M

:Disp "GUESSES"

Display three lines, including the number of guesses made. You could optimize this into a single Disp line with commas

Going Further: Expand Your Game

• Let the player choose the smallest and/or largest possible number to guess. The game in this lesson picked a number between 1 and 50.
• Display the range in which the player should be guessing, here 1 to 50.
• Keep track of the high score (the lowest number of guesses made). You could keep track of other statistics as well, like the average number of guesses or the worst score (the highest number of guesses). To store information in more permanent locations than the numeric variables A-Z, take a look at the information on custom lists.
• Use Input instead of Prompt to ask for a guess.
• Find a way to [CLEAR] the screen before the game begins.

You can, of course, also use your imagination to think of other features you want to add to the game. Good luck!

Moving a Letter around the Homescreen

The program that we’ll be creating in this lesson is quite short, but brings together a number of important programming concepts. We’ll be building a program around an event loop: a section of code executed over and over again that waits for and reacts to events. In this program, the events we’ll be looking for will be keypresses, and our program will respond to these events by moving a letter around the calculator’s homescreen. Event loops in computer programs might wait for a time or date, a mouse click, a key on the keyboard, or even arriving packets from the network.

Event Loops and getKey

The following diagram shows the basic structure of an event loop-based program. It executes code to set up the loop, like initializing variables, then it continually repeats the event loop until some escape condition occurs.

There are three major components of an event loop:

• An escape condition that defines when the event loop stops repeating. In a computer program, an escape condition might be something like exiting from the program or pressing [ESC]. In our program, we’ll check for the [CLEAR] key, and our escape condition could be expressed as “end the event loop if [CLEAR] is pressed”.
• Non-event code. In this program, we won’t have any non-event code. However, in other programs, this is code that runs regardless of whether events occur or not.

Check for (and react to) events. In this program, our events are keys being pressed. If we want to check for and react to keypresses, though, we’ll need to be able to execute or skip sections of code based on whether a key is pressed.

To construct our event loop, we’ll need conditional statements and getKey.

getKey is a TI-Basic command that your programs can use to detect if a key has been pressed. If the user pressed a key since the last time getKey was called, getKey will return a number between 11 and 105, indicating which key was pressed (see the diagram below). If no key was pressed, it returns 0. Unlike Input and Output, the getKey command doesn’t pause your program, so you can create more complex programs and games.

Conditional statements allow you to control whether sections of code are executed. Conditional statements consist of a condition that can be true or false, and code that is executed if the condition is true. Conditions might look like If A>1 or If K=24 or If K=25 and B>1 on your calculator. Happily, these do exactly what they look like: the first one is true if the variable A>1, the second is true if K=25, and the third is true if both K=25 and B>1 are true. The simplest form of conditional on your calculator consists of the condition on one line, followed directly by a second line of code that is run if the condition was true or skipped if the condition was false. You can also create more complex conditionals using If/Then/End and If/Then/Else/End.

Moving a Letter around the Homescreen

Let’s explore the MOVECHAR program. The MOVECHAR program is one of the simplest possible examples of an event loop-based program, repeatedly listening for keypress events and acting on them. The flowchart represents the MOVECHAR program. The event loop itself loops from “Redraw M” to “Check for keypresses” and then back around to “Redraw M”. The escape condition that we discussed earlier was the condition to leave the event loop; here, you can see that the only way to leave the loop is to press [CLEAR].

Note that if you’re using the TI-83 Plus or TI-84 Plus, the only differences are in the values used for the edges of the homescreen and the starting point, due to differences in the sizes of each calculator’s homescreen.

Line-by-line, here’s how the code works:

:13➔A

:5➔B

Initialize the x- and y-coordinates of the letter that will be drawn. We don’t use the X and Y variables, because the calculator’s operating system sometimes modifies the Y variable if you use graphscreen commands. In this program, A is the x-coordinate, and B is the y-coordinate. Column 13, row 5 is roughly the center of the color calculator’s homescreen.

:ClrHome

[CLEAR] the homescreen.

:Repeat K=45

Repeat all of the code between Repeat and End (the event loop) until the variable K equals 45 (the keycode for [CLEAR]).

:Output(B,A,"M”)

Draw the letter M at row B, column A on the homescreen. If there was already an M on the screen at the same coordinates, it simply draws over it, so the screen doesn’t change.

:getKey➔K

Get the keycode for any key pressed since the last time getKey was called, and store it in the variable K. This returns immediately, instead of waiting for a key to be pressed: if no key was pressed, it stores 0 to K

: If K≠0

If a key was pressed, we want to erase the letter already on the screen, because we might be moving it. If we didn’t erase it, we’d leave a trail of Ms around the homescreen.

:Output(B,A,"_”

Draw a space over the M that was on the homescreen, effectively erasing it. This line of code is only executed if K is not zero.

:If K=24 and A>1

:A-1➔A

Handle the left arrow key, ◀, keycode 24. If the left arrow key was pressed, we want to subtract 1 from the x-coordinate so that the M will move one space to the left. However, we don’t want to move the M off the edge of the screen. Therefore, we only subtract 1 from A and store it back to A if both K=24 (the left key was pressed) and A>1 (the M was not at the left edge of the screen already).

:If K=26 and A<>

:A+1➔A

:If K=25 and B>1

:B-1➔B

:If K=34 and B<>

:B+1➔B

Handle the right, up, and down arrows. Each conditional statement checks that both an arrow key has been pressed, and that the letter isn’t already at the corresponding edge of the screen.

:End

Loop back up to the Repeat command, unless K=45. If K is 45, the loop will end, and because this is the last line of the program, the program will end as well.

Going Further: Expand MOVECHAR

With this simple event loop program that listens for and reacts to keys, you can build many fun programs and especially games.

• An easy place to start would be to make something other than an M move around the screen. Perhaps a different letter? Or a group of letters in a shape?
• Handle diagonal movement so that the letter can move in 8 directions instead of just 4. Because getKey can’t register multiple arrow keys held together, you could use the 1–9 keys as arrows instead (where 2 is down, 7 is up-left, and so on).
• If you’re familiar with drawing text on the graphscreen, try moving this program to the graphscreen. Which commands do you need to change, and which stay the same? What are the new bounds you need to use to keep the text from going off the screen?
• Try turning the MOVECHAR program into a space shooter game: the M can become your spaceship, and you might be trying to shoot asteroids before they reach you. How can you implement a weapon, and keep track of where the asteroids are and the score?

You can, of course, also use your imagination to think of features you want to add. Good luck!

You can learn more about programming for the TI-84 Plus family of graphing calculators in “Programming the TI-83 Plus/TI-84 Plus,” by Christopher Mitchell, Ph.D.

Writing a “Snake” Game

Create the Snake program on your calculator as prgmSNAKE. If you have a color-screen calculator like the TI-84 Plus CE or TI-84 Plus C Silver Edition, you can enter it exactly as shown. For the the TI-84 Plus and TI-84 Plus Silver Edition, calculators, you need to account for the fact that the homescreen is smaller

Line-by-line, here’s how the code works:

:ClrHome

Clear the homescreen.

13➔A

:5➔B

:10➔X

:1➔P

:34➔D

Initialize all the variables to be used:

• A is the x-coordinate of the snake’s head, and B is the y coordinate of its head. Row 5, column 13 is roughly the center of the TI-84 Plus CE’s homescreen.
• X is the length of the snake, here, 10 segments. If you wanted to make this a real snake game, you’d have to start with a small X, and increase it as the snake ate food.
• P is a pointer to the element holding the snake’s tail. L1(P) is the y coordinate of the snake’s tail, and L2(P) is the x-coordinate of the snake’s tail. As the snake moves, P moves as well, so that it always points to the end of the snake (without having to move the data in L1 and L2 forward).
• D is the direction in which the snake is heading. To reuse code you’ve seen before, we use the keycodes for up, down, left, and right (25, 34, 24, and 26, respectively) to represent the direction the snake is going.

:X➔dim(L1)

:X➔dim(L2)

Create two lists, each X elements long, for our circular buffers of snake segment coordinates.

:Fill(B,L1)

:Fill(A,L2)

Fill the two lists with the starting coordinates. This way, all 10 segments of the snake will start out on a single spot on the homescreen, and as the game starts, the snake will appear to grow out of that spot to its full length. Making the snake start already drawn at its full length would be more complicated.

:Repeat K=45

As in Lesson 2, repeat the main event loop until [CLEAR] is pressed.

:Output(L1(P),L2(P)," ”)

Erase the tail of the snake. Because we’re using circular buffers, we change P to always point to the elements of L1 and L2 holding the snake’s current tail. L1(P) is the y-coordinate (the row) of the tail’s last segment, and L2(P) is the -coordinate (the column) of the last segment.

:Output(B,A,"0")

Draw the new head. A and B always hold the coordinates of the snake’s head, and "O" just happens to look good as a snake segment. You could use any character you want instead.

:B➔L1(P)

:A➔L2(P)

Store the current head coordinates into the circular buffers. Because P+1 will point to the tail on the next iteration, P will point to the head, so we store these over the old tail coordinates at P.

:P+1-X(P=X)➔P

Update P to point to the next element of the lists. If P is less than X, then P=X is false (0), and this simplifies to P+1➔P. If P is already pointing to the last element of the circular buffers, which means P=X, then P=X is true (1), and this simplifies to P+1-X➔P, or X+1-X➔P, or 1➔P. Thus, when P reaches the end of the lists, it will wrap around to the beginning again.

:getKey➔K
:If max(K={24,25,26,34})
:K➔D

Handle keypresses. As always, we store the keypress in K, so that the Repeat K=45 condition can tell if [CLEAR] has been pressed. The conditional statement is a shorthand for If K=24 or K=25 or K=26 or K=34. K={24,25,26,34 produces a 4-element list, holding the elements {K=24,K=25,K=26,K=34}: that is, a series of 1s and 0s. The max() command returns the largest value in a list, so if K is equal to any of those four numbers, there will be a 1 in the resulting list, and the maximum will be 1. If K is not equal to any of those four keycodes, the list will be filled with 0s, and the maximum of the list will be 0. Therefore, the conditional will only be true if K is equal to one of those four keycodes. Moreover, if K holds an arrow key’s keycode, update D to contain a new direction for the snake to go.

:A+(D=26)-(D=24)➔A
:B+(D=34)-(D=25)➔B

Use the direction variable D to update the coordinates of the head. If D=26 or D=24, then the snake’s head is moving horizontally. Update A (the -coordinate) accordingly. Try plugging D=26 and D=24 into the first line to see how this works. The second line updates B, the -coordinate of the head, if D=34 or D=25, which means the head is moving up or down.

:A+26((A=0)-(A=27))➔A
:B+10((B=0)-(B=11))➔B

The preceding two lines could make the head of the snake go off the edges of the screen. If we try to draw a character off the edge of the screen, the program will end with an ERR:DOMAIN, so we need to fix it. These two lines wrap the head around the edges of the screen. For example, if it reaches the top of the screen, it will reappear at the bottom instead.

:End

Loop back up to the Repeat command, unless K=45. If K is 45, the loop will end, and because this is the last line of the program, the program will end as well.

Going Further: Build a Complete “Snake” Game

The SNAKE game as presented contains everything you need to start building a “Snake” game. The three biggest missing pieces are: (1) a growing snake, (2) scoring, and (3) food to eat. Here’s what you could do to make a complete “Snake” game out of this basic version:

• First, you’ll need a second variable to handle a head pointer. In this version, we used P as both the head and tail pointer, because the circular buffer was always completely full.
• Next, you’ll need to have circular buffers which are bigger than the starting size of the snake, because the snake will need to be able to grow. This will lead you to some interesting design decisions: should you start with lists as large as the snake could possibly grow? Or should you expand the lists when the snake is in danger of outgrowing the buffers?
• Next, you’ll need some food for the snake to eat. How will you make sure that you don’t put the food on top of the snake? Some approaches store the contents of the homescreen in a matrix, so you can easily test which spots on the homescreen are occupied.

• You’ll need to detect if the snake is about to (or has just) eaten the food, so that you can increment the score and the snake’s length, and place a new piece of food.
• You can go even further and add things like walls and differently-shaped levels. If you do this, you might want to strongly consider the matrix approach to easily detect when the snake has hit a wall (or its own tail).

You can, of course, also use your imagination to think of features you want to add. Good luck!

 

 

You can learn more about programming for the TI-84 Plus family of graphing calculators in “Programming the TI-83 Plus/TI-84 Plus,” by Christopher Mitchell, Ph.D.

After completing a series of mini projects, you’ll have a maze game similar to the one on the right. 

Along the way you will learn how to:

1. Detect which keys are pressed.

2. Use key presses to move a word stored in a string value.

3. Draw objects using pixels.

4. Move objects using key presses and variables.

5. Create a specific maze.

6. Randomize maze attributes.

7. Create the final maze project (with option to add sound using the TI-Innovator™ Hub).

 

The getKey command returns the value of the key that is pressed.

To find the getKey command, press [prgrm] then select the I/O menu for input/output.

 

The line getKey→K stores the value of the key into a variable named K.

 

Write the following lines of code:

:ClrHome

:getKey→K
:Disp K

If you execute the program now, it will execute and display a 0 automatically. The program doesn’t wait for you to press a key. If it doesn’t detect a key push it displays 0.

Insert the two lines between ClrHome and the getKey line
([alpha] [graph]) will give you an option to insert a blank line).

:0 →K

  :While K ≠45

At the end of your code add

:End

The WHILE loop will continue to execute the code to get and
display the values of keys pressed until the clear key is pressed.

Run your program.

What type of values are displayed when you press a key? 

What type of values are displayed when you don’t press a key?

Insert the following IF statement before the display line.

:If K ≠ 0
:Then
:Disp K
:End

Before running your modified program, predict how the new
lines of code will change the program.

Use your program to explore the keypad.

 

What are the values of the arrow keys?

What is the value of the enter key?

What value is the clear key?

Use the blank template of the keypad (provided in the 'Download- Teacher/Student Docs folder' and can be printed ) to write down the numeric value of each key. Do you notice the pattern?

In this mini project, you will learn how to store your name as a string.  You will use the getKey command from the first project to move your name on the screen.  This project will teach you how to move objects similarly to how you will move your shape for the maze project.

Your screen is divided into multiple rows that go down the screen and multiple columns that go across the screen.

Type the code below, insert your name.

Note: Str1 can be found under Vars →String.

:3 →R
:1 →C
:“NAME” →Str1
:Output(R,C,Str1)

Execute your code. 

What row and column contains your first initial?

You’ll now modify your code to get a key press value. You’ll use this value to change either the row or column variable which will change where your name is displayed.

• Use the variable K to store the value from the key press
• Use a WHILE loop to continually get key press values until the clear key is pressed
• You will need four IF statements, one for each arrow key

Do you remember the arrow key numbers from Mini Project 1?  If not, return to it, and determine the number for each arrow key.

What do you think the IF statements will look like to control the movement of the string?

Can you error trap your code so the Domain Error doesn’t occur when the user moves the name off the screen?

Error trapping

The row and column variables have to be larger than 0.

:If R = 0
:Then
:1 →R
:End
:If C= 0
:Then
:1 →C
:End

There are 10 rows.

:If R = 11
:Then
:10 →R
:End

Error trapping (continued)

There are 26 columns. Count the number of letters in your name. Subtract from 27 to determine the maximum value for C.

:If C = 24

:Then
:23 →C
:End 

In this mini project, you’ll:

• Design two characters — a PLAYER character and a GOAL character.
• Learn how to turn pixels on and off.
• Change pixel colors using pre-defined colors.
• Create two programs — PLAYER and GOAL.

Think of your calculator as a piece of graph paper. The graph paper has 164 rows and 264 columns. To color one pixel the code is:

Pxl-On(row number, column number, color)

To create a blue rectangle that has a width of five and a height of two, type the code below.

• AxesOff is under FORMAT (2nd zoom).
• Colors can be found using the [prgm] > COLORS.
• All other commands are under DRAW (2nd prgm).

:AxesOff
:BackgroundOff
:ClrDraw
:Pxl-On(0, 0, BLUE)
:Pxl-On(0, 1, BLUE)
:Pxl-On(0, 2, BLUE)
:Pxl-On(0, 3, BLUE)
:Pxl-On(0, 4, BLUE)
:Pxl-On(1, 0, BLUE)
:Pxl-On(1, 1, BLUE)
:Pxl-On(1, 2, BLUE)
:Pxl-On(1, 3, BLUE)
:Pxl-On(1, 4, BLUE)

Modify your code. Create a brown rectangle that has a width of 20 and a height of 3.

The previous step had you write a line of code for each pixel. To make a 3 row x 20 column BROWN rectangle, you would need 60 lines of code. To simplify this process, we will use a loop.

:AxesOff
:BackgroundOff
:ClrDraw
:For(C,0,19)
:Pxl-On(0, C, BROWN)
:Pxl-On(1, C, BROWN)
:Pxl-On(2, C, BROWN)
:End

Note: If you want to color a row, but turn a few points off, use the command Pxl-Off(row number, column number).

For the maze project, you need to create two objects. Each object will be coded in its own program. One object will be your PLAYER that moves on the screen. The other will be a stationary GOAL object. Your objects need to be between 10 and 15 pixels in width and height. 

Use graph paper to sketch out each of your objects.

Sample objects:

 

                 

 

Here’s some sample code for the first sample object. If you designed your own objects, the snippets might help in coding your own designs. 

 

Note: Don’t start coding your characters until you’ve read step 6.

In this mini project, you will be moving your PLAYER object, which will be similar to how you moved your name in MP2.  You will need to:

• Draw the initial heart.
• Use a loop to detect key press values.
• Do the following X, if an arrow key is pressed.
• Turn all the heart pixels off.
• Redraw the heart in the new location.

Create a new program named PLAYER.  You’ll need two variables to shift your picture vertically (V) and horizontally (H). We’ll use K to represent the button push value.

Type the following code:

:ClrDraw
:0 →K
:0 →V
:0 →H

Use recall to import the code from image you’d like to be the PLAYER.

  rcl              ([2nd] [sto→])

  prgm

  EXEC

  Select the name of your file

  Press the enter key

Moving your object is similar to moving your name like you did in Mini Project 2. 

You will use:

• A WHILE loop around all of your pixel code that executes until the clear button is pressed
• The getKey command to determine when arrow keys are pressed
• IF statements to change the vertical and horizontal variables V and H

 

1. Add a WHILE statement at the end of code. The statement should continue while the user doesn’t press the clear button. 
2. Use the getKey command to store the keys pressed in the value K.
3. Write an IF statement that will happen if an arrow key is pushed.

Your code should look something similar to the code on the right.


Next you’ll write the code to hide the old shape.

Add a comment line so it will be easier to debug your code.
:”HIDE OLD

Then import the heart code.
:rcl prgmHeart 

 

Delete the ClrDraw from the beginning of the heart.

Note:If you leave the ClrDraw in here, it will delete your maze and your GOAL when we import this code into the maze game.

You need to modify every pixel line of the form

Pxl-On(row number, column number, color)

 

to

 
Pxl-Off(row number + V, column number + H)

 

Note: Remember V is the vertical shift and H is the horizontal shift.

 

This will turn off the old pixel from the old shifted location.

 

Add an End statement to the last line to end the IF for the key press.

:End

Now you’ll change the vertical and horizontal shift based on the key pressed.

• If the key is the left arrow key, subtract 30 from H
• If the key is the right arrow key, add 30 to H
• If the key is the up arrow key, subtract 20 from V
• If the key is the down arrow key, add 20 to V

:If K = 24
:Then
:H-30→H
:End

......<———Add the code for the Right, Up and Down key

If an arrow key was pressed, you need to redraw the shape after the shift.

 Insert the following:

:If K=24 or K=25 or K=26 or K=34
:Then
:”DRAW NEW

Now import the heart file one more time.

Delete the ClrDraw.

In this mini project, you will create a maze. You'll use lists to store values for each column indicating open and closed doors. You'll use Pxl-Onto turn on pixels. You will use lists, loops and the Pxl-on command to draw a maze similar to the one here.

The maze has six columns of walls not including the border (L1, L2 …).

The maze has eight rows.

You will use lists to store the properties of the walls.

In each column, we will use the number 1 to present a “closed” door and an 0 to represent an “open” door. Each column will have eight values.

 

Finish labeling the other four walls.

Now code the status of the six columns. Store each list of numbers in a separate list. Make sure to use list {} notation to define your list. 
:ClrDraw
:{1,0,1,1,0,1,1,1} →L₁
:{1,0,1,1,0,1,1,1} →L₂
:{1,0,1,1,0,1,1,1} →L₃


… add in the code for L₄ , L₅ and L₆.

Now to draw the walls using pixels. Each wall segment has a length of 20 pixels.

 

The top wall has a 1 stored in L₁(1). To code the first door we could use the following.

         (3 + 0,  60)
         (3 + 1,  60)
         (3 + 2,  60)
  …
         (3 + 20,  60)

The next wall is open because 0 is stored in L₁(2). 

 

The third wall is solid because 1 is stored in L₁(3).
         (3 + 20*2 + 0,  120)
         (3 + 20*2 + 1,  120)
         (3 + 20*2 + 2,  120)

  …
         (3 + 20*2 + 20,  120)

The fourth wall is solid because 1 is stored in L₁(4).
         (3 + 20*3 + 0,  150)
         (3 + 20*3 + 1,  150)
         (3 + 20*3 + 2,  150)

   …
         (3 + 20*3 + 20,  150)

 

Can you write a loop to draw the walls represented in L₁?

Code the four loops to create the four line segments for the border.

 

 

Does your code look something similar to the code on the right?

In this mini project you’ll learn how to randomly set doors open and closed in your maze. You’ll import the code from mini- project 5 and make a few adjustments.

You can skip Mini Project 6 and go straight to Mini Project 7, but then your game will be the same each time you open it. In this mini project, you’ll learn how to use the randInt() function to randomly create 1s and 0s in the six lists.

 

Create a new program named RMAZE.

Type the following code:

:For(A,1,8)
:randInt(0,1) → L₁(A)
:Disp L₁(A)
:End

Execute your code several times.

 
Approximately what percent of the doors will be open and closed?

How will that effect your game?

How could you modify the code to change the proportion of 1s and 0s?

In this step you will modify your existing code. Change the parameters for the random integer function to randInt(1,10). This will generate numbers 1 through 10. 

 

Modify your code to match the code below. This code will generate a 0 (door) approximately 20% of the time for any given slot.

:For(A,1,8)
:If randInt(1,10) < 3
:Then
:0 →L₁(A)
:Else
:1 →L₁(A)
:End
:End

Create a FOR loop for each of the six lists.

If the probability of generating a 1 is 20% for any given element, what is the probability all eight elements in a row are 1s creating one solid wall without any doors?

 

Since each number is independent of the next, the probability is
0.8x 0.8x 0.8x 0.8x 0.8x 0.8x 0.8x 0.8 = 0.8⁸ ≈ 0.167. 

 

Currently, the code will generate a column without any open spaces approximately 16.7% of the time. To fix this problem, we will check to see if the sum of all the items in the list equal 8. If the sum equals 8, all items equal 1. If this happens, code the project to randomly change one element to 0.
:If sum(L1) = 8
:Then
:0 →L₁(randInt(1,8))
:End

 

Now that the code randomly generates values for the lists, you need to import the code from the basic maze. After the import, delete the six lines that create the basic six lists from before.

Use recall to import the code from an image you’d like to be the PLAYER.

rcl              ([2nd] [sto→])   prgm EXEC Select the MAZE file Press the enter key

Execute your code several times. 

Is each maze unique?

Are you satisfied with the proportion of 1s and 0s? If not, how can you change the proportion?

In the final project, you will now create the Maze Game.  You’ll import the player, goal and random maze files.  You’ll add code to restrict movement to the maze.  Finally, you’ll create a message that lets the user know when the goal is obtained. Good Luck!

You now have most of the components already coded that you need to create the final maze game. In this last mini project, you will import code from other mini  projects and make some small alterations and additions to complete the maze game. 

File to import	Modifications
PLAYER (Mini Project 4)	Only move left/right if there is a door
RMAZE (Mini Project 6)
GOAL (Mini Project 3) [Sample is SMILE]	Modify the location if needed

 

1. Create a final project MZGAME.

2. Add a comment line, then import your maze created in project 6 named RMAZE using the recall method. 

:”MAZE
:rcl RMAZE

3. Add a comment then import your goal object created in Mini Project 3 using the recall method.  The sample was names SMILE, your file might be different.

 :”GOAL
 :rcl SMILE

 

Remove the ClrDraw from the beginning of the GOAL code.

 4. Add a comment line then import your player code.

 :”PLAYER CODE
 :rcl PLAYER 

 

Remove the ClrDraw from the beginning of the PLAYER code.

 5. Run your code make sure you don’t have any errors. If all the objects don’t stay on the screen, go line by line through your code looking for extra ClrDraw statements. You should have a ClrDraw at the beginning.

Can you modify your object 20 pixels when you move down vertically if it keeps your object on in the maze?

Did your modifications to your PLAYER work? Does your PLAYER stay in the maze and only move if a wall isn’t present?  

Here is one possible way to accomplish appropriate vertical movement.

 

 

You need to modify the left and right arrow keys from the PLAYER code. You first need to know how many spaces down and over your PLAYER has traveled. Inside the WHILE loop for your key press, Type the following:
:V/20 + 1 →Y
:H/30 + 1 →X

 

How do you restrict the PLAYER so it doesn’t walk through walls?

The Y value will let you know which row you are on. You’ll use this when determining if the element in list is a 0 (no wall) or a 1 (wall). The X value will let you know which list to analyze.

Locate your If statement to move left (If K = 24) and to move right (If K = 26).

 

Here is one way to modify the code.

 

	Left		Right
Include L3, L4, L5	:If K=24 and X > 1 :Then :If X-1 = 1 AND L1(Y)=0 :Then :H-30 →H :End :If X-1 = 2 AND L2(Y)=0 :Then :H-30 →H :End … (code continues) :End	Include L3, L4, L5	:If K=26 and X ≤ 6 :Then :If X = 1 AND L1(Y)=0 :Then :H+30 →H :End :If X = 2 AND L2(Y)=0 :Then :H+30 →H :End … (code continues) :End

 

Check your game. Make sure it works before you continue. Fix any errors you find.

How do you let the PLAYER know he or she has reached the GOAL? At the end your project, above the last End statement that controls the key press loop, add the following lines:

:If Y=1 and X = 7
:Then
:TextColor(BLACK)
:Text(75,110,“YOU WIN”)
:End

Optional — Add Sound Using the TI-Innovator™ Hub 

Connect your calculator to the TI-Innovator™ Hub.

Use the “Set Sound” command in each of the four IF statements for the arrow keys. You could use the same tone or a different tone for each key. Don’t forget to connect your TI-Innovator™ Hub for the sound to work.

 

:If K=24 and X > 1 
                :Send(“SET SOUND 262 Time 0.5”)
                :If X-1 = 1 AND L1(Y)=0 
                :Then 
                :H-30 →H 
                :End 
                :If X-1 = 1 AND L2(Y)=0 
                :Then 
                :H-30 →H 
                :End 
                …  
                :End

In this first mini project, you’ll import or create a background for your game.  You will also set up the screen dimensions. You will: 

• Download or draw the background image.
• Use TI-Connect to import the background.
• Display the background using code.

Connect your calculator to your computer and run the TI Connect™  CE software application.

      Open the Emulator Explorer workspace.

 

      Import your drawing as IMAGE8.

 

      Create a new program named BACKGRND.

 

     TI-Connect CE software is a free download, and can be found here.

You need to:

• Set the background to your image.
• Display graph

Type the following code:

Execute the program. After pressing the enter key does the background turn off?

Create a new program named NET.

 

You’ll import your BACKGRND code from Mini Project 1. We import this code to help trouble shoot bugs. If at any point your program becomes too hard to understand, you can start over and import the functioning BACKGRND code.

 

Use recall to import the background code:

  Rcl              ([2nd][sto→])
prgm
  EXEC
  Select BACKGRND
   Press the enter key

:Pause
:BackgroundOff
:RecallGDB 1

In this mini project, you’ll code the velocity gauge.  The gauge won’t change based on arrow keys yet.  This is just the drawing of the gauge.  You’ll import this code in two different places in MP 5.  You will:

• Create a variable F to store the velocity.
• Use the Line function to create a velocity meter.

 

It will be useful to have your background loaded as reference. We won’t do this in code because it is already coded in the NET code you’ll use in later projects.

Press [2nd][sto→]
Under Background, select the image that has your basketball background.

Optional: You can change the color of the power-up bar based on the value of F.  

Note: If you choose to not change the color, delete the ClrDraw from the top of your program.

Option 1: Entire bar changes color based on the value of F.	Option 2: The bar has different color segments based on the value of F.

Color Option 1: The entire power gauge color is based on the value of F. Therefore, you’ll use multiple IFs to select the color before the For statement.  Based on the results of the IF, you’ll set the color. You get to decide how many IFs to include, which will determine the number of color choices. Your modification should look something like the lines below:

                :MAGENTA →C
                :If F > 33
                :Then
                :ORANGE →C
                :End 
                :If F > 66
                :Then
                :BROWN →C
                :End 
                :For(A, 1, F)
                :Line(12, A + 12, 19, A + 12, C)
                :End
                :For(A, F+1,99)
                :Line(12, A + 12, 19, A + 12, WHITE)
                :End

 

Note: Once your program is complete and functioning, delete the ClrDraw from the top of your code.

Color Option 2: Each layer of the power gauge is based on a selection. Therefore, the IF is inside the FOR statement. Based on the results of the IF, you’ll set the color for that line. You get to decide how many IFs to include, which will determine the number of color choices. Your modification should look something like the lines below.

                :For(A, 1, F)
                :MAGENTA →C
                :If A > 33
                :Then
                :ORANGE →C
                :End 
                :If A > 66
                :Then
                :BROWN →C
                :End 
                :Line(12, A + 12, 19, A + 12, C)
                :End
                :For(A, F+1,99)
                :Line(12, A + 12, 19, A + 12, WHITE)
                :End

Note: Once your program is complete and functioning, delete the ClrDraw from the top of your code.

 

It will be useful to have your background loaded as reference. We won’t do this in code because it is already coded in the NET code you’ll use in later projects.

 

Press [2nd][ZOOM]

In Background, select the image that contains your basketball background.

Create a new program named ARC.

 

Add a comment line and a ClrDraw line. It will be beneficial to have the comment line when compiling the final project.

            :”ANGLE GAUGE
            :ClrDraw

 

You’ll create the gauge by drawing a series of line segments similar to the ones on the power gauge.  Instead of parallel lines like the power gauge, these lines will need to radiate from a single point as they are drawn.

r*sin(θ)=y              r*cos(θ)=x

 

We’ll use this relationship to draw the line segments in the angle gauge.

     :Line(X1, Y1, X1 + r*cos(θ), Y1 + r*sin(θ), Color)

 

You’ll start with a radius of 30. You may modify this value to fit your picture.

     :Line(X1, Y1, X1 + 30*cos(θ), Y1 + 30*sin(θ), Color)

Now to complete the angle gauge. You’ll indicate the angle θ using a different color. Add the code in bold to your project.
: 45→ θ
:For(A, 90, θ, -1)
:Line(65, 95, 65 + 30*cos(A°), 95+30∗sin⁡(A °), WHITE)
:End
:For(A, θ, 0, -1)
:Line(65, 95, 65 + 30*cos(A°), 95+30∗sin⁡(A °), MAGENTA)
:End

Be careful. Make sure all the thetas are θ and all the zeros are 0. 

Note: If you choose to skip the next three steps, delete the ClrDraw from the top of the program after you have thoroughly tested your code.

Option 1 (Step 9): Entire meter changes color based on the value of θ.	Option 2 (Step 10): The meter has different color segments based on the value of θ.

Option 1: The entire power gauge color is based on the value of θ. Therefore, you’ll use multiple IFs to select the color before the For statement. Based on the results of the IF, you’ll set the color. You get to decide how many IFs to include, which will determine the number of color choices. Your modification should look something like the lines below.

:MAGENTA →C
:If θ > 33
:Then
:NAVY →C
:End
:If θ > 66
:Then
:GREEN →C
:End
:For(A, 90, θ, -1)
:Line(40, 80, 40 + 30*cos(A°), 80+30∗sin⁡("A" °), WHITE)
:End
:For(A, θ, 0, -1)
:Line(40, 80, 40 + 30*cos(A°), 80+30∗sin⁡("A" °), C)
:End

Note: Once your program is complete and functioning, delete the ClrDraw from the top of your code.

Option 2: Each layer of the power gauge is based on a selection. Therefore, the IF is inside the FOR statement. Based on the results of the IF, you’ll set the color for that line. You get to decide how many IFs to include which will determine the number of color choices. Your modification should look something like the lines below.

:For(A, 90, θ, -1)
:Line(40, 80, 40 + 30*cos(A°), 80+30∗sin⁡(A °), WHITE)
:End
:For(A, θ, 0, -1)
:MAGENTA →C
:If A > 33
:Then
:NAVY →C
:End
:If A > 66
:Then
:GREEN →C
:End 
:Line(40, 80, 40 + 30*cos(A°), 80+30*sin(A °), C)
:End

Note: Once your program is complete and functioning, delete the ClrDraw from the top of your code.

In this mini project, you’ll import the code from all four previous projects.  You’ll code the left and right arrow keys to change the value of the angle gauge.  You’ll also code the up and down arrow keys to change the value of the power gauge. You will:

• Add the NET code.
• Add the GAUGE code.
• Add the ARC code. 
• Use getKey to change velocity and angle.

Create a program named BB.

 

Import the NET code:
  rcl ([2nd][sto→] )
  prgm
EXEC
Select NET
   Press the enter key

 

Delete the last three lines:
:Pause
:BackgroundOff
:RecallGDB 1

Import the GAUGE code:
rcl ([2nd][sto→] )
  prgm
  EXEC
  Select GAUGE
   Press the enter key

Import the ARC code:
rcl ([2nd][sto→] )
  prgm
  EXEC
  Select NET
   Press the enter key

 

Scroll through your code. Make sure ClrDraw is only in the first couple of lines. Delete all other ClrDraw commands you find.

You’ll use the arrow keys to change the values of F, the power level and θ the shot angle.

 

• If the left arrow key is pressed and θ < 88 you’ll increase θ by 2.
• If the right arrow key is pressed and θ > 2 you’ll decrease θ by 2.
• If the up arrow key is pressed and F < 100 you’ll increase F by 2.
• If the down arrow key is pressed and F > 2 you’ll decrease F by 2.
• If the left or right arrow key is pressed you’ll redraw the angle gauge.
• If the up or down arrow key is pressed you’ll redraw the power gauge.

 

All of this code will be embedded inside a loop that will repeat the selection statements until the ENTER key is pressed.

:”ARROW KEYS
:0 →K
:While K≠105
:getKey →K
:
:MISSING IF STATEMENTS
:

Can you code the first two IF statements inside the WHILE statement?

 

• If the right arrow key is pressed and θ > 2 you’ll decrease θ by 2.
• If the left arrow key is pressed and θ < 88 you’ll increase θ by 2. 

 

:”ARROW KEYS
:0 →K
:While K≠105
:getKey →K
:
: MISSING IF STATEMENTS
:

 

Does your code match the code on the right?

 

 

 

Can you code the next two IF statements inside the WHILE statement?

 

• If the up arrow key is pressed and F < 100 you’ll increase F by 2.
• If the down arrow key is pressed and F > 2 you’ll decrease F by 2.

 

All of this code will be embedded inside a loop that will repeat the selection statements until the ENTER key is pressed.

:”ARROW KEYS
:0 →K
:While K≠105
:getKey →K
:
: MISSING IF STATEMENTS
:

 

Check your lines of code. 

 

Make sure the only ClrDraw is in the first couple of lines of code. 

Delete any other ClrDraws you find.

 

Execute and debug your code. The arrow keys should update the values for F the velocity and θ the shot angle.

In this mini project, you’ll import the code from MP5.  You’ll learn the math to model the basketball’s path. You will draw the path of the ball when the user presses the enter key. You will:

 

• Import the code from the BB code.
• Use an IF statement to make a selection.
• Use DrawF to draw the shot.
• Use an IF statement to determine if a shot is made.

Create a program named TOSS.

 

 

The first two lines of code will create variables to keep track of your shots made and the total number of shots attempted. Use the variable H for hits and T for tosses.

:0 →H
:0 →T

Import the BB code:
rcl ( [2nd][sto→)
  prgm
  EXEC
  Select NET
   Press the enter key

x = 65 + F*cos(θ)*t                                              y = 95 + F*sin(θ)*t - 4.9*t²   

t=(x-65)/(F∗cos⁡(θ))

 

You can combine these two equations into one with a little substitution:
  y = 95 + F*sin(θ)*(x-65)/(F∗cos⁡(θ)) - 4.9*((x-65)/(F∗cos⁡(θ)))²

 

  y = 95 + sin(θ)*(x-65)/(cos⁡(θ)) - 4.9*((x-65)/(F∗cos⁡(θ)))²

 

  y = 95 + tan⁡(θ)*(x-65) - 4.9*((x-65)/(F∗cos⁡(θ)))²

 

If your starting X₁ and Y₁ values are different, make sure you use those values instead of 65 and 95 on the next step.

Delete the last End statement at the end of your code. This ends the WHILE statement used to get a key pressed. You’ll insert an IF statement that will execute if the enter key is pressed.

 

Write the following lines of code:

:”SHOOT BASKET
:If K = 105
:Then

You could simply DrawF ([2nd][[DRAW]) with the equation you found in Step 4. However, that will draw the entire parabola. We only want the part when X > 65. (Your x value may be different. Use your starting X value.) Therefore, we will add a small conditional statement to the equation. 

 

Add the two new lines:

:”SHOOT BASKET
:If K = 104
:Then
:DrawF ((95 + tan(𝜽°)*(X-65) – 4.9*((X-65)/(F*cos(𝜽°)))²)/(X>65))
:End

 

Add one more End to complete the WHILE loop.

Execute your code. Make sure it runs. Try several games. Use the arrow keys to change the velocity and the angle.

In this mini project, you’ll code the scoring components of the game.  You’ll create an equation to determine if the ball was a “SWISH” or a “MISS” and give the user feedback.  You’ll also learn how to keep track of the number of baskets made overall. You will:

• Import the code from the TOSS file.
• Use an IF statement to determine if the shot is made.
• Create a flag variable to determine if a new hoop should be generated.
• Use an IF statement to determine if another hoop should be generated.
• Add another WHILE statement to continue play.

Create a program named BBGAME.

 

You could extend the code in TOSS instead of creating a new file. However, it is a good idea to keep a backup of your code in case you need to start over.

 

Import the TOSS code:
  rcl ([2nd][sto→])
  prgm
  EXEC
  Select TOSS
  Press the enter key

 

Make sure your code works.

In order to make the shot, the ball needs to pass through the hoop. That means for some X value between 241 and 259, the function should evaluate to a y value between Y and Y+10. 

You’ll create a variable, A, to store the amount to add to the score. The value of A will start at 0. You’ll check all 19 x-values to see if one of them evaluates to a Y between Y and Y + 10. If one value matches the criteria, set the variable A to 1. After you check all 19 values, add A to the number of hits.

 

The pseudocode looks like:
                   Set A to 0
                   Loop through all 19 x values
                            If  Y > f(x) > Y+10
                                   Set A to 1
                   Add A to H
                  Add 1 to T

 

Can you add this loop on the blank lines you created in the previous step?

:0 → A
:For(X, 241, 259)
:95 + tan(𝜽°)*(X-65) – 4.9*((X-65)/(F*cos(𝜽°)))² →W
:If W < Y and W > Y-10
:Then
:1 → A
:End
:End
:A + H → H
:1 + T → T

Run your code. Make sure there aren’t any build errors. There is a slight issue with the calculation you’ll fix in the next step.

:TextColor()
:If A = 1
:Then
:Text(80,80,“SWISH”)
:Else
:Text(80,80,“MISS”)
:End

Look at the modifications below.  Are they similar to what you thought? 

Load the background
Generate a hoop and draw the net (NET code)
Draw both gauges (GAUGE and ARC code)
    1. While the clear key isn’t pressed continue playing game
While the enter key isn’t selected let the user adjust the gauges
If the arrow keys are pressed
update the appropriate gauge
If the enter key is pressed
draw the path
update H and T (you haven’t displayed these yet)
display a descriptive message.
End the enter key loop
    2. Wait until the “+” key is pressed (Use a while)
    3. Generate a hoop and draw the net (NET code)
    4. Draw both gauges (GAUGE and ARC code)
    5. Display the score
    6. End the game loop

It might look a little overwhelming at first, but there will only be a few lines of code for you to actually type. Isn’t it easy to import code using the rcl method? That’s one useful reason for modular coding. It allows you to code and debug smaller chunks of code, then import them into larger projects.

Let’s tackle the first new section of code.

Draw both gauges  (GAUGE and ARC code)
1.While the clear key isn’t pressed continue playing game
     While the enter key isn’t selected let the user adjust the gauges

It should be below the 0 →K. We still need to initialize the value of K before we use it in the WHILE loop. 

We’ll use the clear button, number 45, to exit the game.

:While K≠45
:While K≠105
:getKey→K
:If K = 4
:Then
:Stop
:End

:While K≠𝟗𝟓
:getKey → K
:If K=95
:Then
:ClrHome
:End
:End

:Text(1, 1, “SCORE=”, H, “/”, T)
:End

 

1. While the clear key isn’t pressed continue playing game
      While the enter key isn’t selected let the user adjust the gauges
                  If the arrow keys are pressed
                           update the appropriate gauge
                  If the enter key is pressed
                            draw the path
                            update H and T (you haven’t displayed these yet)
                            display a descriptive message
        End the enter key loop
 2. Wait until the “+” key is pressed (Use a while)
 3. Generate a hoop and draw the net (NET code)
 4. Draw both gauges (GAUGE and ARC code)
 5. Display the score
 6. End the game loop

In this final mini project, you’ll create fireworks and a trophy to appear after the user sinks enough baskets.  You will:

• Create a temporary file Win.
• Use FOR statements to repeat code.
• Use the TI Connect™ CE software application to import a background.
• Import the Win code into your final project.

You could add this code directly to the end of the basketball game. However, you’d have to run through the entire game each time you needed to fix a bug or wanted to see your fireworks progress. Therefore, we are going to create a short program W that will allow you to design your fireworks and trophy code without all the other lines you have done so far.

 

Create a new program named WIN.

 

You’ll import your BACKGRND code from Project 1. We import this code so we’ll have all the settings set to the same as the game’s settings.

 

Use recall to import the keyboard code:

  rcl              ([2nd][sto→])
  prgm
  EXEC
  Select BACKGRND
   Press the enter key

Connect your graphing calculator to your computer and open up the TI Connect™ CE software application.

 

   Open the Emulator Explorer workspace.

 

   Import the night sky as IMAGE7.

 

   Import the trophy as IMAGE9.

To draw the fireworks, you’ll use the Circle command.  Remember, it uses Circle(x, y, radius, color)

 

 

 

Notice how, to make the colors symmetric, one equation adds to 80 the other equation subtracts the same amount from 80.

 

Execute your code. Debug any errors.

The loop for the second firework is

:ClrDraw
:For(I, 0, 7)
:Circle(180 + I*4, 80 – (I-10)², 1, RED)
:Circle(180 - I*4, 80 – (I-10)², 1, RED)
:Circle(180 + I*10, 80 – (I-10)², 1, ORANGE)
:Circle(180 - I*10, 80 – (I-10)², 1, ORANGE)
:Circle(180 + I*25, 80 – (I-10)², 1, RED)
:Circle(180 - I*25, 80 – (I-10)², 1, RED)
:END

Execute your code. Debug any errors.

Last step before you import your code to the game, clear the drawing and display the trophy

:ClrDraw
:BackgroundOn Image9

Execute your program and debug any errors.

Open the code for BBGAME.

 

Go to the end of your code. Insert four blank lines above the last End statement.

What constitutes a winning game? One basket? Five baskets? Is 5/6 a winner but 5/100 not?

 

For now, you’ll say one basket is a winner so we can test the code. Insert the following lines of code. They will set the key value K to 45 which exits the overarching WHILE statement:

:IF H = 1
:Then
:45 →K
:End

Scroll to the end of your code. Fireworks are the last thing that should happen.

 

Import your WIN code.

 

Use recall to import the keyboard code:

  rcl              ([2nd][sto→])
  prgm
  EXEC
  Select WIN
   Press the enter key

Play your game a few times. 

 

Change the winning setting to a setting of your choice. 

 

You might say three SWISHES are a win, so your IF statement would be If H = 3.

 

You might say at least three SWISHES and at least 50% are a win, so your IF statement would be:
  H/T →P

  If H  ≥3 and P ≥ 0.5 

After completing a series of 5 mini-projects, you will have a few different ways to play a piano simulation on your calculator.  You will be able to play the piano using the keys on your handheld, using the brightness sensor on the TI-Innovator Hub, using a separate ultrasonic sensor or using the ultrasonic sensor on the TI-Rover. The first mini project will be used as the base code. 

In this project, you’ll:

• Import a piano picture.
• Use if statements to make selection.
• Draw a point to indicate which piano key is pressed.
• Use a FOR statement to repeat code.

Note: If you have yet to complete the Maze project, you may want to complete the Mini Project 1 from that project “Detect Which Keys Are Pressed” before you start the Piano project.

Connect your calculator to your computer and run the TI Connect™ CE software application.* You’ll need to download the files from the folder to your computer first, and then transfer to the calculator.

       Open the Emulator Explorer workspace.

 

      Import the piano drawing as IMAGE1.

 

Create a new program named PIANO.

 

*TI Connect™ CE software is a free download.

Your graphing calculator has a width of 165 pixels and a height of 265 pixels.

 

By default, the upper left corner is (0,0).

This may seem odd, but often in programming, as you go down a screen the values increase.

 

You can change the orientation of the coordinate grid so (0,0) is in the lower left and the value increase as you go up the screen. 

Put ClrDraw as your first line of code ( [2nd] [prgm] ). This will clear any old graphics off the screen. 

 

Set the x values using the code:

:0 →Xmin
:264→Xmax

 

Set the y values using the code:

:0→Ymin
:164→Ymin

You need to:

•  Turn functions off
•  Turn plots off
• Set the background to your image

 

 The following code will accomplish the three tasks:

:FnOff
:PlotsOff
:BackgroundOn Image1
:DispGraph

The natural (white) keys start at x = 10. Each natural key has a width of 30 pixels. You have eight natural keys in your picture. 

The sharp () keys start at x = 35. Each sharp key has a width of 10 pixels. They are also 30 pixels apart. There are six sharp keys in your picture.

To represent a pressed key, you’ll draw a point using the point on command.

 

To draw the point, the code is Pt-On( X, Y, Style, Color) where the point (X,Y) is the center of the point. We will use Style = 2, but feel free to explore style values from 1–7. 

 

What would the line of code look like to draw the point to the right?

Did your code look similar to the code below?
:Pt-On(25, 30, 2, MAGENTA)

 

 

 

 

 What would the line of code look like to draw the square to the right?

If you want to draw squares on all the natural keys, you could write eight different lines of code, or you could write a FOR loop similar to the one below.

:For(A,0,7)
:Pt-On(25 + 30*A, 30, 2, MAGENTA)
:End

 

Write a FOR loop to draw squares on all the sharp keys. 

Hint: You’ll need an IF statement inside your loop to skip the two missing keys.

Did your code look similar to the code below?

:For(A,0,7)
:If A≠2 and A ≠6
:Pt-On(41 + 30*A, 90, 2, MAGENTA)
:End

Now you know how to draw points on all the keys to represent playing the piano. You’ll utilize this skill in the next activity which has you incorporate key press values from the keypad to draw different points. You’ll then use key press values to play the correct note for the piano key.

 

Delete the loops you have written but remember formula format. You’ll use the formula later. The only base code you’ll need for the next project is shown on the right.

In this mini project, you will be able to "play" the piano using the keys on your handheld. You will :

• Import PIANO to draw your keyboard.
• Use getKey to retrieve key press values.
• Use IF statements to make decisions.
• Use lists to store information.
• Use a WHILE statement to repeat code.

Create a new program named PIANOKEY.

 

Use recall to import the keyboard code from the first mini project.

rcl ( [2nd] [sto→])
prgm
EXEC
Select PIANO 
Press the enter key 

In 10 Minutes of Code for the TI-Innovator™ Hub, Unit 2, Skill Builder 3, it says that “Musical notes are determined by the frequency of a vibrating object such as a speaker, drum head, or as in a guitar or a piano. The notes of the musical scale have a special mathematical relationship. If a note has a frequency F, then the very next note has a frequency F * 2^1/12.”     

 

Multiplying a note’s frequency by 2^1/12 gives the next note in the scale. 

We’ll turn the calculator sideways and use the lowest two rows to represent the keys on the piano keyboard.

 

      

Middle C, represented by the [2nd] key, key 21, has a frequency of 261.64 Hz.

The next note C# has a frequency of 261.64*2^1/12 ≈ 277.20 Hz.

 

D has a frequency of 261.64*2^2/12 ≈ 293.68 Hz.

 

D# has a frequency of 261.64*2^3/12 ≈ 311.14 Hz.

 

What is the frequency for E?

What is the frequency for B?

What is the frequency for the C above middle C (key 91)?

Now to match the key number to the exponent numerator.  
Complete the table below.

Can you find a mathematical pattern to relate the key number to the exponent’s numerator?