Machine Problem 3: The Maze (Part I)

Introduction

Machine Problem (MP3) is the first part of three machine problems. For MP3, you will implement a program which uses the system I/O to read a file describing the maze layout. You will then process that file to record the location of walls, hallways, starting position, and the ending position to system memory. Once the map is in memory, you will then process the map to mark the location of each decision point in the maze. Lastly, you will render a top-down view of the maze onto a color video graphics screen. A screen-dump of the program is shown below:

In MP4, you will implement a function to advance the mouse around the maze. You will then add 'Turbo' and 'Auto-Advance' features that automatically forward the mouse through hallways and around turns. You will finally implement a Depth First Search (DFS) algorithm to automatically guide the mouse out of the maze.

Lastly, in MP5, you will implement a "mouse eye-view" of the maze-- i.e., render a three dimensional view of the maze that the mouse would see while standing inside the maze looking directly down a hallway.

Problem Description

Internally, our program will represent the maze as a byte array of 80 (columns) * 23 (rows) = 1840 (bytes) called _MAZE. The size of the maze is defined as a constant called MAZESIZE. The array is stored in left-to-right, top-to-bottom order -- i.e., offset zero of _MAZE holds the top-left byte of the maze and offset MAZESIZE-1 holds the bottom-right element of _MAZE. Each byte defines a hallway, a wall, an endpoint, or a decision point. A decision point is a location in the maze where the mouse must decide which way to travel (i.e., the hallway branches). You will compute the location of decisions points just after the maze is read from the file.

To view the maze, the VGA adapter is used in with text-mode graphics. In this mode, each character on the screen is represented by two bytes -- an attribute byte and the ASCII character. The attribute byte determines the background color, the foreground color, intensity, and a flag to determine if the character should be blinking. Details of programming the VGA adapter were described in lecture and appear in the textbook.

The location of the mouse is determined by a variable called _POS. _POS is a word-sized (16-bit) integer defined as an offset into _MAZE. For example, if the mouse is at row 5, column 7 of the maze, _POS would equal 80*5+7. The mouse can move NORTH, EAST, SOUTH, or WEST. North is defined pointing towards the top of the screen. The mouse is represented on the screen as an arrow that points in the current direction.

Operation of MAZE

There are four modes of operation to this program: Manual, Turbo, AutoAdvance, and AutoSolve. Modes can be selected by pressing the 'M' key, followed by a number (0 to 3). In manual mode (M0), pressing the arrows keys will advance you by one position. In turbo mode (M1), the mouse will run down a hallway until hitting a wall. In AutoAdvance mode (M2), the mouse will traverse down a hallway until hitting a decision point. In AutoSolve mode (M3), the mouse will find the solution to the maze automatically. The mode of the program is displayed at the top-center of the screen.

In modes 1-3, the speed of the mouse can be adjusted. The (+) and (-) keys determine the delay rate. A larger rate slows the mouse, while a smaller makes the mouse move faster. The delay rate is displayed at the top-right of the screen.

You can exit the program by pressing 'Q' to quit.

Implementation

The ASM procedures that you will need to implement are described below. There are working library versions of each of these procedures in libmp3.lib. Unless otherwise noted, it is expected that that all subroutines will preserve the value of any register that they modify. The only exception is for registers that are used as outputs of procedures.

ReadMazeFile

• Purpose:
  • This subroutine reads a disk file to record the layout of the maze into the _MAZE array.
• Input
  • The Maze.DTA file.
• Output Variables:
  • All 80*23 bytes of the _MAZE array.
  • The word-size _POS variable should be set to store the start location of the mouse.
• Called by:
  • Main program
• Description:
  • For each ASCII character in the input file,
    store the corresponding CONSTANT (as defined at the top of mp3.asm)
    into the _MAZE array.
    • '#' [pound symbol] maps to WALL
    • ' ' [space] maps to HALL
    • 'E' indicates ENDPOS (The End Position)
  • Update _POS based on the location of the 'S'
  • C code for a simlar function is given below

    FILE* fp; int x, y, ch; int position=0; fp = fopen("Maze.Dta","r"); // Open Maze File for (y=0; y<MAZEROWS; y++) { for (x=0; ch!=EOF && x<MAZECOLS; x++) { ch = getc(fp); switch (ch) { case '#': *(&MAZE+position) = WALL; // Wall break; case ' ': *(&MAZE+position) = HALL; // Hallway break; case 'S': *(&MAZE+position) = HALL; // Starting Position POS = position; break; case 'E': *(&MAZE+position) = ENDPOS; break; default: *(&MAZE+position) = HALL; // Any other character (?) } position++; } while ((ch=getc(fp))!=10 && ch!=EOF); // Ignore any junk characters after 80th col } fclose(fp); }

• Notes
  • Use MSDOS Interrupt service routines to to open, read, and close the file.
  • If an error occurs while opening or reading the file, print a meaningful error message.
  • Details of MS-DOS calls appear in Chapter 13 of the Art of Assembly book.
  • Note that the _MAZE array holds constants, not ASCII codes, to represent the maze.
  • Note that Carriage return and line feeds appear the end of each line of the text input file. It is safe to ignore all ASCII 13 and ASCII 10 values.
  • Avoid overflowing the _MAZE buffer. This will occur if you read more than 80*23 characters into the _MAZE array.

MarkDecisionPoints

• Purpose:
  • Mark all locations in the _MAZE where hallways join.
• Input/Output Variable:
  • _MAZE array
