Machine Problem 3: LiteCycles

Introduction

Text-mode Video

Keyboard Control

The topic of interrupts was discussed in great detail during the Lecture 14 class period. The operation of the keyboard controller was discussed during Lecture 16.

Timer Control

The default timer interrupt rate is 18.2 times per second.  Unfortunately, this is not fast enough for this MP, as action can occur more frequently than that.  One of the jobs of InstTimer will be to increase the interrupt rate up to 72.8 times per second. See the lab notes for details.

Data Structures

• Constants for this MP are defined in MP3CONST.ASM.  Some of them are explained below.
• P1_U, P2_L, etc. : These define the scan codes for keyboard control of the players.  See the lab manual and lecture notes for more information on scan codes.
• UP, DOWN, LEFT, RIGHT : These should be used when comparing directions or passing them as arguments.  It is much easier to read your code if you use enumerated values instead of directly using integers.
• GRIDSPACE, GRIDWALL, P1WALL, P2WALL : Use these values when writing and reading from the grid array. The outside perimeter should possess the value GRIDWALL.  Walls created by player one and player two should have the values P1WALL and P2WALL, respectively. All other points (spaces) should have the value GRIDSPACE.
• SCREENSIZE_X, SCREENSIZE_Y : Size of the video screen in columns and lines.  Normally, this will be 80 x 50, but you should allow for modifications by using these constants instead of hard-coded values.
• GRIDSIZE_X, GRIDSIZE_Y : Size of the game grid.  GRIDSIZE_X <= SCREENSIZE_X and GRIDSIZE_Y <= (SCREENSIZE_Y - 1).  The grid should be positioned at the upper-left corner of the screen.
• *ATTR : The text-mode video attributes for drawing text, grid background, crash, or player wall.  Use these in the higher byte when writing to video memory.
• *SYMBOL : The ASCII values for a crash indicator or a player wall.  Use these in the lower byte when writing to video memory.  For the grid perimeter walls, find the appropriate symbols in an ASCII table, and add your own constants (e.g., LOWER_RIGHT_CORNER, etc.).
• Some variables have already been defined for you in the program framework.
• grid : A two-dimensional array of bytes that describes where all the walls in the game are. Its dimensions are specified by the constants GRIDSIZE_X and GRIDSIZE_Y and is indexed from the upper left-hand corner, first across, then down. This array is written to only by DrawCycles but can be read from various routines.  Often, an offset value refering to the beginning of grid is passed to a routine as an argument.
• p1X, p1Y, p2X, p2Y : The current x- and y-coordinates of the two players within grid. The point (0,0) is at the upper-left hand corner of the grid.
• playerPosState : Determines which one of four starting positions will be used for the next round.  See SetPlayerPos for details.
• p1Score, p2Score : The current scores for the two players.  Scores start out at zero.  If a player crashes, the other player's score is incremented by one, except for in the special case where the two players collide or otherwise crash during the same step (in which case scores should remain the same).
• p1KeyDir, p2KeyDir : Written to by our modifed keyboard interrupt handler. p1KeyDir and p2KeyDir take on either UP, DOWN, LEFT, or RIGHT if an appropriate key is pressed.  For example, if the handler detects the scan code corresponding to P1_R, then it will set p1KeyDir to RIGHT.
• escPressed, spcPressed : Written to by our modifed keyboard interrupt handler.  A value of one (1) is written to these variables if the escape key or the space bar is press, respectively.  The user code that checks for the setting of these values should reset the value to zero (0) before checking for a value of one (1).
• p1Dir, p2Dir : These are the directions that each player is heading in as determined by P1Control and P2Control, respectively for use in DrawCycles.  Your AI might want to take advantage of this information as well.
• round : Specifies which round we are in.  round should start at one (1) and increment at the end of each round.
• timerCount : Incremented by the timer interrupt handler each time it is called.  When set up, it should increment approximately 72 times per second.  It is up to user code to reset timerCount if necessary.
• gameSpeed : Used to control game pace.  Modified by SetGameSpeed. gameSpeed is initially set to 24, which should correspond to a pace of 3 steps per second (72/24).  In SetGameSpeed it is decreased slightly at the end of each round.
• oldTimerV, oldKeyV : Hold far pointers to the default timer and keyboard interrupt handlers.  Used in the interrupt install/deinstall routines.
• p1Name, p2Name : 8-byte (plus '$') strings to specify the player's names.

Procedures

