ZX Spectrum Assembly, Tic-Tac-Toe – 0x04 Options and end of game
In this chapter of ZX Spectrum Assembly, we will implement the different options of the game and the end of the game; as we left off in the previous chapter, the game continues indefinitely. The options will be selected from a start menu.
Translation by Felipe Monge Corbalán
Table of contents
Colours
In var.asm we will add the following constants for the colours to avoid having to use numbers and to make it easier to change the colours during the game.
INK0: equ $00
INK1: equ $01
INK2: equ $02
INK3: equ $03
INK4: equ $04
INK5: equ $05
INK6: equ $06
INK7: equ $07
INK0: equ $00
INK1: equ $01
INK2: equ $02
INK3: equ $03
INK4: equ $04
INK5: equ $05
INK6: equ $06
INK7: equ $07As an exercise, go through the title and text declarations and where you see $10, change the number that follows it to the corresponding INK tag.
In the same way, look for INK calls in the rest of the files, and instead of loading the ink number in A, load the corresponding INK tag.
Menu
Some of the start menu texts are already defined in ar.asm: the TitleEspamatica tag and from TitleOptionStart to TitleOptionTime.
We will delete all these lines as we are going to reimplement it, adding colours and positions, and it will look like this:
Title3InStripe: db $10, INK2, $13, $01, $16, $02, $09
defm "Three in a row"
TitleOptionStart: db $10, INK1, $13, $01, $16, $08, $08, "0. "
db $10, INK5
defm "Start"
TitleOptionPlayer: db $10, INK7, $13, $01, $16, $0a, $08, "1. "
db $10, INK6
defm "Players"
TitleOptionPoint: db $10, INK7, $16, $0c, $08, "2. ", $10, INK6
defm "Points"
TitleOptionTime: db $10, INK7, $16, $0e, $08, "3. ", $10, INK6
defm "Time"
TitleEspamatica: db $16, $14, $08
db $10, INK2, "E", $10, INK6, "s"
db $10, INK4, "p", $10, INK5, "a"
db $10, INK2, "m", $10, INK6, "a"
db $10, INK4, "t", $10, INK5, "i"
db $10, INK2, "c", $10, INK6, "a"
db $10, INK7, " 2019", $ffNow we have the definition of the start menu almost ready to paint, we just need a routine to paint the values of the options. We implement this in screen.asm.
; -------------------------------------------------------------------
; Paint the values of the options.
;
; Alters the value of the AF, BC and HL registers.
; -------------------------------------------------------------------
PrintOptions:
ld a, INK4 ; A = green ink
call INK ; Change ink
ld b, INI_TOP-$0a ; B = coord Y
ld c, INI_LEFT-$15 ; C = coord X
call AT ; Positions cursor
ld hl, MaxPlayers ; HL = value players
call PrintBCD ; Paints it
ld b, INI_TOP-$0c ; B = coord Y
call AT ; Positions cursor
ld hl, MaxPoints ; HL = points value
call PrintBCD ; Paints it
ld b, INI_TOP-$0e ; B = coord Y
call AT ; Positions cursor
ld hl, MaxSeconds ; HL = time value
jp PrintBCD ; Paints it and exitsPrintOptions paints the values of the options in green. It positions the cursor and paints each of the values.
Let’s see what the start menu looks like. We locate Main in main.asm, and under CALL OPENCHAN we add these lines:
Menu:
di ; Deactivate interruptions
im $01 ; Interruptions = mode 1
ei ; Activates interruptionsWe have added a label for the menu part, disabled the interrupts to switch to mode one and enabled them again. We will then use the interrupts in mode two, so these lines are needed here.
At the bottom we find CALL CLS and then add the following lines:
ld hl, Title3InStripe ; HL = address three-inline
call PrintString ; Paints the menu
menu_op:
call PrintOptions ; Paint the options
jr menu_op ; Menu loopWe draw the start screen and the values of the options. We remain in an infinite loop as this is where we will implement the menu logic.
With the menu definition and a few lines we have painted it, but we still need to make it work.
Compile it, load it into the emulator and see how it looks.
Before implementing the menu logic, we will implement a routine in game.asm that uses the ROM to read the keyboard and return the ASCII code of the last key pressed. This routine will be used for the menu options and for the player name query.
; -------------------------------------------------------------------
; Wait for a key to be pressed and return its Ascii code.
;
; Output: A -> Ascii code of the key.
;
; Alters the value of the AF and HL registers.
; -------------------------------------------------------------------
WaitKeyAlpha:
ld hl, FLAGS_KEY ; HL = address flag keyboard
set $03, (hl) ; Input mode L
; Loop until a key is obtained.
WaitKeyAlpha_loop:
bit $05, (hl) ; Key pressed?
jr z, WaitKeyAlpha_loop ; Not pressed, loop
res $05, (hl) ; Bit set to 0 for future inspections
; Gets the Ascii of the key pressed.
; Valid Ascii 12 ($0C), 13 ($0D) and from 32 ($20) to 127 ($7F)
; If the key pressed is Space, load ' ' in A
WaitKeyAlpha_loadKey:
ld hl, LAST_KEY ; HL = last key pressed address
ld a, (hl) ; A = last key pressed
cp $80 ; Ascii > 127?
jr nc, WaitKeyAlpha ; Yes, invalid key, loop
cp KEYDEL ; Pushed Delete?
ret z ; Yes, exit
cp KEYENT ; Press Enter?
ret z ; Yes, exit
cp KEYSPC ; Powered Space?
jr c, WaitKeyAlpha ; Ascii < space, invalid, loop
ret ; ExitsWaitKeyAlpha waits until a key is pressed that is valid for us, that is: delete, enter or an ASCII code between thirty-two and one hundred and twenty-seven. When a valid key is pressed, it returns the ASCII code for that key in A.
We implement the menu routine in main.asm, just after CALL PrintOptions, and the final aspect is this:
menu_op:
call PrintOptions ; Paint the options
call WaitKeyAlpha ; Wait for keypress
cp KEY0 ; Pushed 0?
jr z, Init ; Yes, start game
menu_Players:
cp KEY1 ; Pushed 1?
jr nz, menu_Points ; No, skip
ld a, (MaxPlayers) ; A = players
xor $03 ; Alternates between 1 and 2
ld (MaxPlayers), a ; Update in memory
jr menu_op ; Loop
menu_Points:
cp KEY2 ; Pushed 2?
jr nz, menu_Time ; No, skip
ld a, (MaxPoints) ; A = points
inc a ; A += 1
cp $06 ; A = 6?
jr nz, menu_PointsDo ; No, skip
ld a, $01 ; A = 1
menu_PointsDo:
ld (MaxPoints), a ; Update in memory
add a, '0' ; A = value ascii
ld (info_points), a ; Update in memory
cp '1' ; Points 1?
jr z, menu_Points1 ; Yes, skip
ld a, 's' ; Plural
jr menu_PointsEnd ; Jump
menu_Points1:
ld a, ' ' ; Singular
menu_PointsEnd:
ld (info_gt1), a ; Update in memory
jr menu_op ; Loop
menu_Time:
cp KEY3 ; Pushed 3?
jr nz, menu_op ; No, loop
ld a, (MaxSeconds) ; A = seconds
add a, $05 ; A += 5
daa ; Decimal setting
cp $35 ; A = 35 BCD?
jr nz, menu_TimeDo ; No, skip
ld a, $05 ; A = 5
menu_TimeDo:
ld (MaxSeconds), a ; Refreshes in memory
jr menu_op ; LoopAfter calling the routine that checks if a valid key has been pressed, it evaluates if it is any key between zero and three, and depending on which it is, it acts in one way or another. Note that it only does the decimal adjustment when incrementing seconds; it is the only option whose value is greater than nine.
We compile, load the emulator and see the results. Everything seems to go well until we press zero, start the game and the menu remains.
To fix this, we add the following line below the Init tag:
call CLS ; Clear screen
Start of game
When the game starts, the first thing we will do is ask for the names of the players. First, we add another constant to rom.asm; this address contains the coordinates of the cursor.
; Cursor position on screen 2.
; If loaded at BC -> B = Y, C = X.
CURSOR: equ $5c88We implement the routine responsible for retrieving the names of the players in game.asm. Although we won’t go through it instruction by instruction, due to the size of the routine we will implement it in blocks.
GetPlayersName:
ld hl, Name_p1
ld de, Name_p1+$01
ld bc, LENNAME*2-$01
ld (hl), " "
ldir We have cleared the names of the players.
ld e, $01
getPlayersName_loop:
ld a, INK4
call INK
ld b, INI_TOP-$0f
ld c, INI_LEFT-$01
call CLL
call AT
ld hl, TitlePlayerNumber
ld (hl), "1"
ld a, $01
cp e
jr z, getPlayersName_cont
ld (hl), "2"
getPlayersName_cont:
ld hl, TitlePlayerName
call PrintString
ld hl, Name_p1
ld a, $01
cp e
jr z, getPlayersName_cont2
ld hl, Name_p2We make a loop of at most two iterations, one per player, change the colour, delete the line where the names are requested, position the cursor, prepare the title depending on the player, and point HL to the player’s name.
getPlayersName_cont2:
ld d, $00
ld a, INK3
call INK
call getPlayersName_getName
ld a, (MaxPlayers)
cp $02
jr nz, getPlayersName_onlyOne
inc e
cp e
jr z, getPlayersName_loop
retWe use D to control the length of the name, change the ink and ask for the player’s name. We get the players, see if there are two players, and if not, default the name to two. If there are two players, we check if the name entered is the name of player two, and if not, we loop to ask for it.
getPlayersName_onlyOne:
ld hl, Name_p2Default
ld de, Name_p2
ld bc, LENNAME
ldir
retIf it is a single player, give the second player the default name.
getPlayersName_getName:
push hl
call WaitKeyAlpha
pop hl
cp KEYDEL
jr z, getPlayersName_delete
cp KEYENT
jr z, getPlayersName_enter
push de
ld e, a
ld a, LENNAME
cp d
ld a, e
pop de
jr z, getPlayersName_getName
ld (hl), a
inc hl
rst $10
inc d
jr getPlayersName_getNameWe wait for a valid key to be pressed, check if it is Delete and if so, we jump to its operation. We check if it is enter and if it is, we jump to its operation.
If it is neither delete nor enter, we check if we have reached the maximum length and if not, we add the character to the name and draw it.
getPlayersName_delete:
ld a, $00
cp d
jr z, getPlayersName_getName
dec d
dec hl
ld a, ' '
ld (hl), a
ld bc, (CURSOR)
inc c
call AT
rst $10
call AT
jr getPlayersName_getNameIf the key pressed is delete and the length of the name is not zero, we delete the previous character of the name and the display.
getPlayersName_enter:
ld a, 0
cp d
jr z, getPlayersName_getName
retIf the key pressed is enter and the length of the name is not zero, the name request is terminated.
The final aspect of the routine is as follows:
; -------------------------------------------------------------------
; Ask for the names of the players.
;
; Alters the value of the AF, BC, DE and HL registers.
; -------------------------------------------------------------------
GetPlayersName:
ld hl, Name_p1 ; HL = address player name 1
ld de, Name_p1+$01 ; DE = HL+1
ld bc, LENNAME*2-$01 ; BC = length names - 1
ld (hl), " " ; Clears first position
ldir ; Clean up the rest
ld e, $01 ; E = 1
getPlayersName_loop:
ld a, INK4 ; A = ink 4
call INK ; Change ink
ld b, INI_TOP-$0f ; B = coord Y
ld c, INI_LEFT-$01 ; X = coord X
call CLL ; Delete the line
call AT ; Position cursor
ld hl, TitlePlayerNumber ; HL = player number
ld (hl), "1" ; Player 1
ld a, $01 ; A = 1
cp e ; Player 1?
jr z, getPlayersName_cont; Yes, skip
ld (hl), "2" ; Player 2
getPlayersName_cont:
ld hl, TitlePlayerName ; HL = title player name
call PrintString ; Paints it
ld hl, Name_p1 ; HL = address player name 1
ld a, $01 ; A = 1
cp e ; Player 1?
jr z, getPlayersName_cont2 ; Yes, skip
ld hl, Name_p2 ; HL = address player name 2
getPlayersName_cont2:
ld d, $00 ; D = counter length name
ld a, INK3 ; A = ink 3
call INK ; Change ink
call getPlayersName_getName; Request player name
ld a, (MaxPlayers) ; A = players
cp $02 ; Two players?
jr nz, getPlayersName_onlyOne ; One player, default name
inc e ; E+=1
cp e ; Compare with players
jr z, getPlayersName_loop; Equals, jumps
ret
; Single player
; Copies the default name of player 2
getPlayersName_onlyOne:
ld hl, Name_p2Default ; HL = default player name 2
ld de, Name_p2 ; DE = name player 2
ld bc, LENNAME ; Length name
ldir ; Copy default name
ret ; Sale
; Requests the player's name
getPlayersName_getName:
push hl ; Preserve HL
call WaitKeyAlpha ; Wait for valid key
pop hl ; Retrieve HL
cp KEYDEL ; Delete?
jr z, getPlayersName_delete ; Yes, skip
cp KEYENT ; Enter?
jr z, getPlayersName_enter ; Yes, skip
push de ; Preserves DE
ld e, a ; E = code Ascii
ld a, LENNAME ; A = maximum length name
cp d ; D = maximum length?
ld a, e ; A = code Ascii
pop de ; Retrieve DE
jr z, getPlayersName_getName ; D = maximum length
; other character
; Enter or Delete
ld (hl), a ; Append character to name
inc hl ; HL = next position
rst $10 ; Print character
inc d ; D+=1
jr getPlayersName_getName; Request another character
getPlayersName_delete:
ld a, $00 ; A = 0
cp d ; Length 0?
jr z, getPlayersName_getName ; Yes, another character
dec d ; D-=1
dec hl ; HL-=1, previous character
ld a, ' ' ; A = space
ld (hl), a ; Clear previous character
ld bc, (CURSOR) ; BC = cursor position
inc c ; BC = previous column for AT
call AT ; Position cursor
rst $10 ; Delete the display character
call AT ; Position cursor
jr getPlayersName_getName; Other character
getPlayersName_enter:
ld a, 0 ; A = 0
cp d ; Length 0?
jr z, getPlayersName_getName ; Yes, another character
ret ; End nameLet’s see if it works. In main.asm we find Init, and under CALL CLS we add the call to the name request, and another call to CLS.
call GetPlayersName ; Request player names
call CLS ; Clear screenWe compile, load into the emulator and see the results. We can now enter the names of the players and they will appear in the game information. If it is a single player game, we are playing against ZX Spectrum.
Shift time
One of the options is the number of seconds each player has to make their move. If the move has not been made within these seconds, the player loses the turn and it passes to the other player.
We will use interrupts to control the time. We create the file int.asm.
At the top of main.asm, just below ORG $5E88, we add the following lines (we already did this in Space Battle):
; -------------------------------------------------------------------
; Flags
; bit 0 -> Reset countdown
; bit 1 -> Lose turn
; bit 2 -> Paint countdown
; bit 3 -> Warning sound, countdown ends
; -------------------------------------------------------------------
flags: db $00
; Value countdown
countdown: db $00
; Seconds per shift
seconds: db $00Seconds is used to tell the interrupts how many seconds per turn the players have chosen. With seconds, the MaxSeconds variable is no longer needed, so we will remove it.
Locate Main and after the CALL OPENCHAN line, initialise seconds:
ld a, $10 ; A = $10 BCD
ld (seconds), a ; Update seconds
ld (countdown), a ; Update countdownLocate menu_Time and after JR NZ, menu_op modify the line LD A, (MaxSeconds), as follows:
ld a, (seconds) ; A = secondsLocate menu_TimeDo, delete LD, (MaxSecond), A and add the following lines instead:
ld (seconds), a ; Update seconds
ld (countdown), a ; Update countdownIn screen.asm, at the end of the PrintOptions routine, we replace LD HL, MaxSeconds with:
ld hl, seconds ; HL = time valueFinally, we delete the MaxSeconds definition in var.asm.
The interrupt routine will change the value of the flags and the countdown, we need to take this into account in the main loop.
For the interrupt routine to run fifty times per second (in PAL, sixty in NTSC), mode two of the interrupts must be enabled. Locate Loop in main.asm and add over it:
di ; Disables interruptions
ld a, $28 ; A = $28
ld i, a ; I = A (interruptions in $7e5c)
im $02 ; Interruptions = mode 2
ei ; Activates interruptionsWe disable the interrupts, load $28 into the interrupt register, set it to mode two and enable it.
We look for loop_key and just below it we implement the flag handling logic.
ld a, (flags) ; A = Flags
bit $02, a ; Bit 2 active?
res $02, a ; Disables bit 2
jr z, loop_warning ; Not active, skips
push af ; Preserve AF
call PrintCountDown ; Paint countdown
pop af ; Retrieve AFWe load the flags in A and evaluate if bit two is active and deactivate it. If it is not active, we jump, if it is, we draw the countdown.
loop_warning:
bit $03, a ; Bit 3 active?
res $03, a ; Disable bit 3
jr z, loop_lostMov ; Not active, skip
ld bc, SoundCountDown ; BC = sound direction
call PlayMusic ; Outputs soundWe evaluate whether bit three is active and deactivate it. If it is active, we jump, if it is not, we give the warning sound.
loop_lostMov:
bit $01, a ; Bit 1 active?
res $01, a ; Disables bit 1
ld (flags), a ; Update in memory
halt ; Synchronise with interrupts
jr z, loop_keyCont ; Not active, skip
ld hl, TitleLostMovement ; HL = address mov lost
ld de, TitleLostMov_name ; DE = address name
call DoMsg ; Paint message
ld bc, SoundLostMovement ; BC = sound direction
call PlayMusic ; Outputs sound
jr loop_cont ; Jump
loop_keyCont:We check if bit one is active, disable it, update the flags and synchronise with the interrupts. If it is, we draw the lost motion message and play the sound. The loop_keyCont tag is above the CALL WaitKeyBoard.
Finally, locate loop_cont, delete JR Loop and add the following lines in its place:
ld a, $01 ; A = restart countdown
ld (flags), a ; Update flags
jp Loop ; Main loopWe have updated the flags so that the interrupt routine restarts the countdown. We also replaced JR with JP because the lines we added make JR out of range.
In screen.asm we will implement the routine that draws the countdown.
; -------------------------------------------------------------------
; Paint the countdown.
;
; Alters the value of the AF, BC and HL registers.
; -------------------------------------------------------------------
PrintCountDown:
ld a, INK3 ; A = ink 3
call INK ; Change ink
ld b, INI_TOP-$0c ; B = coord Y
ld c, INI_LEFT ; C = coord X
call AT ; Position cursor
ld hl, countdown ; HL = direction countdown
call PrintBCD ; Paint countdown left
ld c, INI_LEFT-$1e ; C = coord X
call AT ; Position cursor
jp PrintBCD ; Paints countdown right and exitsWe paint the countdown in two positions, on the left and right of the board. We set the ink to magenta, move the cursor to the left, draw the countdown, move the cursor to the right and draw the countdown.
The interrupt handling routine is implemented in int.asm (do not include this file in main.asm). We will also look at this implementation in blocks.
; -------------------------------------------------------------------
; int.asm
;
; Mode 2 Interrupt Handling
; -------------------------------------------------------------------
org $7e5c
; -------------------------------------------------------------------
; Indicators
; bit 0 -> Reset countdown
; bit 1 -> Lose turn
; bit 2 -> Paint countdown
; bit 3 -> Warning sound, countdown ends
; -------------------------------------------------------------------
FLAGS: equ $5e88
COUNTDOWN: equ FLAGS+$01 ; Countdown Value
SECONDS: equ FLAGS+$02 ; Seconds per turnThe interrupt routine is loaded at address $7E5C. Then we add the constants with the memory addresses we will use for the information exchange between main.asm and int.asm.
CountDownISR:
push af
push bc
push de
push hl
push ix ; Preserves recordsThe first step of the routine is to preserve the value of the registers.
countDown_flags:
ld a, (FLAGS) ; A = flags
and $01 ; Reset countdown?
jr z, countDown_cont ; No, skip
ld a, (SECONDS) ; A = SECONDS
ld (COUNTDOWN), a ; Refreshes in memory
ld a, $04 ; A = paint countdown
ld (FLAGS), a ; Update in memory
jr countDownISR_end ; EndWe check if main.asm indicates that the countdown should be restarted (shift change) and jump if it does not. If there is a shift, it restarts the countdown at the value specified in the menu, indicates in flags that the countdown should be painted, and jumps to exit the routine.
countDown_cont:
ld hl, countDownTicks ; HL = ticks counter
inc (hl) ; Counter ticks+=1
ld a, $32 ; A = 50
cp (hl) ; Counter ticks = 50?
jr nz, countDownISR_end ; No, skip.
xor a ; A = 0, Z = 1, Carry = 0
ld (hl), a ; Counter ticks = 0In countDownTicks we add one at each pause, and when we reach fifty it is a sign that a second has passed, which we check in this block. If it has not reached fifty, it jumps to exit the routine, if it has, we set the ticks counter to zero and continue with the routine.
; It's reached 50, it's been a second.
ld a, (COUNTDOWN) ; A = countdown value
dec a ; A-=1
daa ; Decimal setting
ld (COUNTDOWN), a ; Update in memory
ld b, $04 ; B = paint countdown / 4 sec
cp b ; Less than 4 seconds?
jr nc, countDownISR_reset; A >= 4, skip
set $03, b ; Warning sound
or a ; A = 0?
jr nz, countDownISR_reset; No, skip
set $01, b ; Misses turnIf one second has passed, we calculate what kind of information to pass to main.asm. We subtract one second from the countdown, see if it is below four (it also communicates to main.asm that the countdown has to be painted), and jump if it is not. If it is, we set the bit for the warning sound, evaluate whether the countdown has reached zero, and jump if it has not. Turn on the shift loss bit if it has reached zero.
countDownISR_reset:
ld a, b ; A = B
ld (FLAGS), a ; Updates in memoryUpdate the value of flags with the information you want to pass to main.asm.
countDownISR_end:
pop ix
pop hl
pop de
pop bc
pop af ; Retrieves records
ei ; Activates interruptions
reti ; Exits
countDownTicks: db $00 ; Ticks (50*sec)We get the value of the registers, enable interrupts and exit. Finally we declare the tick counter.
Remember that we now need to compile two separate .tap’s and make our own loader.
The basic loader looks like this:
10 CLEAR 24200
20 LOAD ""CODE 24200
30 LOAD ""CODE 32348
40 RANDOMIZE USR 24200The script to compile on Windows looks like this:
echo off
cls
echo Compiling oxo
pasmo --name OXO --tap main.asm oxo.tap oxo.log
echo Compiling int
pasmo --name INT --tap int.asm int.tap int.log
echo Generating Tic-tac-toe
copy /y /b loader.tap+oxo.tap+int.tap TicTacToe.tap
echo Process completedThe Linux version looks like this:
clear
echo Compiling oxo
pasmo --name OXO --tap main.asm oxo.tap oxo.log
echo Compiling int
pasmo --name INT --tap int.asm int.tap int.log
echo Generating Tic-tac-toe
cat loader.tap oxo.tap int.tap > TicTacToe.tap
echo Process completedWe compile it, load it into the emulator and check that the countdown is painted, that an alarm goes off if it goes under four seconds and that it loses the turn if it goes to zero. We also see the missed turn message.
End of game
At the end of this chapter we will implement the end of the game, which occurs when one of the players reaches the points defined in the menu, or when the maximum number of tables is reached.
At the end of the game we are asked if we want another game; we add the keys of the answer as constants in var.asm. We also add the maximum number of tables.
KEYN: equ $4e ; N key
KEYn: equ $6e ; Key n
KEYS: equ $53 ; S key
KEYs: equ $73 ; Key s
MAXTIES: equ $05 ; Maximum number of tablesDepending on whether you want to play another game or not, you will jump to one place or another in main.asm. We locate the Init tag, and after CALL GetPlayersName we add the following tag:
Start:We locate the loop_reset tag and just below it we will implement the check to see if someone has won the game.
call PrintPoints ; Paint the dots
ld a, (MaxPoints) ; A = maximum points
ld b, a ; B = A
ld a, (Points_p1) ; A = points player 1
cp b ; Player 1 wins?
jr z, EndPlay ; Yes, skip
ld a, (Points_p2) ; A = points player 2
cp b ; Player 2 wins?
jr z, EndPlay ; Yes, skip
ld b, MAXTIES ; B = maximum tables
ld a, (Points_tie) ; A = points tables
cp b ; A = B?
jr z, EndPlay ; Yes, skipWe draw the points and compare the players’ scores with the set maximum score. If one of the players has the required number of points, they win the game.
At the end of main.asm, before the includes, we add the split end routine.
EndPlay:
di ; Disables interrupts
im $01 ; Mode 1 interrupts
ei ; Activates interruptions
ld hl, TitleGameOver ; HL = title game over
call PrintMsg ; Paints the message
endPlay_waitKey:
call WaitKeyAlpha ; Wait key
cp KEYN ; Pressed N?
jp z, Menu ; Yes, menu
cp KEYn ; Pushed n?
jp z, Menu ; Yes, menu
cp KEYS ; Pulsed S?
jp z, Start ; Yes, start
cp KEYs ; Pushed s?
jp z, Start ; Yes, start
jr endPlay_waitKey ; Not pressed, loopWe deactivate interruptions, switch to mode one, activate interruptions, wait for the question to be answered and, depending on the answer, we jump to one place or another.
- Menu: Return to the main menu. We can select the different options and enter new player names.
- Start: is the label we have added. It clears the screen, paints the screen, resets the game data and switches interrupts to mode two.
If none of the expected keys have been pressed, it will loop until one is.
If you go to the Menu tag, you will see that the first three lines are for switching to interrupt mode one, which is what we do in EndPlay. Delete the three lines below the Menu tag.
We compile, load into the emulator and see the results. Everything seems to work fine, but at the end of the game the score is flashing. This is something we inherited from the beginning, although we didn’t notice it until now.
To change the behaviour, locate PrintPoints in screen.asm and add the lines needed to disable the flickering just below it.
ld a,(ATTR_T) ; A = temporary attributes
and $7f ; Removes flicker
ld (ATTR_T), a ; Update in memory
At this point, we can play the first full two-player games.
ZX Spectrum Assembly, Tic-Tac-Toe
Want to play against the Spectrum and beat it? We will implement this in the next chapter of ZX Spectrum Assembly,
Download the source code from here.
Useful links
ZX Spectrum Assembly, Tic-Tac-Toe by Juan Antonio Rubio García.
Translation by Felipe Monge Corbalán.
This work is licensed to Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0).
Any comments are always welcome.