• Called By:
  • Main program
• Description:
  • For each location in the _MAZE array (except the outer walls), determine if the mouse will need to make a decision.
  • Look at the type of character above, below, to the left, and to the right of each position in _MAZE. If less than two of these positions contain a WALL, then this location must be a decision point. Write the DECPOS constant into the _MAZE array to indicate that the location is a decision point.
  • C-code for the function is show below

    MarkDecisionPoints() { int x, y, wallctr, position; for (y=1; y<(MAZEROWS-1); y++) for (x=1; x<(MAZECOLS-1); x++) { position=x+MAZECOLS*y; if (*(&_MAZE+position) == HALL) { wallctr=0; if (*(&_MAZE+position+1)==WALL) wallctr++; if (*(&_MAZE+position-1)==WALL) wallctr++; if (*(&_MAZE+position+MAZECOLS)==WALL) wallctr++; if (*(&_MAZE+position-MAZECOLS)==WALL) wallctr++; if (wallctr<2) *(&MAZE+position) = DECPOS; } } }

ShowMaze

• Purpose: Draw the maze on the screen. and indicate the initial location of the mouse using the mouse.
• Variables: Both _MAZE, _POS and _DIR are read but not modified
• Inputs: ES points to the segment address of the video display memory.
• Useful Constants: MAZESIZE, HALL, WALL, DECPOS, ENDPOS, HALLCH, WALLCH, DECCH, and ENDCH.
• Called by: _ShowMaze
• Registers: All preserved

• Description:

  The maze can be drawn on the screen as follows: For each byte of the maze, this routine should write a word to the video buffer.

  For your convenience, a number of constants have been defined in maze.def. MAZESIZE defines the size of the maze (in bytes). This constant is equal to 80 (columns) * 23 (rows) = 1840 (bytes). For each element in the maze, this routine will draw an element on the screen.

  Constants are also used to define the values of _MAZE elements and their Attribute:Character values used on the screen. A table lookup is an efficient method to map the byte-value of _MAZE[index] to a Attribute:Character value used by the video buffer. The mapping function is summarized below.

  _MAZE Value (byte)	Attribute:Character (word)	Description
  HALL	HALLCH	Black background
  WALL	WALLCH	Green, Solid Box
  DECPOS	DECCH	Decision Position - Blue crosshair (+)
  VISPOS	VISCH	Visited Position - Green crosshair (+)
  FINPOS	FINSH	Finished Position - Red crosshair (+)
  ENDPOS	ENDCH	Yellow End-of-maze Marker (E)

  After drawing the maze, the routine also needs to draw the location of the mouse (Red smile character). The variable _POS holds the initial position (byte offset into the maze).

  The constants M{N,E,S,W}CH are the attribute:character value for the mouse pointing in different directions.

At the bottom of the screen, there is static text with directions that should be displayed.

ShowMode

• Purpose: Display the current mode and rate at the top of the screen and the instructions at the bottom of the screen.
• Variables: Both mazemode and mazedelay are read but not modified
• Inputs: ES points to the segment address of the video display memory.
• Called by: _ShowMaze when the program begins and by _MazeManual when the user changes mazemode or mazedelay.
• Registers: All preserved
• Description:

  At the top of the screen, there are two boxes that display the mode of the game and the delay value.

  Mazemode indicates the mode of the game. Its value ranges from 0 to 3. For each of these values, a text message should be printed to indicate the mode. This message should be printed at the top, center of the screen using yellow text on a blue background. The mappings between mazemode and output values are as follows:

  MazeMode	Text String	Description
  0	'MANUAL'	Manual Mode
  1	'TURBO'	Turbo Mode
  2	'AUTOADV'	Auto-Advance
  3	'AUTOSLV'	Auto-Solve

  Mazedelay indicates the delay between movements. Its value ranges from 0 to 255. At the top, right of the screen, the value should be printed using the same text attributes as used for the mode message.

UpdateTextScreen

• Purpose: Draw mouse at new position on the screen after an advance.
• Inputs:
  • SI: Original Position of Mouse
  • DI: New position of Mouse
  • AL: Direction of the mouse (0..3)
• Outputs: Writes only to screen
• Description:

  After advancing by a position, it is necessary to update the screen. This routine provides an efficient alternative to redrawing the entire screen. The mouse should be drawn at the new position given by DI. The mouse should be removed from the old position given by SI. To remove the mouse, you will need to access _MAZE to determine what element should be drawn on the screen. Possible values of maze include: WALL, ENDPOS, HALL, DECPOS, VISPOS, and FINPOS. The mappings from characters in _MAZE to attribute:character elements for the screen is the same as were used for ShowMaze.

Points

• ReadMazeFile: 10 pts
• MarkDecisionPoints: 10 pts
• ShowMaze: 10 pts
• ShowMode: 10 pts
• UpdateTextScreen: 10 pts

Starting Files

• You will begin MP3 with the following files:
  • mp3.exe: A fully functional executable program using library routines
  • maze.dta: The maze definition file.
  • mp3.asm: A starting point for the program. You are given the routines for reading and processing keyboard input, calling the other functions, and delaying movement.
  • libmp3.lib: Binary versions of the routines that you need to implement.
  • lib306.lib: The standard ECE306 library routines. (you can always use these routines freely)
  • build.bat: A short batch program which assembles and links your program
  • clean.bat: A short batch program which removes temporary files
• These files can be download as mp3.zip

MP3 Code Assignment