Machine Problem 3: The "15-Puzzle"

About this Machine Problem

How the Puzzle Works

Although we know that it is the hole that is moving, the user sees the tile sliding into the place previously occupied by the hole.  MoveHole accomplishes this by repeated calls to the DrawTile subroutine.  DrawTile simply draws the specified tile at the specified location.  The "animated" effect is achieved by repeatedly drawing the tile, each time moving it over by one character until it reaches its destination. Calling the Delay subroutine each time the tile is drawn slows the animation down.  Delay simply burns clock cycles so that the animation appears at human-detectable speed.  Without some sort of delay, the animation would be instantaneous to the human eye.

The state of the game board is stored in the Board variable.  This is simply an array of bytes indicating which tiles are in each of the 16 possible positions (numbered 0...15).  The hole is represented as tile 0.  The variable HolePtr always contains the position of the hole.  In addition, the Moves variable always contains the number of moves the user has made. 

The mouse control is implemented in the MouseControl subroutine.  Using the mouse as an input device is straightforward, and the details are contained in the lab manual.  MouseControl returns a value indicating which tile or button was clicked.  The Main routine (given) takes this value and decides what action to take.  If a tile is clicked, Main calls the CheckMove routine, which checks if the click was valid, and if so, calls MoveHole to effect the desired move.  Note that the user should be able to click on any tile in line with the hole.  In figure 2 (farthest to right), clicking on the 3 tile should cause the 11, 7, and 3 tiles to move downward.  The full details of these subroutines are given below.

The Autosolve "Algorithm"

To solve the puzzle, the AutoSolve subroutine simply pops the moves off of the stack and calls MoveHole. The Shuffle routine resets the puzzle and then moves the hole in random directions.  The number of times the hole is moved is specified by ShuffAmount.  Your Shuffle routine should take care not to move the hole in one direction and then follow that by moving the hole right back to where it started again.  That sort of behavior is not very impressive and it is annoying to watch. 

The randomness is achieved by generating random numbers with the Random routine.  The method for generating random numbers is outlined below.  Each time Shuffle moves the hole, the opposite move is pushed onto the stack for later retrieval by the AutoSolve routine.  In this manner, the puzzle can solve itself after being shuffled and then played with.  Be careful when using the stack to store moves.  You will be using the same stack that the CPU uses to store return addresses for subroutine calls.  Review your lecture notes on stack usage.

A Few Other Things

• The Reset routine will restore the board to its original, in-order configuration.  Reset will also pop all existing moves off of the stack. 
• DrawBoard is the routine that will draw all of the static elements of the Graphical User Interface.  Buttons, title bars, borders, and backgrounds are all "static" elements of the display.  These do not change and generally only need to be drawn once. DrawBoard also draws the current arrangement of tiles, specified in the Board array.  Your puzzle game will display the current number of moves the user has made.  It will also display the current setting of the DelayC constant. 
• UpdateScreen is the routine which draws these displays into place.  UpdateScreen is called any time the Moves variable or the DelayC variable changes.

Play With It

Efficiency

80x50 Text Mode Video

Data Structures

• A few variable have been defined in the program framework.  Use them.
• Moves: keeps track of the number of moves the used has made.  This must be updated every time MoveHole returns successful.
• MovesPushed: tracks the number of moves that have been pushed to the stack.  This is not necessarily equal to the Moves variable.
• HolePtr: always contains the current position of the hole.  A position is a number 0...15 representing the offset into the Board array where the hole is stored.
• Board: is an array of bytes representing the state of the board.  Each byte position contains a number 0...15 representing which tile is in that position.  For example, if the 6 tile is located in the lower left hand corner of the board, then Board[12]=6.  The hole is represented as tile number 0.
• RandVal: contains the seed used by the random number generator.
• DelayC: contains the delay constant.  This delay constant is a number 1...20.
• A few constants have also been defined.  Please see the given code (MP3.ASM) for documentation on these constants.  Use them.

Procedures

• This assignment has eleven procedures.  You will receive credit by replacing each of the eleven procedures listed below with your own code.
• Experiment with the given library code to gain a full understanding of how the program works.
• You program should exactly match the functionality of the library subroutines.  Do not violate the I/O specs given.
• All subroutines must preserve the value of any registers that they modify, not including registers used for function output.
• Library routines only call other Library Routines.  Keep this in mind when testing your code with the given library code.

MouseControl

• Purpose: To get user input via the mouse.
• Inputs: none
• Outputs: DX - returns values according to the following table:
 

Value	Description
TileClicked	returned if a tile on the board was clicked
ShuffleClk	returned if the Shuffle button was clicked
SolveClk	returned if the Solve button was clicked
SolveOnceClk	returned if the Solve Once button was clicked
DelayUpClk	returned if the Increase Delay button was clicked
DelayDownClk	returned if the Decrease Delay button was clicked
QuitClk	returned if the Quit button was clicked
ResetClk	returned it the Reset button was clicked

 
• AX: returns the position of the tile that was clicked, if a tile was clicked.
• Notes:
• The program will spend most of its time looping through this subroutine.  The subroutine does not return until a valid place on the screen has been clicked.
• Many comparisons will need to be made in this subroutine.  Use the provided constants to refer to return values or screen element locations.  See the given code for details.
• See the lab manual for details on how to use the mouse hardware.
• Calls: None
 

ResetBoard

