Programming Exercise I: Showing a tic-tac-toe game

Programming Exercise I: Showing a Tic-Tac-Toe Game

Absolutely no copying others’ works

Development Requirements
When start developing the exercise, have to use:

MASM (Microsoft Macro Assembler) assembly language and
Microsoft Visual Studio to develop and test your exercise.

An online tic-tac-toe game is here.

Due Date^† and Submission Method
On or before Monday, October 19, 2026 and upload the source code (no documentation needed) to the Blackboard section:

COVID-19 Exams, Homeworks, & Programming Exercises ▶ Programming Exercise I

Use the template from Using MASM and replace the assembly code by . If the code does not work, a demonstration will be requested by the instructor.

^†Since related topics may not be covered completely by the due date, no penalty will be applied if submitted after the due date. However, you may lag behind if you are not able to submit it by then. In addition, the Exam I will cover the materials from the Programming Exercise I.

Objective
Design and implement an MASM assembly program, which displays a tic-tac-toe game. The purpose of this exercise is to get students ready for assembly programming and the second exercise, playing a tic-tac-toe game.

Requirements
The 3×3 tic-tac-toe game includes the following requirements:

(Printing user prompts: 10%) Print appropriate user prompts to guide users to interact with your system.
(Starting the game: 10%) Randomly pick either one of the two players, System or User, to start the game.
(Picking the piece: 10%) If the System starts the game, randomly pick either one of the two pieces, X or O. Otherwise, the User picks the piece manually.
(Taking turns: 10%) The two players take turns making moves.

(Displaying board: 10%) The board includes two parts: the game board (left) and the index (right) as follows:

        | |       1|2|3
       -----      -----
        | |       4|5|6
       -----      -----
        | |       7|8|9

(Next move: 10%) Continue with the next move after asking.
(The System’s next move: 10%) Randomly pick the next move, and print the move.
(Marking moves and displaying board: 10%) Mark the move by alternating between the pieces ‘X’ and ‘O’. For example, if the first move from the System is ‘5’, display the following:
```
  I (System) enter the next move: 5

        | |       1|2|3
       -----      -----
        |X|       4|5|6
       -----      -----
        | |       7|8|9
```
(Full board: 10%) When all cells on the board are filled, automatically start a new game.
(New game: 10%) Start a new game after asking.
Ignore the result (win/loss). The game ends when the user requests no new game.
No error checking is required; i.e., you may assume the input is always correct for that case.

Programming Hints
The four essential components of software are (i) algorithms, (ii) data structures, (iii) programming languages, and (iv) code, where algorithms are the most critical one. In addition, using appropriate data structures could save a great deal of coding work, especially for assembly coding. The following hints are from the instructor and you do not necessarily have to use them:

To represent the game board, a 3×3 grid:

        | |       1|2|3
       -----      -----
        | |       4|5|6
       -----      -----
        | |       7|8|9

the instructor uses the following string:

   board  BYTE  0Dh, 0Ah, "     | |       1|2|3"
          BYTE  0Dh, 0Ah, "    -----      -----"
          BYTE  0Dh, 0Ah, "     | |       4|5|6"
          BYTE  0Dh, 0Ah, "    -----      -----"
          BYTE  0Dh, 0Ah, "     | |       7|8|9", 0Dh, 0Ah, 0Dh, 0Ah, 0
  
   # (offset)    0    1    23456789012345678901

where the numbers are offsets (not assembly code) and the new line, “0Dh 0Ah”, is two bytes long. The offset of the (1-9) is found by using the following formula:

   offset = 6 + [(move-1)%3]×2 + [(move-1)÷3]×44

For example, if the move is 5, the offset is 6+[(5-1)%3]×2+[(5-1)÷3]×44=6+1×2+1×44=52. The following code then puts the marker ‘X’ at that location:

   mov  eax, offset           ; Load EAX with the offset.
   mov  board[eax], 'X'       ; Store the marker to the location, board+offset.

Assuming the game has just started, entering the move 5 will result in the following board state:

          | |       1|2|3            | |       1|2|3
         -----      -----           -----      -----
          | |       4|5|6     ⇒     |X|       4|5|6
         -----      -----           -----      -----
          | |       7|8|9            | |       7|8|9

Sample code of marking a game board is given below for your reference:

MarkBoard.asm

TITLE  Tic-Tac-Toe     (MarkBoard.asm)

COMMENT!
*
* This program shows how to mark the game board.
*
!

INCLUDE Irvine32.inc   ; Include Irvine32 macros and procedures