• This assignment has eight procedures. You will receive credit for this assignment by replacing each of the eight procedures listed below with your own code.
• Experiment with the working code to gain a full understanding of how the program works.  The library version of P2Control uses the artificial intelligence AI291 instead of keyboard inputs so that you can get a feel for how that works. For best results, operate the program in FULL-SCREEN mode (Hit ALT-ENTER to switch between windowed and full-screen mode).
• Your program should exactly match the functionality of the library subroutines.
• All subroutines should be modular. They should use the stack to preserve the value of any registers they may modify.
• Use defined constants where appropriate.

• For Checkpoint 1, you must complete the following routines:

• GameMain
• Purpose: Control game flow.
1. Install and deinstall timer and keyboard handlers at the beginning and end.
2. Print out StartMsg
3. Initialize screen and grid and configure player starting positions and game speed before the start of every round
4. Wait for the space bar to be pressed in between rounds
5. During a game, between each step, wait for timerCount to reach gameSpeed and then ...
6. Get directions from both players
7. Draw litecycles on the screen
8. If a player crashed, display the appropriate message (check behavior of library version)
9. Update scores and round.
• Inputs: Keyboard controls
• Outputs: A TRON LiteCycles game!
• Notes:
1. When in doubt, check out how the library version does something.
2. Use the provided strings for messages when possible.
• Points: 8
 
• DrawScreen
• Purpose: Writes the initial game grid to video memory
• Draws grid perimeter and inside spaces.
• Prints status line on line below bottom wall of grid.
• Inputs:
• RoundInfoMsg (non-changing)
• round
• p1Name, p2Name
• p1Score, p2Score
• Outputs: Writes to video memory (segment 0B800h)
• Notes:
• Hints: It would be handy to write helper functions that write strings or integers to video memory for printing the status line.
• Points: 5
 
• ResetGrid
• Purpose: Initialize grid before each round.
• The perimeter should be set to GRIDWALL and the interior should be set to GRIDSPACE.
• Inputs:grid (uninitialized)
• Outputs:grid (initialized)
• Points: 3
 