• Purpose: to reset the board to its ordered configuration.  This routine will reset the Board array to the ordered configuration.  HolePtr will be reset.  This routine will also remove all moves currently residing on the stack.  This routine resets the Moves variable.  When ResetBoard is done, the user sees a reset screen.
• Inputs: the stack, Board, HolePtr, MovesPushed, Moves
• Outputs: the stack, Board, HolePtr, MovesPushed, Moves
• Calls: DrawBoard, UpdateScreen

Shuffle

• Purpose: to shuffle the board.  This routine moves the hole in random directions the number of times specified by the ShuffAmount constant.  The hole should never be moved in one direction and then moved right back again.  Your code must prevent this from happening.  Each time shuffle makes a valid move, the opposite move is pushed to the stack and MovesPushed is incremented.
• Inputs: the stack, MovesPushed, ShuffAmount
• Outputs: the stack, MovesPushed
• Calls: Random, MoveHole

MoveHole

• Purpose: to move the hole.  A hole is moved by sliding the corresponding tile in the proper direction.  The motion should be animated.  MoveHole checks to see if the move requested is valid, and returns an error code if an invalid move was attempted. This routine is responsible for correctly updating the Board and HolePtr variables. Board should be updated to reflect the actual arrangement of tiles, and HolePtr should be updated to point to the new Hole locations
• Inputs: HolePtr, Board
• SI = the direction the hole should be moved in

Value in SI	Direction of Hole Motion
0	Up
1	Right
2	Down
3	Left

 
• Outputs: Board, HolePtr
• DX = 0 if success, 1 if failure
• Notes:
• Can you use lookup tables to make this simple?
• This routine does not push moves to the stack.
• Calls: DrawTile

DrawBoard

• Purpose: Draw out all of the static elements of the display, as well as draw out all of the tiles.  This routine is called to redraw the entire screen, including the background, the buttons, the labels, and anything else you include in the user interface.
• Inputs: none
• Outputs: to screen
• Uses: none

UpdateScreen

• Purpose: Update the "Number of Moves" and the "Delay" displays on the screen.  This routine is called whenever Moves or Delayc is changed.  It draws the proper characters to the screen so the user can see the value of these variable.
• Inputs: Moves, DelayC
• Outputs: to screen
• Uses: none

Delay

• Purpose: Burns CPU cycles.  This routine loops through a meaningless loop DelayC*0AFFFh times.  Just sit there and loop.  That's all it needs to do.  Delay is called to give the program its animated quality.
• Inputs: DelayC
• Outputs: time
• Uses: none

Random

• Purpose: This routine generates and returns a pseudo-random number by multiplication and addition of large prime constants to a random number.
• Inputs: Randval memory variable
• Outputs: AX - Random number between 0 .. 2^16-1
• Notes: The random function is defined below
  R(1) = Randval
  R(i+1) = Randval = (K1 *R(i) + K2) % MaxValue 
  Where
• R(i) is the random value generated in the i-th call to the subroutine.
• Randval is a variable that holds the initial random value and is updated with the result after each call to Random.
• K1 and K2 are two large, prime-valued constants.
• MaxValue = 2^16-1 (0FFFFh)
Hints & Observations
• The first call to Random returns the original random number seed
• Perform multiplication and division using the 16-bit unsigned operations.
• Uses: None

AutoSolve

• Purpose: To solve the puzzle.  Autosolve solves the puzzle by popping a move from the stack and executing that move using MoveTile.  Moves is incremented for each pop. In addition, AutoSolve should only pop and execute one move off the stack if AX=0. If AX=1, Autosolve should pop and execute all moves off the stack.
• Inputs: stack, MovesPushed, Moves
  • AX = 0 - Autosolve only pops one move off the stack, 1 - Autosolve pops all moves off the stack and executes them.
• Outputs: a solved puzzle, Moves, MovesPushed, stack
• Uses: UpdateScreen, MoveHole

DrawTile

• Purpose: to draw a tile.  Draw tile will draw a tile at the specified location, with the specified number inside.  Tiles should be drawn with differing colors for visual appeal.
• Inputs:
• AL = # of tile being drawn (1...15)
• BX = Offset into text mode video memory of the upper left hand corner of the tile.
• Outputs: A tile is drawn to the screen
• Uses: None

CheckMove

• Purpose: to execute a user's move.  This routine takes as input the position of the board which the user clicked on.  It determines if a valid move is available, and executed that move using MoveHole.  When the hole is moved, this routine pushes the opposite move to the stack and updates Moves.
• Inputs: stack, HolePtr, Moves, MovesPushed.
• AX = the position of the board that was clicked.
• Outputs: stack, Moves, MovesPushed
• Uses: MoveHole, UpdateScreen
 

Scoring

MouseControl: 8 pts.
ResetBoard: 3 pts.
Shuffle: 5 pts.
MoveHole: 8 pts.
DrawBoard: 4 pts.
UpdateScreen: 4 pts.
Delay: 1pt.
Random: 3 pts.
AutoSolve: 3 pts.
DrawTile: 3 pts.
CheckMove: 8 pts.

 Preliminary Procedure

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

xcopy /s I:\ece291\mp3 F:\mp3
Alternatively, from home, you can download the same files as mp3.zip.
• As with previous MPs, run NMake to build an executable program using the given ECE291 library functions.
• As with previous MPs, 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 with previous MPs, 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!

Final Steps

1. Print a copy of the MP3 grading sheet.
2. Demonstrate 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. Handin in your program by running:

A:\Handin YourWindowsLogin
4. Print MP3.ASM

Staple the MP3 grading sheet to the front of your MP3.ASM file and give both to the same TA that approved your demonstration.

MP3.ASM (program framework)