0x02 Ensamblador ZX Spectrum OXO – marcadores y partida a dos
El siguiente paso de Ensamblador ZX Spectrum OXO es implementar los marcadores y la partida a dos jugadores, teniendo así gran parte del programa desarrollado.
Tabla de contenidos
Información
En primer lugar añadiremos el nombre del programa, jugadores, marcadores y la ficha que mueven.
Agregamos en Var.asm los datos necesarios.
LENNAME: equ $0c ; Longitud nombre jugadores
; Información
Info: db $10, $07, $16, $00, $05, "Tres en raya a "
info_points: db "5 punto"
info_gt1: db "s"
player1_title: db $10, $05, $16, $02, $00
player1_name: defs LENNAME, " "
player1_figure: db $16, $04, $00, $90, $91, $0d, $91, $90
player_tie: db $10, $02, $16, $02, $0d, "Tablas"
player2_title: db $10, $06, $16, $02, $14
player2_name: defs LENNAME, " "
player2_figure: db $16, $04, $1b, $92, $93, $16, $05, $1b
db $94, $95, $ff
; Títulos
TitleTurn: db $16, $15, $05, $13, $01
db "Turno para "
TitleTurn_name: defs LENNAME, " "
db $ff
TitleError: db $10, $02, $16, $15, $09, $12, $01, $13, $01
defm "Casilla ocupada", $ff
TitleEspamatica: defm "Espamatica 2019", $ff
TitleGameOver: db $10, $07, $16, $15, $03, $12, $01, $13, $01
defm "Partida finalizada. Otra?", $ff
TitleLostMovement: db $10, $02, $12, $01, $13, $01, $16, $15, $05
defm "Pierde turno "
TitleLostMov_name: defs LENNAME, " "
db $ff
TitleOptionStart: defm "0. Empezar", $ff
TitleOptionPlayer: defm "1. Jugadores", $ff
TitleOptionPoint: defm "2. Puntos", $ff
TitleOptionTime: defm "3. Tiempo", $ff
TitlePlayerName: defm "Nombre jugador "
TitlePlayerNumber: db " : ", $ff
TitlePointFor: db $10, $07, $16, $15, $05, $12, $01, $13, $01
defm "Punto para "
TitlePointName: defs LENNAME, " "
db $ff
TitleTie: db $10, $07, $16, $15, $0d, $12, $01, $13, $01
defm "Tablas", $ff
; -------------------------------------------------------------------
; Desarrollo de la partida.
; -------------------------------------------------------------------
; Casillas del tablero. Un byte por casilla, del 1 al 9.
; Bit 0, casilla ocupada por jugador 1.
; Bit 4, casilla ocupada por jugador 2.
Grid: db $00, $00, $00, $00, $00, $00, $00, $00, $00
; Posiciones de las fichas en el tablero, 2 bytes por ficha X, Y
GridPos: db POS1_LEFT, POS1_TOP ; 1
db POS2_LEFT, POS1_TOP ; 2
db POS3_LEFT, POS1_TOP ; 3
db POS1_LEFT, POS2_TOP ; 4
db POS2_LEFT, POS2_TOP ; 5
db POS3_LEFT, POS2_TOP ; 6
db POS1_LEFT, POS3_TOP ; 7
db POS2_LEFT, POS3_TOP ; 8
db POS3_LEFT, POS3_TOP ; 9
Points_p1: db $00 ; Puntos jugador 1
Points_p2: db $00 ; Puntos jugador 2
Points_tie: db $00 ; Puntos tablas
PlayerMoves: db $00 ; Jugador que mueve
MaxPlayers: db $01 ; Máximo jugadores
MaxPoints: db $05 ; Máximo puntos
MaxSeconds: db $10 ; Máximo seguntos
Name_p1: db "Amstrad CPC " ; Nombre jugador 1
Name_p2: db "ZX Spectrum " ; Nombre jugador 2
Name_p2Default: db "ZX Spectrum " ; Nombre por defectoEn la etiqueta Info definimos los literales que se van a mostrar en la parte superior de la pantalla. Aunque lo veáis raro, la división que se hace en varias etiquetas se debe a que hay valores que cambian por la selección que hagan los jugadores:
- Puntos necesarios para ganar la partida.
- Si son más de un punto, se pone en plural.
- Nombre de los jugadores.
También se definen las etiquetas que vamos a usar para llevar la cuenta de la puntuación de cada jugador y sus nombres.
Vamos a Screen.asm e implementamos una rutina para pintar la información y otra para pintar la puntuación.
; -------------------------------------------------------------------
; Pinta la información de la partida.
;
; Altera el valor de HL.
; -------------------------------------------------------------------
PrintInfo:
ld hl, Info ; HL = información
jp PrintString ; La pintaPrintInfo pinta la información a mostrar en la parte superior de la pantalla. No asigna colores de tinta, ni posiciones, ya que todo eso está definido en la etiqueta Info.
Ya lo tenemos todo listo. Vamos a Main.asm y tras la llamada a PrintBoard, añadimos el código que pinta la información y la puntuación.
ld hl, Name_p1
ld de, player1_name
ld bc, LENNAME
ldir
ld hl, Name_p2
ld de, player2_name
ld bc, LENNAME
ldir
call PrintInfo
xor a
ld hl, Points_p1
ld de, Points_p1+$01
ld bc, $03
ld (hl), a
ldir
call PrintPointsLos nombres de los jugadores están en las etiquetas Name_p1 y Name_p2, por lo que tenemos que pasarlos al lugar correspondiente de la información. Inicializamos la puntuación y la pintamos.
Compilamos, cargamos en el emulador y vemos los resultados.
Partida a dos
Vamos a implementar la partida a dos jugadores: controles, movimientos de ficha, comprobaciones de que sean correctos y de consecución de tres en raya.
En Var.asm incluimos unas serie de constantes con colores de tinta, líneas en las que se producen las tres en raya, y códigos de teclas, que vamos a usar junto a la rutina de la ROM para verificar los controles.
INKWARNING: equ $C2 ; Tinta advertencias
INKPLAYER1: equ $05 ; Tinta jugador 1
INKPLAYER2: equ $06 ; Tinta jugador 2
INKTIE: equ $07 ; Tinta tablas
KEYDEL: equ $0c ; Tecla Delete
KEYENT: equ $0d ; Tecla Enter
KEYSPC: equ $20 ; Tecla Space
KEY0: equ $30 ; Tecla 0
KEY1: equ $31 ; Tecla 1
KEY2: equ $32 ; Tecla 2
KEY3: equ $33 ; Tecla 3
KEY4: equ $34 ; Tecla 4
KEY5: equ $35 ; Tecla 5
KEY6: equ $36 ; Tecla 6
KEY7: equ $37 ; Tecla 7
KEY8: equ $38 ; Tecla 8
KEY9: equ $39 ; Tecla 9
WINNERLINE123: equ $01 ; Linea ganadora 123
WINNERLINE456: equ $02 ; Linea ganadora 456
WINNERLINE789: equ $03 ; Linea ganadora 789
WINNERLINE147: equ $04 ; Linea ganadora 147
WINNERLINE258: equ $05 ; Linea ganadora 258
WINNERLINE369: equ $06 ; Linea ganadora 369
WINNERLINE159: equ $07 ; Linea ganadora 159
WINNERLINE357: equ $08 ; Linea ganadora 357La lógica la vamos a implementar en el archivo Game.asm. Lo creamos y añadimos el include en Main.asm.
; -------------------------------------------------------------------
; Espera a que se pulse alguna tecla del tablero.
; Durante el juego se activan las interrupciones para realizar la
; cuenta atrás.
; Con las interrupciones activadas no actualiza FLAGS_KEY/LAST_KEY.
;
; Salida: C -> Tecla pulsada.
;
; Altera el valor de los registros AF y BC.
; -------------------------------------------------------------------
WaitKeyBoard:
ld a, $f7 ; A = semifila 1-5
in a, ($fe) ; Lee semifila
cpl ; Invierte bits, teclas pulsadas a 1
and $1F ; A = bits 1 a 4
jr z, waitKey_cont ; Niguna tecla pulsada, salta
; Evalúa la tecla pulsada del 1 al 5
ld c, KEY1 ; C = tecla 1
ld b, $05 ; B = teclas a comprobar
waitKey_1_5:
rra ; ¿Tecla pulsada?
ret c ; Pulsada, salta
inc c ; C = codigo siguiente tecla
djnz waitKey_1_5 ; Bucle para 5 teclas
waitKey_cont:
ld a, $ef ; A = semifila 0-6
in a, ($fe) ; Lee semifila
cpl ; Invierte bits, teclas pulsadas a 1
and $1F ; A = bits 1 a 4
jr z, waitKey_end ; Niguna tecla pulsada, salta
; Evalúa la tecla pulsada 9 al 6
rra ; Se salta la tecla cero
ld c, KEY9 ; C = tecla 9
ld b, $04 ; B = teclas a comprobar
waitKey_9_6:
rra ; ¿Tecla pulsada?
ret c ; Pulsada, salta
dec c ; C = codigo siguiente tecla
djnz waitKey_9_6 ; Bucle para 4 teclas
; No se ha pulsado ninguna tecla
waitKey_end:
ld c, KEY0
retCon WaitKeyBoard vamos a comprobar si se ha pulsado alguna de las teclas del tablero, del uno al nueve. En este caso no vamos a usar la rutina de la ROM ya que, más adelante, tendremos las interrupciones en modo dos activas, y no se actualizarán ni FLAGS_KEY ni LAST_KEY, y la ROM no podrá decirnos la última tecla pulsada.
La comprobación de las teclas es muy parecida a la que hicimos en Batalla espacial, con las siguientes variantes:
- CPL: invertimos los bit y evaluamos si se pulsó alguna tecla con AND $1F; saltamos si no se pulsó ninguna.
- Lo que devolvemos, en este caso en C, es el código ASCII de la tecla pulsada; de la tecla cero si no se ha pulsado ninguna.
También se puede ver que antes de comprobar las teclas del 9 al 6 hacemos una rotación para ignorar la tecla 0.
Continuamos ahora con la lógica del movimiento de la ficha.
; -------------------------------------------------------------------
; Comprueba y realiza el movimiento si es correcto.
;
; Entrada: C -> Tecla pulsada
; Salida: Z -> Movimiento correcto
; NZ -> Movimiento incorrecto
;
; Altera el valor de los registros AF y HL.
; -------------------------------------------------------------------
ToMove:
push bc ; Perserva BC
ld hl, Grid ; HL = dirección grid
ld a, c ; A = C (codigo tecla)
sub $30 ; A = valor númerico tecla
dec a ; A-=1, para que no sume uno más
ld b, $00 ; B = 0
ld c, a ; C = A, BC = desplazamiento
add hl, bc ; HL = dirección casilla de tecla
pop bc ; Recupera BC
ld a, (hl) ; A = valor casilla
or a ; ¿Está libre?
ret nz ; Ocupada, sale
ld a, (PlayerMoves) ; A = jugador que mueve
or a ; ¿Jugador 1?
jr nz, toMove_p2 ; Jugador 2, salta
set $00, (hl) ; Activa casilla jugador 1
jr toMove_end ; Salta
toMove_p2:
set $04, (hl) ; Activa casilla jugador 2
toMove_end:
xor a ; Pone flag Z
ret ; SaleToMove recibe en C el código de la tecla pulsada. Calculamos el valor restando el código ASCII de cero, restamos uno para no sumar uno de más en el desplazamiento, y apuntamos a la celda correspondiente a la tecla pulsada. Comprobamos si la celda no está ocupada, si no lo está activamos los bits uno o cuatro de la celda según el jugador que mueve. Si la celda está ocupada sale con NZ, si no lo está sale con Z (XOR A).
Necesitamos una rutina que pinte la ficha en el lugar correcto; la implementamos en Screen.asm.
; -------------------------------------------------------------------
; Pinta la ficha.
;
; Entrada: C -> Tecla pulsada.
;
; Altera el valor de los registros AF, BC y HL.
; -------------------------------------------------------------------
PrintOXO:
; Cálculo posición ficha
ld a, c ; A = tecla
sub $30 ; A = valor tecla
dec a ; A-=1, para no sumar de más en desplazamiento
add a, a ; A+=A, desplazamiento, dos bytes por posición
ld b, $00 ; B = 0
ld c, a ; C = A
ld hl, GridPos ; HL = dirección posiciones grid
add hl, bc ; HL+=BC, dirección coord X celda
ld c, (hl) ; C = coord X celda
inc hl ; HL = dirección coord Y
ld b, (hl) ; B = coord Y celda
call AT ; Posiciona cursor
; Cálculo ficha
ld a, (PlayerMoves) ; A = jugador que mueve
or a ; Comprueba jugador
jr nz, printOXO_Y ; No cero, salta
printOXO_X:
ld a, INKPLAYER1 ; A = tinta jugador 1
call INK ; Cambia tinta
ld a, $90 ; A = 1er sprite
rst $10 ; Lo pinta
ld a, $91 ; A = 2º sprite
rst $10 ; Lo pinta
dec b ; B = línea inferior
call AT ; Posiciona cursor
ld a, $91 ; A = 2º sprite
rst $10 ; Lo pinta
ld a, $90 ; A = 1er sprite
rst $10 ; Lo pinta
ret ; Sale
printOXO_Y:
ld a, INKPLAYER2 ; A = tinta jugador 2
call INK ; Cambia tinta
ld a, $92 ; A = 1er sprite
rst $10 ; Lo pinta
ld a, $93 ; A = 2º sprite
rst $10 ; Lo pinta
dec b ; B = línea inferior
call AT ; Posiciona cursor
ld a, $94 ; A = 3er sprite
rst $10 ; Lo pinta
ld a, $95 ; A = 4º sprite
rst $10 ; Lo pinta
ret ; SaleEn la primera parte de PrintOXO se calcula el desplazamiento para obtener las coordenadas donde pintar la ficha, se obtienen y se posiciona el cursor. Tras esto se obtiene que jugador mueve.
La forma de pintar una u otra ficha son casi idénticas: cambia la tinta, pinta la parte de arriba, posiciona el cursor en la línea inferior, y pinta la parte de abajo antes de salir.
Ya podemos empezar a probar como se ve en el programa todo lo implementado. Vamos a Main.asm y debajo de la etiqueta Loop, antes de JR Loop, añadimos las llamadas a las rutinas implementadas.
call WaitKeyBoard
ld a, c
cp KEY0
jr z, loop_cont
call ToMove
jr nz, loop_cont
call PrintOXO
ld a, (PlayerMoves)
xor $01
ld (PlayerMoves), a
loop_cont:Esperamos a que el jugador pulse una tecla, si la ha pulsado se comprueba si el movimiento es correcto, y si es así pintamos la ficha y cambiamos de jugador.
Compilamos, cargamos en el emulador y vemos los resultados.
Vemos como las fichas se pintan y una vez que se ocupa todo el tablero sólo podemos reiniciar y volver a cargar, por lo que tenemos que implementar lo siguiente:
- Si el tablero está lleno, reiniciarlo.
- Mostrar mensajes de información.
- Comprobar si hay tres en raya o tablas.
- Actualizar el marcador.
Reinicio del tablero
En Var.asm, antes de PlayersMoves, añadimos una etiqueta para llevar la cuenta del número de movimientos. El tablero estará lleno en el momento en el que el valor llegue a nueve.
La ponemos antes porque PlayersMoves sólo la vamos a reiniciar cuando si inicia una partida. Si la reiniciamos con cada punto, el jugador uno siempre movería primero.
MoveCounter: db $00 ; Contador de movimientosTambién en Var.asm añadimos una constante al inicio, en la que especificamos la longitud de datos a inicializar en cada partida.
LENDATA: equ $04 ; Longitud de los datos a inicializarSegún sea necesario añadir más datos que debamos inicializar, cambiaremos el valor de esta constante.
En Main.asm localizamos la etiqueta Loop y cuatro líneas antes la línea LD BC, $03. Sustituimos está línea por la siguiente:
ld bc, LENDATACompilamos, cargamos en el emulador y comprobamos que todo sigue funcionando.
Como hemos comentado, no siempre vamos a inicializar todos los datos, por lo que es buena idea implementar una rutina a la que se le pueda pasar la longitud de los datos a inicializar, y así poder llamarla desde distintos sitios, con distintos valores.
Los valores que vamos a inicializar son:
- Points_p1
- Points_p2
- Points_tie
- MoveCounter
- PlayerMoves (solo al iniciar la partida)
Hay más valores que debemos inicializar, pero están más arriba, por lo que, o los inicializamos en dos partes, o cambiamos la etiqueta de sitio. La etiqueta es Grid (movimientos de cada jugador), y debemos de poner todos los valores a cero al inicio de cada punto. Vamos a cambiar la etiqueta de lugar, justo por encima de Points_p1, quedando así:
; -------------------------------------------------------------------
; Desarrollo de la partida.
; -------------------------------------------------------------------
; Posiciones de las fichas en el tablero, 2 bytes por ficha Y, X
GridPos: db POS1_LEFT, POS1_TOP ; 1
db POS2_LEFT, POS1_TOP ; 2
db POS3_LEFT, POS1_TOP ; 3
db POS1_LEFT, POS2_TOP ; 4
db POS2_LEFT, POS2_TOP ; 5
db POS3_LEFT, POS2_TOP ; 6
db POS1_LEFT, POS3_TOP ; 7
db POS2_LEFT, POS3_TOP ; 8
db POS3_LEFT, POS3_TOP ; 9
; Casillas del tablero. Un byte por casilla, del 1 al 9.
; Bit 0 a 1, casilla ocupada por jugador 1.
; Bit 4 a 1, casilla ocupada por jugador 2.
Grid: db $00, $00, $00, $00, $00, $00, $00, $00, $00
Points_p1: db $00 ; Puntos jugador 1
Points_p2: db $00 ; Puntos jugador 2
Points_tie: db $00 ; Puntos tablas
MoveCounter: db $00 ; Contador de movimientos
PlayerMoves: db $00 ; Jugador que mueveEl valor de LENDATA hay que cambiarlo por $0D.
Implementamos la rutina de inicialización en Game.asm.
; -------------------------------------------------------------------
; Inicializa los valores de la partida/punto.
;
; Entrada: BC -> Longitud de los valores a inicializar.
;
; Altera el valor de los registros BC, DE y HL.
; -------------------------------------------------------------------
ResetValues:
ld hl, Grid ; HL = dirección de Grid
ld de, Grid+$01 ; DE = dirección de Grid+1
ld (hl), $00 ; Pone a cero la primera posición
ldir ; Pone a cero el resto (BC)
retResetValues recibe en BC el número de bytes a limpiar (debe ser uno menos de la longitud total, por eso LENDATA es igual a $0D en lugar de $0E), apunta HL y DE a la primera y segunda posición de Grid, limpia la primera y luego el resto.
Si os fijáis bien, esta rutina os debe de sonar mucho, id y mirad la rutina CLS de Screen.asm. ¡Son casi iguales!
Podríamos implementar una rutina con las líneas LD (HL), $00, LDIR y RET, teniendo en cuenta que antes de llamarla habría que cargar los valores necesarios en HL y BC, y eliminar CLS y ResetValues. Lo dejo a vuestra elección, yo lo voy a dejar como está ahora.
Volvemos a Main.asm, localizamos Loop y unas líneas más arriba XOR A. Desde XOR A a CALL PrintPoint, sólo vamos a dejar las líneas LD BC, LENDATA y CALL PrintPoints, el resto las borramos.
Entre LD BC, LENDATA y CALL PrintPoints, vamos a añadir CALL ResetValues, quedando así:
call PrintInfo
ld bc, LENDATA
call ResetValues
call PrintPoints
Loop:Tras cargar la longitud de los datos a limpiar en BC, llamamos a la inicialización de los valores y pintamos los puntos.
Compilamos, cargamos en el emulador y vemos que todo sigue funcionando.
Para poder saber si el tablero está lleno, tenemos que actualizar MoveCounter con cada movimiento y comprobar si ha llegado a nueve.
Localizamos loop_cont y añadimos las líneas siguientes justo por encima, después de LD (PlayerMoves), A:
ld hl, MoveCounter
inc (hl)
ld a, $09
cp (hl)
jr nz, loop_cont
ld bc, LENDATA-$01
call ResetValues
call PrintBoardIncrementamos el contador de movimientos, comprobamos si ha llegado a nueve, en cuyo caso cargamos en BC la longitud de los datos a limpiar menos uno (para no limpiar el jugador que mueve), inicializamos los datos y pintamos el tablero vacío.
Compilamos y cargamos en el emulador. Si vamos pulsando las teclas del uno al nueve, hasta que se llene el tablero, el jugador al que le toca mover no se ha limpiado y mueve al que le tocaba en el siguiente turno.
Mensajes de información
Durante el transcurso de la partida se deben mostrar diversos mensajes a los jugadores: si el movimiento es erróneo, el jugador que mueve, quién consigue el punto, si hay tablas y si la partida a finalizado.
Los mensajes ya los definimos al inicio del capítulo, y en cada uno de ellos la tinta, brillo, parpadeo y localización, por lo que lo único que tendríamos que hacer es llamar a PrintString con la dirección del mensaje en HL.
Hay dos motivos para no poder hacerlo así:
- Los mensajes Turno para, Pierde turno y Punto para no están completos, se completan con el nombre del jugador en posesión del turno.
- Antes de escribir un mensaje, hay que borrar la línea.
Vamos a implementar dos rutinas, una en Game.asm y la otra en Screen.asm; estas rutinas nos harán de puente cuando llamemos a PrintString.
Empezamos por la rutina que implementamos en Screen.asm.
; -------------------------------------------------------------------
; Pinta los mensajes
;
; Entrada: HL -> dirección del mensaje
; -------------------------------------------------------------------
PrintMsg:
ld b, INI_TOP-$15 ; B = coord Y linea a borrar (invertida)
call CLL ; Borra la línea
jp PrintString ; Pinta el mensajePrintMsg recibe en HL la dirección del mensaje, borra la línea de mensajes y salta a pintar el mensaje; sale por allí. Borrar la línea antes de pintar un nuevo mensaje es la única utilidad de esta rutina.
Implementamos la rutina de Game.asm, que va a completar los tres mensajes que pintan el nombre del jugador.
; -------------------------------------------------------------------
; Completa los mensajes en los que se muestra el nombre del jugador.
;
; Entrada: HL -> dirección del mensaje
; DE -> dirección donde debe ir el nombre
;
; Altera el valor de los registros AF, BC y DE.
; -------------------------------------------------------------------
DoMsg:
push hl ; Perserva HL
ld hl, player1_name ; HL = nombre jugador 1
ld a, (PlayerMoves) ; A = jugador
or a ; ¿Jugador 1?
ld a, INKPLAYER1 ; A = tinta jugador 1
jr z, doMsg_cont ; Jugador 1, salta
ld hl, player2_name ; HL = nombre jugador 2
ld a, INKPLAYER2 ; A = tinta jugador 2
doMsg_cont:
call INK ; Cambia tinta
ld bc, LENNAME ; BC = longitud nombre
ldir ; Pasa nombre jugador a mensaje
pop hl ; Recupera HL
jp PrintMsg ; Pinta mensajeDoMsg recibe en HL la dirección de mensaje a pintar, y en DE la dirección dónde se debe poner el nombre del jugador. Comprueba que jugador tiene el turno, pone uno u otro nombre y la tinta del jugador. Pinta el mensaje y sale por allí.
Vamos a Main.asm y pintamos todos los mensajes que podemos pintar, por ahora, empezando por quién tiene el turno.
Localizamos Loop, y justo debajo añadimos las siguientes líneas:
ld b, $19
loop_wait:
halt
djnz loop_wait
ld hl, TitleTurn
ld de, TitleTurn_name
call DoMsg
loop_key:Cada vez que pasamos por el bucle pintamos el jugador al que le toca mover. Antes realizamos una pausa de como medio segundo para que de tiempo a leer los mensajes.
Ahora localizamos la línea CP KEY0 y, justo debajo, en la línea JR Z, loop_cont, cambiamos loop_cont por loop_key.
Compilamos, cargamos en el emulador y vemos que ya pintamos a que jugador le toca mover.
Vamos a pintar también el mensaje de error de casilla ocupada. Localizamos la línea CALL ToMove, borramos la línea siguiente, JR NZ, loop_cont, y añadimos las siguientes:
jr z, loop_print
ld hl, TitleError
call PrintMsg
jr Loop
loop_print:Si retorna de la rutina ToMove con el flag Z activo, siginifca que el movimiento es correcto y saltamos a loop_print, etiqueta que hemos añadido antes de CALL PrintOXO. Si no es el caso, el movimiento no es correcto y pintamos el mensaje de error y volvemos al inicio del bucle.
Compilad, cargad en el emulador e intentad mover a una casilla ocupada. Se debe pintar el mensaje de error, aunque se ve durante un corto espacio de tiempo; no os preocupéis, más adelante quitaremos la pausa al inicio de Loop y utilizaremos los efectos de sonido para poder temporizar.
Comprobación de tablas
La comprobación de tablas es sencilla; si se ha llegado a nueve movimientos y no hay tres en raya, hay tablas.
Localizamos la etiqueta loop_cont y cuatro líneas por encima, entre JR NZ, loop_cont y LD BC, LENDATA-$01, añadimos lo siguiente:
ld hl, Points_tie
inc (hl)
ld hl, TitleTie
call PrintMsgCon estas líneas, si se llega a nueve movimientos sin haber tres en raya, se suma uno al marcador de tablas.
Id a la etiqueta loop_key y encima añadid la siguiente línea:
call PrintPointsAhora, en cada iteración del bucle pintamos las puntuaciones. El CALL PrintPoints que hay justo encima de Loop lo podemos quitar.
Compilad, cargad en el emulador y veréis como no todo funciona como debería, no se actualiza el marcador de tablas.
En realidad todo está funcionando como debe, el problema está en que ResetValues está reiniciando las puntuaciones, lo cual es fácil de solucionar, aunque lo haremos más adelante.
También observamos que al repintar el tablero el parpadeo está activo, debido a que el mensaje Punto para lo deja así.
Para solucionarlo podríamos implementar una rutina para quitar el parpadeo, pero optamos por solucionarlo en la definición del tablero. Vamos a Var.asm y justo debajo de la etiqueta Board_1 añadimos la siguiente línea para desactivar el parpadeo y brillo al pintar el tablero.
db $12, $00, $13, $00Comprobación de tres en raya
La comprobación de tres en raya no tendríamos que realizarla hasta que se hayan realizado al menos tres movimientos. En principio, se deberían dar al menos cinco movimientos antes de poder haber tres en raya, pero dado que vamos a implementar la posibilidad de que el jugador pierda el turno si tarda más de lo establecido en realizarlo, es posible que con tres movimientos haya tres en raya. No obstante, vamos a realizar la operación cada vez que se mueva una ficha, y así siempre tardará lo mismo cada iteración del bucle (más o menos).
En Game.asm añadimos la rutina que comprueba si hay tres en raya.
; -------------------------------------------------------------------
; Comprueba si hay tres en raya.
;
; Retorno: A -> línea de tres en raya
; Z si hay tres en raya, NZ en el caso contrario.
;
; Altera el valor de los registros AF, B e IX.
; -------------------------------------------------------------------
ChekcWinner:
ld ix, Grid-$01 ; IX = dirección grid - 1
ld b, $03 ; B = suma celdas jugador 1
ld a, (PlayerMoves) ; A = jugador
or a ; ¿Jugador 1?
jr z, ChekcWinner_check ; Jugador 1, salta
ld b, $30 ; B = suma celdas jugador 2
ChekcWinner_check:
ld a, (ix+1) ; A = celda 1
add a, (ix+2) ; A+= celda 2
add a, (ix+3) ; A+= celda 3
cp b ; ¿Tres en raya?
ld a, WINNERLINE123 ; A = indicador línea 123
ret z ; Tres en raya, sale
ld a, (ix+4) ; A = celda 4
add a, (ix+5) ; A+= celda 5
add a, (ix+6) ; A+= celda 6
cp b ; ¿Tres en raya?
ld a, WINNERLINE456 ; A = indicador línea 456
ret z ; Tres en raya, sale
ld a, (ix+7) ; A = celda 7
add a, (ix+8) ; A+= celda 8
add a, (ix+9) ; A+= celda 9
cp b ; ¿Tres en raya?
ld a, WINNERLINE789 ; A = indicador línea 789
ret z ; Tres en raya, sale
ld a, (ix+1) ; A = celda 1
add a, (ix+4) ; A+= celda 4
add a, (ix+7) ; A+= celda 7
cp b ; ¿Tres en raya?
ld a, WINNERLINE147 ; A = indicador línea 147
ret z ; Tres en raya, sale
ld a, (ix+2) ; A = celda 2
add a, (ix+5) ; A+= celda 5
add a, (ix+8) ; A+= celda 8
cp b ; ¿Tres en raya?
ld a, WINNERLINE258 ; A = indicador línea 258
ret z ; Tres en raya, sale
ld a, (ix+3) ; A = celda 3
add a, (ix+6) ; A+= celda 6
add a, (ix+9) ; A+= celda 9
cp b ; ¿Tres en raya?
ld a, WINNERLINE369 ; A = indicador línea 369
ret z ; Tres en raya, sale
ld a, (ix+1) ; A = celda 1
add a, (ix+5) ; A+= celda 5
add a, (ix+9) ; A+= celda 9
cp b ; ¿Tres en raya?
ld a, WINNERLINE159 ; A = indicador línea 159
ret z ; Tres en raya, sale
ld a, (ix+3) ; A = celda 3
add a, (ix+5) ; A+= celda 5
add a, (ix+7) ; A+= celda 7
cp b ; ¿Tres en raya?
ld a, WINNERLINE357 ; A = indicador línea 357
ret ; Ultima condición, siempre saleEn CheckWinner apuntamos IX a la dirección anterior a Grid, en B cargamos el valor que deben sumar las celdas en el caso de que gane uno u otro jugador: tres para el jugador uno y treinta para el dos.
Luego, vamos comprobando las posibles combinaciones de tres en raya que hay y salimos si se ha producido alguna, con la combinación ganadora en A y el flag Z activado. Para comprobar si ha habido tres en raya, sumamos los valores de las celdas en A y lo compramos con B.
En la última comprobación, si no se han logrado las tres en raya, se sale con el flag Z desactivado.
En Main.asm vamos a añadir las líneas para la comprobación de tres en raya, y para actuar según se haya conseguido o no. Añadimos las líneas siguientes justo debajo de CALL PrintOXO.
loop_checkWinner:
call ChekcWinner
jr nz, loop_tie
ld hl, TitlePointFor
ld de, TitlePointName
call DoMsg
ld hl, Points_p1
ld a, (PlayerMoves)
or a
jr z, loop_win
inc hl
loop_win:
inc (hl)
jr loop_reset
loop_tie:Llamamos a la comprobación de tres en raya y saltamos si no las hay. Si hay tres en raya, pintamos el mensaje de Punto para, obtenemos que jugador lo ha conseguido e incrementamos su marcador.
Justo debajo de loop_tie están estas líneas:
ld a, (PlayerMoves)
xor $01
ld (PlayerMoves), aLas quitamos y las ponemos debajo de la etiqueta loop_cont, de lo contrario el siguiente punto lo empieza el mismo jugador que ganó el anterior.
Por último, antes de LD BC, LENDATA-$01 añadimos la etiqueta loop_reset.
Compilamos, cargamos en el emulador y todo parece funcionar, excepto los marcadores que siguen sin actualizarse.
Vamos a marcar visualmente dónde se han producido las tres en raya, dibujando una diagonal que cruce las tres fichas. Implementamos la rutina en Screen.asm.
; -------------------------------------------------------------------
; Imprime la línea ganadora.
;
; Entrada: A -> Línea ganadora
;
; Altera el valor de los registros AF, BC, DE y HL.
; -------------------------------------------------------------------
PrintWinnerLine:
ld hl, COORDX ; HL = coord X
ld bc, $6c6c ; BC = desplazamiento
ld de, $01ff ; DE = orientación
cp WINNERLINE159 ; ¿Gana línea 159?
jr z, printWinnerLine_159 ; Sí, salta
ld e, $01 ; DE = orientación
cp WINNERLINE357 ; ¿Gana línea 357?
jr z, printWinnerLine_357 ; Sí, salta
ld c, $00 ; Desplazamiento
cp WINNERLINE147 ; ¿Gana línea 147?
jr z, printWinnerLine_147 ; Sí, salta
cp WINNERLINE258 ; ¿Gana línea 258?
jr z, printWinnerLine_258 ; Sí, salta
cp WINNERLINE369 ; ¿Gana línea 369?
jr z, printWinnerLine_369 ; Sí, salta
ld bc, $006c ; Desplazamiento
ld (hl), $48 ; Coord X
inc hl ; Apunta HL a coord Y
cp WINNERLINE123 ; ¿Gana línea 123?
jr z, printWinnerLine_123 ; Sí, salta
cp WINNERLINE456 ; ¿Gana línea 456?
jr z, printWinnerLine_456 ; Sí, salta
cp WINNERLINE789 ; ¿Gana línea 789?
jr z, printWinnerLine_789 ; Si es así, salta a pintarla.
printWinnerLine_159:
ld (hl), $b7 ; Coord X
jr printWinnerLine_Y
printWinnerLine_357:
ld (hl), $48 ; Coord X
jr printWinnerLine_Y
printWinnerLine_147:
ld (hl), $58 ; Coord X
jr printWinnerLine_Y
printWinnerLine_258:
ld (hl), $80 ; Coord X
jr printWinnerLine_Y
printWinnerLine_369:
ld (hl), $a8 ; Coord X
printWinnerLine_Y:
inc hl ; Apunta HL a coord Y
ld (hl), $10 ; Coord Y
jr printWinnerLine_end ; Pinta la línea
printWinnerLine_123:
ld (hl), $70 ; Coord Y
jr printWinnerLine_end ; Pinta la línea
printWinnerLine_456:
ld (hl), $47 ; Coord Y
jr printWinnerLine_end ; Pinta la línea
printWinnerLine_789:
ld (hl), $20 ; Coord Y
printWinnerLine_end:
jp DRAW ; Pinta la líneaPrintWinnerLine recibe en A la línea ganadora. En primer lugar evaluamos cual es esa línea para saltar a una parte u otra de la rutina. Dado que las distintas líneas a pintar comparten datos comunes, se van cambiando solo los datos que difieren y se llama a DRAW para pintar la línea y salir por allí (para más información ver comentarios de DRAW en ROM.asm).
En Main.asm, localizamos la etiqueta loop_checkWinner y debajo de JR NZ, loop_tie añadimos la línea siguiente:
call PrintWinnerLineCompilamos, cargamos en el emulador y vemos los resultados.
Como podemos comprobar se pinta una línea marcando las tres en raya, aunque es tan rápido que apenas podemos verlo. En el próximo capítulo usaremos el sonido para temporizar.
No obstante, si queréis comprobar que se pinta la línea, podéis poner debajo de CALL PrintWinnerLine, estas dos líneas:
tmp:
jr tmpNo olvidéis quitarlas luego.
Actualización del marcador
Vamos a arreglar el error que arrastramos desde hace tiempo y que provoca que el marcador no se esté actualizando.
En Var.asm localizamos la etiqueta Grid y vemos que por debajo están las etiquetas Points_p1, Points_p2 y Point_tie. Movemos estas tres etiquetas a justo debajo de MoveCounter.
; -------------------------------------------------------------------
; Desarrollo de la partida.
; -------------------------------------------------------------------
; Posiciones de las fichas en el tablero, 2 bytes por ficha Y, X
GridPos: db POS1_LEFT, POS1_TOP ; 1
db POS2_LEFT, POS1_TOP ; 2
db POS3_LEFT, POS1_TOP ; 3
db POS1_LEFT, POS2_TOP ; 4
db POS2_LEFT, POS2_TOP ; 5
db POS3_LEFT, POS2_TOP ; 6
db POS1_LEFT, POS3_TOP ; 7
db POS2_LEFT, POS3_TOP ; 8
db POS3_LEFT, POS3_TOP ; 9
; Casillas del tablero. Un byte por casilla, del 1 al 9.
; Bit 0 a 1, casilla ocupada por jugador 1.
; Bit 4 a 1, casilla ocupada por jugador 2.
Grid: db $00, $00, $00, $00, $00, $00, $00, $00, $00
MoveCounter:db $00 ; Contador de movimientos
Points_p1: db $00 ; Puntos jugador 1
Points_p2: db $00 ; Puntos jugador 2
Points_tie: db $00 ; Puntos tablas
PlayerMoves:db $00 ; Jugador que mueveEn Main.asm, localizamos la etiqueta loop_reset, y en la línea de más abajo, LD BC, LENDATA-$01, sustituimos $01 por $04.
Compilamos, cargamos en el emulador y, ahora sí, se actualizan los marcadores.
Ensamblador ZX Spectrum, conclusión
En este capítulo hemos pintado la información de la partida y empezado la implementación de la partida a dos, controlando cuando hay tablas o tres en raya y sumando los puntos.
En el próximo capítulo de Ensamblador ZX Spectrum OXO implementaremos el sonido.
Todo el código que hemos generado lo podéis descargar desde aquí.
Enlaces de interés
Ensamblador para ZX Spectrum OXO por Juan Antonio Rubio García.
Esta obra está bajo licencia de Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
También puedes visitar el resto de tutoriales:
Y recuerda, si lo usas no te limites a copiarlo, intenta entenderlo y adaptarlo a tus necesidades.