.data
  board   BYTE   0Dh, 0Ah, "     | |       1|2|3"
          BYTE   0Dh, 0Ah, "    -----      -----"
          BYTE   0Dh, 0Ah, "     | |       4|5|6"
          BYTE   0Dh, 0Ah, "    -----      -----"
          BYTE   0Dh, 0Ah, "     | |       7|8|9", 0Dh, 0Ah, 0Dh, 0Ah, 0
  
  prompt  BYTE   "Enter the next move (1..9): ", 0
  temp    DWORD  ?
  next    DWORD  ?
  const3  BYTE   3
  q       BYTE   ?
  r       BYTE   ?

.code
main PROC
  mov    edx, OFFSET board
  call   WriteString           ; Print the game board.
  mov    edx, OFFSET prompt
  call   WriteString

  ; Read the next move.
  call   ReadInt
  mov    next, eax             ; Save the move, next = eax.
  call   MarkBoard             ; Mark the game board.
  mov    edx, OFFSET board
  call   WriteString
  exit
main ENDP

;;
;; MarkBoard Procedure
;;
;;   offset = 6 + [(move-1)%3]×2 + [(move-1)÷3]×44
;;
  
MarkBoard  PROC
  pushad                       ; Save the registers.
  mov    eax, next
  dec    eax                   ; eax  = move - 1
  idiv   const3                ; eax  = (move-1) ÷ 3
  mov    q, al                 ; quotient:  al
  mov    r, ah                 ; remainder: ah
  movzx  eax, r                ; eax  = remainder: ah
  imul   eax, eax, 2           ; eax  = [(move-1)%3]×2
  add    eax, 6                ; eax  = 6 + [(move-1)%3]×2
  mov    temp, eax             ; temp = 6 + [(move-1)%3]×2

  movzx  eax, q                ; eax  = quotient:  al
  imul   eax, eax, 44          ; eax  = [(move-1)÷3]×44
  add    eax, temp             ; eax  = 6 + [(move-1)%3]×2 + [(move-1)÷3]×44
  mov    board[eax], 'X'       ; Mark the move.
  popad                        ; Pop the registers.
  ret
MarkBoard ENDP
END main

An execution example


     | |       1|2|3
    -----      -----
     | |       4|5|6
    -----      -----
     | |       7|8|9

Enter the next move (1..9):  5 

     | |       1|2|3
    -----      -----
     |X|       4|5|6
    -----      -----
     | |       7|8|9

^†The white italic text with a navy background color is entered by users.

Execution Examples
The following list shows some execution examples:

Examples of Exercise I Execution


Start Showing a Tic-Tac-Toe Game.

You (User) pick a piece: (X or O)   X 

     | |       1|2|3
    -----      -----
     | |       4|5|6
    -----      -----
     | |       7|8|9

You (User) enter the next move: (1..9)  5 

     | |       1|2|3
    -----      -----
     |X|       4|5|6
    -----      -----
     | |       7|8|9

Continue?: (Y or N)  Y 

I (System) enter the next move: 3

     | |O      1|2|3
    -----      -----
     |X|       4|5|6
    -----      -----
     | |       7|8|9

Continue?: (Y or N)  Y 

You (User) enter the next move: (1..9)  8 

     | |O      1|2|3
    -----      -----
     |X|       4|5|6
    -----      -----
     |X|       7|8|9

Continue?: (Y or N)  N 

New game?: (Y or N)  Y 


Start Showing a Tic-Tac-Toe Game.

I (System) make the move: 4

     | |       1|2|3
    -----      -----
    X| |       4|5|6
    -----      -----
     | |       7|8|9

Continue?: (Y or N)  Y 

You (User) enter the next move: (1..9)  9 

     | |       1|2|3
    -----      -----
    X| |       4|5|6
    -----      -----
     | |O      7|8|9

Continue?: (Y or N)  Y 

I (System) enter the next move: 7

     | |       1|2|3
    -----      -----
    X| |       4|5|6
    -----      -----
    X| |O      7|8|9

Continue?: (Y or N)  N 

New game?: (Y or N)  N 

C:\ASM-workspace\Ex1\Debug\Project.exe (process 41384) exited with code 0 (0x0).
Press any key to close this window . . .

Possible Instructions to Be Used
The following directives and instructions may be used in this exercise, but you are not limited to them. For instruction syntax, check MASM Instruction Reference.

