Tic Tac Toe

Repository

I developed this Tic Tac Toe implementation in x86 Assembly to gain a deeper understanding of low-level CPU operations and memory management. The project evolved from a 16-bit DOS application using BIOS interrupts to a 64-bit Linux version leveraging modern system calls. Through this process, I mastered register-level logic, stack manipulation, and the intricacies of direct hardware interaction.

Dual-Architecture Implementation

The project features two distinct versions: a 16-bit version designed for the emu8086 emulator and a modern 64-bit version for Linux. The DOS version relies on INT 10h for video control and INT 21h for standard I/O, while the Linux version uses SYSCALL 1 (sys_write) and 0 (sys_read). This transition allowed me to compare legacy real-mode programming with contemporary protected-mode execution.

1INIT:         ; init all variables
2    MOV PLAYER, 50 ; Set to '2' (ASCII 50)
3    MOV MOVES, 0
4    MOV DONE, 0
5    MOV DR, 0
6
7    ; Initializing board cells with ASCII numbers 1-9
8    MOV C1, 49
9    MOV C2, 50
10    MOV C3, 51
11    MOV C4, 52
12    MOV C5, 53
13    MOV C6, 54
14    MOV C7, 55
15    MOV C8, 56
16    MOV C9, 57
17
18    JMP PLRCHANGE

Win Detection Logic

The CHECK method is the heart of the game logic, evaluating the board state after every turn. It rigorously compares memory values across eight possible winning combinations (rows, columns, and diagonals). By using conditional jumps like JNZ (Jump if Not Zero), the program efficiently branches through validation steps, setting the DONE flag to 1 if a victory is detected.

1CHECK:                  ; 8 possible combinations
2    CHECK1:             ; checking row 1
3        MOV AL, C1
4        MOV BL, C2
5        MOV CL, C3
6
7        CMP AL, BL
8        JNZ CHECK2
9
10        CMP BL, CL
11        JNZ CHECK2
12
13        MOV DONE, 1
14        JMP BOARD
15
16    CHECK2:             ; checking row 2
17        MOV AL, C4
18        MOV BL, C5
19        MOV CL, C6
20
21        CMP AL, BL
22        JNZ CHECK3
23
24        CMP BL, CL
25        JNZ CHECK3
26
27        MOV DONE, 1
28        JMP BOARD

Terminal UI and Input Validation

To create a seamless user experience, I implemented custom rendering and validation routines. In the 64-bit version, I used ANSI escape sequences to clear the screen and position the cursor, mimicking a modern terminal UI. The TAKEN method ensures game integrity by preventing players from overwriting occupied cells, providing instant visual feedback before re-prompting for input.

1TAKEN:
2    DEC MOVES           ; Adjust move counter
3    ; Set cursor position via BIOS interrupt
4    MOV AH, 4
5    MOV DH, 16
6    MOV DL, 20
7    INT 10h
8
9    LEA DX, TKN         ; Display "Cell already taken"
10    MOV AH, 9
11    INT 21h
12
13    MOV AH, 7
14    INT 21h             ; Wait for keypress
15
16    ; Reset cursor for re-input
17    MOV AH, 2
18    MOV DH, 16
19    MOV DL, 20
20    INT 10h
21
22    LEA DX, EMP         ; Overwrite error message with empty line
23    MOV AH, 9
24    INT 21h
25
26    JMP INPUT

Low-Level Challenges

One of the most significant challenges was handling raw terminal mode in Linux to capture single-character inputs without requiring the user to press Enter. This required manipulating the termios structure via ioctl system calls. Learning to manage the stack frame manually and understanding how 32-bit and 64-bit addresses are calculated in real-time was a pivotal moment in my development as a programmer.

Video Demonstration

External Media Required

This video requires third-party cookies from YouTube to be displayed. Accepting will enable all external media across the site.