TI-SIMON, By Daniel Wilhelm

This is a repeated pattern program in which the computer shows a sequence and the player must repeat it. Following is a fairly comprehensive manual on how the program works (to help you in making your own TI-BASIC games) followed by the program code. 

VARIABLE LISTING
A - Used to tell if the current blit is the computer's move or the player's
I  - A general For counter
J - A general For counter; used for drawing the blits inside I loops
L - The level (e.g. how many blits the player has to remember)
R - The random number (when comp moves) or the response (when user moves)
X - The starting X position for the current blit
Y - The starting Y position for the current blit
SSD (list) - Simon Says Data, for holding the sequence

LABEL LISTING
BK - Used as an improvised subroutine; goes BacK from the DR label
DR - Computes the starting X and Y for DRawing the blits
EG - End Game, the user has inputted an incorrect sequence
EX - EXits the program
NX - Gets the NeXt keypress from the user
ST - The STart of the program

I decided to make this game in graphics mode (the Graph Screen) instead of text mode (the Home Screen), mostly because more professional graphics displays can be performed there. It is important to note that in the above and following texts, a blit is defined as the blanking of one of the four quadrants in the main game screen when the computer is showing its sequence. 

#1)  The first paragraph of code sets up the viewing window so that each X value is one pixel on the display screen (basically gotten from ZOOM->ZInteger). The Y values are taken from half of the ZInteger function, so every Y value is two pixels down on the graph. Then a simple introductory message is displayed and waits until a keypress is entered.

The label ST is the start of the program, in case the player wants to replay the game. When in graphics mode, you must make sure that the functions and plots are off so that predefined Y=...  functions are not drawn when the graph is displayed (also, make sure to turn these back on afterward). My game uses the axis to separate the screen into 4 parts (which is why the Xscl and Yscl is set to 0 - no tick marks). 

#2)  A is initialized to 0 so that the first time we pass through the blit function it recognizes that the computer is moving. Note that the While 1 statement will repeat indefinitely, as 1 is always equal to 1. Next a simple text dropper is implemented that will make falling text in the Home Screen. This is simply done via the Output command, by making the Y parameter part of a For loop. One interesting thing to note is that the calculator has no time consuming function, so a For loop that does nothing but L*1->L is used that effectively takes up a constant amount of time on the calculator (L+0->L would also work and would most likely perform faster). 

#3)  The number blits occur proportionally to the level number, so a For loop loops from 1 to L (the level). Now we start the DR label. This section is set up to act as a subroutine - unfortunately by using Goto statements to facilitate for the calculator's lack of support for in-program subroutines (although it does allow for external ones). Remember that we are in graphics mode, so the screen is mapped out to a preset coordinate system (in this case: X=-47 to 47, Y=-15 to 15) so we must simply calculate the upper left hand corner for each blit in terms of X and Y so that we can use the same blit function for all four corners (R=1, upper left; R=2, upper right; R=3, lower left; R=4, lower right). Then is our pseudo-subroutine Goto, which branches to BK if R was user defined.

#4)  Now we are at the computer's blitting routine. Since our X and Y values are preset, we must draw a line from (X,Y) to (X+47,Y) and so on for decrementing values of Y (because we are starting in the upper left corner of the blit). Following the draw is an immediate blank out so that we preserve the screen and don't have to redraw it via ClrDraw (slow and choppy). Notice how the For loop and X+... value have been modified so that the line doesn't write over the axis. And finally, we store the blit number in List SSD so that we can later tell if the user's sequence is correct.

#5)  It is time for the user to input something, as the computer is done displaying its pattern, and we must collect L inputs. The input via getKey is checked with valid values (the 7, 8, 4, 5, and 2nd keys) then if one is not found it simply loops back to get another keypress. If one is found and it is correct in the sequence, the finding X and Y value code is reused at DR, except that this time R represents the user's response and A is set, letting DR know to bring the value back by Goto. If the 2nd key is hit, it branches to the EX label which exits the program. If it is not the correct press in the sequence, it flows to EG.

#6)  In this next section we draw the user's selection. X's were used to denote his keypress (if it is correct). Note that we could have used the same blit code the computer move uses, but the X's are much faster and produce a nice effect as well. 

#7/8)  Now the screen does some fancy blanking (Vertical commands) at label EG and asks the user to replay. And at label EX the program cleans up after itself, so it is much friendlier to the user if he/she exits via the 2nd key rather than a manual 'ON' keypress. Also, some exiting text is displayed.

Note: -> stands for 'STO' key.  LSSD stands for a miniature L  (in LIST->OPS->B) followed by 'SSD'.
PROGRAM: SIMON
: -47->Xmin				; 1
: 47->Xmax
: 0->Xscl
: -15.5->Ymin
: 15.5->Ymax
: 0->Yscl
:
: ClrHome
: Output(1,5,"TI-SIMON")
: Output(3,2,"RePeAT PATTeRN")
: Output(5,1,"KeYS:")
: Output(5,7,"7  8")
: Output(6,7,"4  5")
: Output(7,4,"2ND eXITS")
: Output(8,2,"(PReSS A KeY)")
:
: While getKey=0
: End
:
: Lbl ST
: ClrDraw
: FnOff
: PlotsOff
: AxesOn
: 
: 0->A					; 2
: 0->L
: While 1
: L+1->L
: For(I,1,8)				
: ClrHome
: Output(I,5,"LeveL")
: Output(I,11,L)
: For(J,0,30)
: L*1->L
: End: End
:
: DispGraph
: For(I,1,L)				; 3
: randInt(1,4)->R
: 
: Lbl DR
: If R=1 or R=3
: Then: -47->X
: Else: 0->X: End
: If R<3
: Then: 15->Y
: Else: 0->Y: End
:
: If A=1: Goto BK
: 
: For(J,1,14)				; 4
: Line(X+1,Y-J,X+46,Y-J): End
: For(J,1,14)
: Line(X+1,Y-J,X+46,Y-J,0): End
:
: R->LSSD(I)
: End
: 
: For(I,1,L)				; 5
: 
: Lbl NX
: getKey->R
: If R=72: 1->R
: If R=73: 2->R
: If R=82: 3->R
: If R=83: 4->R
: If R=21: Goto EX
: 
: If R>4 or R=0
: Goto NX
: 
: If R!=LSSD(I)
: Goto EG
: 1->A
: Goto DR
: Lbl BK
: 0->A
: 
: Line(X+1,Y-1,X+46,Y-14)		; 6
: Line(X+1,Y-14,X+46,Y-1)
: For(J,1,20)
: L*1->L: End
: Line(X+1,Y-1,X+46,Y-14,0)
: Line(X+1,Y-14,X+46,Y-1,0)
: End: End
: 
: Lbl EG				; 7				
: For(I,-15,15)
: Horizontal I
: End
: For(I,-47,47)
: Vertical I
: End
: Menu("RePLAY?", "YeS",ST,"NO",EX)
: 
: Lbl EX					; 8				
: ClrHome
: FnOn
: ClrDraw
: Output(4,5,"SIMON, BY")
: Output(5,2,"DANIEL WILHELM")
: Stop