No.	Directive	Description
1	`[name] BYTE initializer`	Defining byte
2	`[name] DWORD initializer`	Defining doubleword
3	`END [procid]`	Marks the last line of the program to be assembled.
4	`ENDP`	Marks the end of a procedure.
5	`.IF .ELSEIF .ELSE .ENDIF`	IF statement
6	`OFFSET n`	Returns the offset of a data label.
7	`label PROC`	Identifies the beginning of a procedure.
8	`PROC … USES`	Lists the names of all registers modified within a procedure.
9	`PROTO`	Creates a prototype for an existing procedure.
10	`PTR`	Override the declared size of an operand.
No.	Instruction	Description
1	`add r/m32, imm32`	Add: r/m32: a 32-bit register or a 32-bit memory operand imm32: a constant 32-bit value Check MASM General-purpose Registers Example: `add eax, temp`
2	`cmp r/m32, imm32`	Compare two operands: Example: `cmp eax, 10`
3	`dec r/m32`	Decrement by 1: Example: `dec eax`
4	`call rel32`	Call procedure: rel32: a 32-bit signed relative displacement Example: `call WriteString`
5	`idiv r/m32`	Signed divide: `EDX:EAX` ÷ r/m32, with result stored in `EAX` := Quotient, `EDX` := Remainder. Example: `idiv const3`
6	`imul r32, r/m32, imm32`	Signed multiply: doubleword register := r/m32 × immediate doubleword Example: `imul eax, eax, 2`
7	`je rel8`	Jump short if equal (`ZF`=1): rel8: an 8-bit relative offset Example: `je L1`
8	`jmp rel16`	Jump rel16: a 16-bit relative offset Example: `jmp L1`
9	`jne rel8`	Jump short if not equal (`ZF`=0) rel8: an 8-bit relative offset Example: `jne L1`
10	`loop rel8`	Loop according to `ECX` counter: Decrement count; jump short if count ≠ 0 Example: `loop L1`
11	`mov r32, imm32`	Move: Example: `mov edx, OFFSET board`
12	`movzx r32, r/m16`	Move with zero-extend: Example: `movzx eax, r`
13	`not r/m32`	One’s complement negation: Example: `not eax`
14	`popad`	Pop all general-purpose registers: Example: `popad`
15	`pushad`	Push all general-purpose registers: Example: `pushad`
16	`ret`	Return from procedure: Example: `ret`
17	`sub r/m32, imm32`	Subtract: Example: `sub eax, 10`

The following table lists some procedures provided by Irvine:

Procedure	Call args	Return args	Description	Example
`Crlf`	None	None	Writes a carriage return/linefeed sequence (,) to standard output.	`call Crlf`
`Randomize`	None	None	Re-seeds the random number generator with the current time in hundredths of seconds.	`call Randomize`
`RandomRange`	`EAX` = n, the range	`EAX` = random (0 to n-1)	Generates an unsigned pseudo-random 32-bit integer in the range of 0 through (n-1).	Get a random number from 1 to 100: `ranNum DWORD ? mov eax,100 call RandomRange inc eax mov ranNum,eax`
`ReadChar`	None	`AL` = ASCII code	Reads a single character from standard input and returns the character in the `AL` register. The character is not echoed on the screen. Waits for the character if none is currently in the input buffer.	`charIn BYTE ? call ReadChar mov charIn, al`
`WriteChar`	`AL` = the character to write	None	Writes a single character to standard output.	`mov al, '$' call WriteChar`
`WriteString`	`EDX` = points to string	None	Writes a null-terminated string to standard output.	`prompt BYTE "Enter your name: ", 0 mov edx, OFFSET prompt call WriteString`

Evaluations
The following features will be considered when grading:

Specifications:
- The instructor has given the exercise specifications as detailed as possible. If you are confused about the specifications, you should ask in advance. Study the specifications very carefully. No excuses for misunderstanding or missing parts of the specifications after grading.
- The specifications may not be possible to cover every detail. You are free to implement the issues not mentioned in the specifications, but the implementations should make sense. Implemented functions lacking common sense may cause the instructor to grade your exercise incorrectly, and thus lower your grade.
- The exercise must meet the specifications. However, exercises with functions exceeding the specifications will not receive extra credits.

Grading:
- This exercise will be graded after the source code is submitted. Students take full responsibility if the code does not work.
- The Visual Studio will be used to grade exercises. Make sure your exercise works on VS.
- Before submitting the exercise, test it comprehensively. Absolutely no extra points will be granted after grading.
- A set of test data will be used to test the exercises of all students. The grades are primarily based on the results of testing. Other factors such as performance, programming styles, algorithms, and data structures will be only considered minimally.
- Unless specified, no error checking is required.
- The total weight of exercises is 25% of the final grade, 10% for this exercise and 15% for Exercise II (playing a tic-tac-toe game).
- Though Exercise II covers parts of Exercise I, you still have to submit both exercises separately. One exercise will not be counted twice.
- The instructor will inform you the exercise evaluations by emails after grading.

Comments:
- According to a study, students in programming courses learn much more by building medium/large-scale exercises instead of many small-scale test programs like these, which give fragmented knowledge contrary to solid understanding of the system.
- Time management is critical for software development. If you are not able to complete the exercises, show whatever you have accomplished, so the instructor can give partial credit to your exercises.