• SetPlayerPos
• Purpose: Setup initial position of each player
• Inputs: playerPosState
• Outputs:
• If playerPosState = 0
• p1 is at (9,45), p2 is at (70,45)
• p1Dir and p1KeyDir are UP, p2Dir and p2KeyDir are UP
• = 1
• p1 is at (29,30), p2 is at (50,40)
• p1Dir and p1KeyDir are RIGHT, p2Dir and p2KeyDir are LEFT
• = 2
• p1 is at (4,45), p2 is at (75,35)
• p1Dir and p1KeyDir are RIGHT, p2Dir and p2KeyDir are UP
• = 3
• p1 is at (35,25), p2 is at (45,26)
• p1Dir and p1KeyDir are LEFT, p2Dir and p2KeyDir are RIGHT
• playerPosState = (old playerPosState + 1 ) mod 4 (but don't use DIV!)
• Points: 3
 
• SetGameSpeed
• Purpose: Determine the next round's pace
• Inputs: gameSpeed (old value)
• Outputs: gameSpeed
• Notes:
• If old gameSpeed = 1, then do not change it
• Else new gameSpeed = (15 * old gameSpeed / 16)
• Hints: Don't use DIV!
• Points: 3
 
• P1Control, P2Control
• Purpose: Determines next directions to head in for players.
• Could get direction from keyboard (p1KeyDir, p2KeyDir).
• Could get direction from an AI (usernameAI or AI291).
• Inputs:
• p[1,2]Dir (previous direction taken)
• p[1,2]KeyDir
• DH : this player's x-coordinate
• DL : this player's y-coordinate
• CH, CL : other player's x- and y-coords
• SI : offset of grid
• Outputs: p[1,2]Dir holds value of next direction for this player.
• Notes:
• The expression [1,2] means to use '1' if this is P1Control and to use '2' if this is P2Control.
• Configure each of P1Control and P2Control to use either keyboard or AI input by commenting out select blocks of code at a time.
• Hints: Not all the inputs necessarily need to be used.
• Points: 3
 
• For Checkpoint 2, you must complete the remaining routines:

• DrawCycles
• Purpose: Moves litecycles to new positions and check for collisions
• Inputs:
• p1Dir, p2Dir
• grid
• p1X, p1Y, p2X, p2Y
• Outputs:
• If no crashes, draws a  PLAYERSYMBOL at each player's new position.
• If someone crashes, draws a CRASHSYMBOL at the site of the crash.
• AL
• 0000b - no crash
• 0001b - player one crashed
• 0010b - player two crashed
• 0011b - both players crashed
• 01xxb - players collided (special case of both players crashed)  This means that both players reach the same grid point during the same step.
• Hints: It would be handy to write a helper function (or macro) that convert x- and y-coordinates into an offset into grid.
• Points: 8
 
• InstTimer, DeInstTimer, MyTimerHandler
• Purpose: Controls pace of game through timer interrupts
• InstTimer
• Saves default interrupt vector in OldTimerV.
• Points the timer interrupt to MyTimerHandler.
• Configures timer chip to send a signal 72 times per second.
• DeInstTimer
• Restores OldTimerV as the default timer routine.
• Reconfigures the timer chip to send a signal 18 times per second.
• MyTimerHandler
• Increments timerCount each time that it is called.
• Calls OldTimerV 18 times per second (i.e., every fourth time).
• Sends ACK and end-of-intterrupt.
• Inputs:
• none for InstTimer
• OldTimerV for DeInstTimer
• timerCount for MyTimerHandler
• Outputs:
• OldTimerV for InstTimer
• none for DeInstTimer
• timerCount for MyTimerHandler
• Notes: Follow the instructions given in lecture for installing interrupts and for interrupt handlers.
• Hints:
• To aid in debugging, test these three routines separately of any others.
• Remember to initialize DS if you need to access variables.
• Points: 6
 
• InstKey, DeInstKey, MyKeyHandler
• Purpose: Grabs game control commands from the keyboard
• InstKey: Saves default interrupt vector in OldKeyV
• DeInstKey: Restores default interrupt vector from OldKeyV
• MyKeyHandler
• Sets escPressed to one (1) if the escape key is pressed.
• Sets spcPressed to one(1) if the space bar is pressed
• Sets p1KeyDir to one of UP, DOWN, LEFT, or RIGHT, depending on whether P1_U, P1_D, P1_L, or P1_R were pressed.
• Similarly for p2KeyDir.
• Sends ACK and end-of-interrupt.
• Inputs:
• none for InstKey
• OldKeyV for DeInstKey
• none for MyKeyHandler
• Outputs:
• OldKeyV for InstKey
• none for DeInstKey
• escPressed, spcPressed, p1KeyDir, p2KeyDir
• Hints:
• Remember to initialize DS if you need to access variables.
• Points: 6
 
• AI291
• Purpose: An example AI. Call it from your P1Control or P2Control
• Inputs: same as AIusername
• Outputs: same as AIusername
• Notes: This AI is fairly simple and can survive a long time., but behaves very passively (doesn't go after the other player).
• Points: 0 (it's already written!)
 
• AIusername
• Purpose: An artificial intelligence. Have the computer play against itself or a human
• Your AI should be able to beat AI291 in at least two thirds of the rounds.
• Your AI should be able to beat the ECE291 staff most of the time.
• Inputs:
• DH, DL: hold player's x- and y-coords, respectively
• CH, CL: hold other player's x- and y-coords, respectively
• SI: offset of grid
• BL: player's previous direction taken
• Outputs: AL: holds value of next direction for player
• Notes:
• Feel free to add additional variables to hold state for your AI, but do not modify any predefined variables.
• Substitute your username in AIusername (so user jessica would call her AI "AIjessica")
• Hints: Use helper routines to help your AI look around.
• Points: 5

Preliminary Procedure

• Copy the empty MP2 program (MP3.ASM), the constant definition file (MP3CONST.ASM), libraries (libmp3.lib, lib291.lib), and Makefile from the network drive to your home directory with the following command:

xcopy /S V:\ece291\mp3 W:\mp3
Alternatively, from home, you can download the same files as mp3.zip.
• As before, run NMake to build an executable program using the given ECE291 library functions.
• As in the past, use a text editor to modify the program. As given, the program uses LIBMP3 routines to implement all functionality. To receive full credit for the assignment, you will need to implement each of the subroutines described above with your own code.
• As before, use CodeView (CV) to debug and test your program. Because you only receive credit for procedures that function completely as specified, it is best to debug each routine individually.
• By modifying a few comments, you can mix and match usage of your own code and Library routines. You may notice that the LIBMP3 routines contain extraneous and difficult-to-read code. They are not meant to be unassembled!

Revision History

• Version 1.0: (10/12/98) - First code release

Monitor the newsgroup and this on-line section for revisions to the MP or to the writeup

Final Steps

1. Print a copy of the MP3 grading sheet.
2. Demonstrate the first checkpoint of MP3.EXE to a TA or to the instructor.
• Be prepared to answer questions about any aspect of the operation of your program. The TAs will not accept an MP if you cannot fully explain all operations of your code.
3. Demonstrate the second checkpoint of MP3.EXE to a TA or to the instructor.
• Be prepared to answer questions about any aspect of the operation of your program. The TAs will not accept an MP if you cannot fully explain all operations of your code.
4. Handin in your program by running:
• A:\Handin YourWindowsLogin
• Print MP3.ASM
5. Staple the MP3 grading sheet to the front of your MP2.ASM file and give both to the same TA that approved your demonstration.

MP3.ASM

TITLE ECE291:MP3-LiteCycles - Your Name - Date

COMMENT % TRON LiteCycle Game with AI players.

          ECE291: Machine Problem 3
          Prof. John W. Lockwood
          Guest Author: Josh Scheid
          University of Illinois
          Dept. of Electrical & Computer Engineering
          Fall 1998
          
          Ver. 1.0
        %

;====== Constants =========================================================

INCLUDE mp3const.asm    ; MP3 constants file

;====== Externals =========================================================

; -- LIB291 Routines (Free) ---
extrn binasc:near, dspmsg:near
extrn rsave:near, rrest:near
extrn mp3xit:near               ; Exit program with a call to this procedure

; -- LIBMP3 Routines (Replace these with your own code) ---

extrn DrawScreen:near           ; display initial game grid on screen
extrn ResetGrid:near            ; initialize game grid
extrn DrawCycles:near           ; place cycles at new position and
                                ; check for collisions
extrn SetPlayerPos:near         ; determine player starting positions
extrn SetGameSpeed:near         ; determine new game speed
extrn InstTimer:near            ; install 'MyTimerHandler in place of default
                                ; handler and speed up timer rate
extrn DeInstTimer:near          ; deinstall 'MyTimerHandler'; reinstall
                                ; default handler and restore normal timer rate
extrn MyTimerHandler:near       ; handle timer interrupt
extrn InstKey:near              ; install 'MyKeyHandler' in place of default
extrn DeInstKey:near            ; deinstall 'MyKeyHandler'; reinstall default
extrn MyKeyHandler:near         ; handle keyboard interrupt

extrn GameMain:near             ; executes game loop and inner round loop

extrn P1Control:near            ; get next direction that player one will go
extrn P2Control:near            ; get next direction that player two will go

;====== SECTION 3: Define stack segment ===================================
stkseg  segment stack                   ; *** STACK SEGMENT ***
        db      64 dup ('STACK   ')     ; 64*8 = 512 Bytes of Stack
stkseg  ends

;====== SECTION 4: Define code segment ====================================
cseg    segment public  'CODE'    ; *** CODE SEGMENT ***
        assume  cs:cseg, ds:cseg, ss:stkseg, es:nothing

;====== SECTION 5: Variables ==============================================
PUBLIC StartMsg, CrashedMsg, WonRoundMsg, CrashedMsg, WonRoundMsg, AndMsg
PUBLIC BothCrashedMsg, CollidedMsg, SpaceMsg, Blank8Msg, RoundInfoMsg
PUBLIC grid, p1X, p1Y, p2X, p2Y 
PUBLIC playerPosState, p1Score, p2Score, p1Name, p2Name, escPressed, spcPressed      
PUBLIC p1KeyDir, p2KeyDir, p1Dir, p2Dir, round, pbuf 
PUBLIC oldTimerV, oldKeyV, timerCount, gameSpeed      

StartMsg        db CR,LF
  db '----------------------- MP3: LiteCycles ----------------------',CR,LF
  db CR,LF
  db 'Controls:  Player 1 (blue)    Player 2 (red)                 ',CR,LF
  db CR,LF
  db '   UP         W               8 (numpad)                  ',CR,LF
  db '   DOWN       S               2 (numpad)                  ',CR,LF
  db '   LEFT       A               4 (numpad)                  ',CR,LF
  db '   RIGHT      D               6 (numpad)                  ',CR,LF
  db CR,LF
  db 'Press the escape key  at any time to end the game.      ',CR,LF
  db CR,LF
  db 'Press the space bar now to begin!!!                          ',CR,LF,'$'

CrashedMsg      db ' crashed!','$'
WonRoundMsg     db ' won round ','$'
AndMsg          db ' and ','$'
BothCrashedMsg  db ' both crashed!','$'
CollidedMsg     db ' collided!','$'
SpaceMsg        db '(press the space bar to start next round)','$'
Blank8Msg       db '        ','$'

RoundInfoMsg    db      '    Round:','$'

grid            db      (GRIDSIZE_X * GRIDSIZE_Y) dup(?)
                        ;allocates memory for game grid

p1X             db      ?      ;player 1 X coord
p1Y             db      ?      ;         Y coord
p2X             db      ?      ;player 2 X coord
p2Y             db      ?      ;         Y coord

playerPosState  db      0       ;player position state

p1Score         dw      0       ;number of rounds that player 1 has won
p2Score         dw      0       ;number of rounds that player 2 has won

; Eight-character strings for player names
p1Name     db      'Player1 ','$'
p2Name     db      'Player2 ','$'

escPressed      db      0       ;flag set if ESC key pressed
spcPressed      db      0       ;flag set if SPC key pressed

; for controlling players through kbd
p1KeyDir        db      UP      ;set by MyKeyHandler
p2KeyDir        db      UP

p1Dir           db      UP      ;direction specified by P1Control
p2Dir           db      UP      ;direction specified by P2Control

round           dw      1       ;current round of game play

pbuf            db      7 dup (?) ;buffer for BINASC

oldTimerV       dd      ?       ;far pointer to default 08h
                                ;  interrupt function
oldKeyV         dd      ?       ;far pointer to default key
                                ;  interrupt function                                
timerCount      db      0       ;counter (to be incremented every 1/72 sec) 

gameSpeed       db      24      ;value that TimerCount should reach before
                                ;advancing game state
                                ;initial speed should be 1/3 sec. (24/72)                                
                                   
;====== Procedures ========================================================


; Your Subroutines go here !
; ---- ----------- -- ----


;====== Main procedure ====================================================

MAIN    PROC    FAR

        MOV     AX, CSEG
        MOV     DS, AX

        ; Put display into 80x50 text mode
        MOV     AX, 1202h               ; Sets to 400 line scan mode
        MOV     BL, 30h
        int     10h
        MOV     AX, 3                   ; Sets to 8x8 font
        INT     10h
        MOV     AX, 1112h               ; Enter text mode
        MOV     BL, 0
        INT     10h
        
        CALL    GameMain                ; Where all the action happens!
        
        CALL    MP3XIT                  ; Exit to DOS

MAIN    ENDP

CSEG    ENDS
        END     MAIN

MP3CONST.ASM

TITLE ECE291:MP3-Constants

COMMENT % TRON LiteCycle Game Constant Declarations
        %
        
;====== Constants =========================================================

;ASCII values for common characters
BEEP    EQU 7
CR      EQU 13
LF      EQU 10
ESCKEY  EQU 27
SPACE   EQU 32

;Player 1 keyboard control scan codes (not ASCII)
P1_U    EQU 17  ;'W'
P1_D    EQU 31  ;'S'
P1_L    EQU 30  ;'A'
P1_R    EQU 32  ;'D'

;Player 2 keyboard control scan codes (not ASCII)
P2_U    EQU 72  ;'8' on num. pad
P2_D    EQU 80  ;'2' "
P2_L    EQU 75  ;'4' "
P2_R    EQU 77  ;'6' "

;Constant values for specifying player direction
;  (used in variables p1NextDir and p2NextDir)
UP      EQU 0
DOWN    EQU 1
LEFT    EQU 2
RIGHT   EQU 3

;Constant values for use in Grid array
GRIDSPACE       EQU     0       ; a point with no walls
P1WALL          EQU     1       ; a point with a wall made by player 1
P2WALL          EQU     2       ; a point with a wall made by player 2
GRIDWALL        EQU     3       ; a point along the outside grid wallkk

;Dimension definitions
SCREENSIZE_X    EQU 80  ;Size of dos screen in x direction
SCREENSIZE_Y    EQU 50  ;Size of dos screen in y direction
GRIDSIZE_X      EQU 80  ;Size of game grid in x direction
GRIDSIZE_Y      EQU 49  ;Size of game grid in y direction

TEXTATTR        EQU 02h ;TxtVid attribute byte for game text
                        ;Currently green on black
GRIDATTR        EQU 01h ;TxtVid attribute byte for game grid
                        ;Currently blue on black
CRASHATTR       EQU 0Eh ;TxtVid attribute byte for crash symbol
                        ;Currently yellow on black
P1ATTR          EQU 79h ;TxtVid attribute byte for player 1 cycle & walls
P2ATTR          EQU 74h ;TxtVid attribute byte for player 2 cycle & walls

CRASHSYMBOL     EQU 0Fh ;ASCII value of symbol to draw at crash site.
PLAYERSYMBOL    EQU 0DBh;ASCII value of symbol to draw for player wall.