SI INT(PEEK(23611)/16)/2 = INT(INT(PEEK(32611)/16/2)
    modo 48K
SI NO
    modo 128K
FIN SI

ld   a, $cc                   ; A = 1100 1100
; Usamos desplazamientos para realizar la división entre 16
sra  a                        ; A = A/2 =  0110 0110
sra  a                        ; A = A/4 =  0011 0011
sra  a                        ; A = A/8 =  0001 1001
sra  a                        ; A = A/16 = 0000 1100
; Comprueba si A es par
bit  $00, a
jr   z, EsPar                 ; Si el bit 0 es 0, es par, salta
EsImpar:
; Código de EsImpar
EsPar:
; Código de EsPar

; ZXModel
;
; Obtiene el modelo de ZX
;
; Entrada: nada
;
; Salida:  BC = modelo de ZX
;              0 = 16K
;              1 = 48K
;              2 = 128K
;              3 = 128K en modo 48K
; Altera el valor de los registros BC y AF.
ZXModel:
ld   bc, $00			; BC se utiliza para devolver el valor a BASIC

ld   a, ($4b)           ; A = dirección modelo
cp   $6e
jr   z, is128           ; $6E, 128, salta

is16or48:
ld   a, ($5cb5)         ; A = cantidad memoria, parte alta
rla                     ; Rota a la derecha para comprobar si es $BF o $FF
ret  nc                 ; NC = 16K, sale ($BF)
inc  c                  ; C+=1
ret                     ; 48K, sale

is128:
ld   c, $02             ; C = 128K
ld   a, ($5c3b)         ; A = dirección de modo
; Sí INT(PEEK 23611/16)/2 = INT(INT(PEEK 23611/16)/2) = 48K.
; Dividir ente 16 es como desplazar 4 veces hacia de derecha,
; el bit 4 pasa al bit 0. 
; Saber si es divisible entre dos es como saber si es par, el bit 0 = 0
; Todo se resume en evaluar el bit 4, si es 0 es modo 48K, si es 1 es modo 128K.
bit  $04, a             ; ¿Bit 4?
ret  nz                 ; !0, modo 128K, sale
inc  c                  ; C+=1
ret                     ; Modo 48K

; Programa para averiguar si es NTSC o PAL
; Compilar: pasmo --name PAL_NTSC --tapbas PAL_NTSC.asm PAL_NTSC.tap
; Una vez cargado, ejecutar PRINT USR 32000 para ver el resultado
; No compatible con modelo de 16K

; Resultados de PRINT USR 32000 usando emulador Es.pectrum
;
; https://habisoft.com/espectrum/
;
; Sinclair:
;       48/48+                  216
;       48 NTSC                  64
;       128                     230
;       48 ar                   ¿?
;       48 se                   215
; Timex:
;       TS 2068                  64
;       TC 2068                 216
;       TC 2048                 216
;       Komputer 2086           216
; Investrónica:
;       48+ es                  215
;       128+ es                 230
;       Inves+                  230
; Amstrad:
;       +2                      230
;       +2 es                   230
;       +2 fr                   230
;       +2 ar                   ¿?
;       +2A 4.0                 230
;       +2A 4.1                 230
;       +2A 4.0 es              230
;       +2A 4.1 es              230
;       +2A ar                  ¿?
;       +3 4.0                  230
;       +3 4.1                  230
;       +3 4.0 es               230
;       +3 4.1 es               230
; Pentagon:
;       Pentagon 128            241
;       Pentagon 512            241
;       Pentagon 1024 SL        227
; ZS Rechearch:
;       Leningrad               184
;       Scorpion ZS-256         151
;       Scorpion ZS-256 Turbo+  215
; Microdigital:
;       Tk90x pt-BR              73
;       Tk90x es-AR             233
;       Tk95  pt-BR              72
;       Tk95  es-AR             233
; ATM:
;       ATM-Turbo               215
;       ATM-Turbo 2+            176
; Otros:
;       Orel BK-08               ¿?
;       Dubna 48K                15
;       HC-91                   230
;       BK-001                  105
;       Foton-Ik03               ¿?
;       Alf TV Game (Elf)        ¿?
;       Vesta IK-30             184
; Mods:
;       +3e                     230
;       +3e es                  230
;       +2e                     230
;       +2e es                  230
;       Pentagon es             241
; Virtuales:
;       Spec256 48K             216
;       Spect256 128K           230
org  $8000

; Entrada: prepara las interrupciones
main:
ld   hl, isr            ; HL = dirección rutina interrupciones
ld   ($feff), hl        ; Guarda en $feff la dirección
ld   a, $fe             ; de la rutina isr
ld   i, a               ; I = $fe
im   2                  ; Pasa a modo 2 de interrupciones

; Bucle, espera a que swCount sea 1 para empezar a contar
; Cuando swCount es 2, sale del bucle y fin de programa
loop:
ld   a, (swCount)       ; A = indicador para saber si contar
or   a                  ; ¿A = 0?
jr   z, loop            ; Z = sí, salta
cp   $02                ; ¿A = 2?
jr   z, exit            ; Z = sí, salta

ld   hl, counter        ; HL = dirección contador
inc  (hl)               ; Contador+=1

jr   loop               ; Bucle

; Salida del programa
; Pone las interrupciones en modo 1
; Pone el contador en BC para que pueda ser recuperado
; desde BASIC
exit:
im   1                  ; Pasa a modo 1 de interrupciones
ld   b, $00
ld   a, (counter)
ld   c, a               ; BC = contador, para devolver el resultado
ret                     ; Vuelta al BASIC

; Rutina de interrupciones
; En cada interrupción incrementa swCount
isr:
push hl                 ; Preserva HL

ld   hl, swCount
inc  (hl)               ; Incrementa el indicador para saber si contar

pop  hl                 ; Recupera HL

ei                      ; Habilita interrupciones
ret                     ; Sale

; Variables
swCount:                ; Indicador para saber si contar
db $00
counter:                ; Contador
db $00

org  $8000
ld   hl, $4000    ; HL = dirección de inicio de la VideoRAM
ld   bc, $20      ; BC = valor a sumar para pasar al siguiente carácter
ld   a, $08       ; A = para dibujar el primer scanline del primer tercio
loop:
ld   (hl), $aa    ; Carga en pantalla el patrón 10011001
add  hl, bc       ; Avanza HL a la siguiente línea
dec  a            ; Decrementa A
jr   nz, loop     ; Bucle hasta que A llegue a 0
ret               ; Vuelve al Basic
end  $8000

; ----------------------------------------------------------------
; CharCoord2PointerHR: Obtiene la dirección de memoria 
; correspondiente a las coordenadas de carácter especificadas. 
; 
; Entrada: B -> Coordenada Y (0 a 23).
;          C -> Coordenada X (0 a 31).
; 
; Salida:  HL -> Dirección de memoria que corresponde a las
;               coordenadas. 010T TSSS LLLC CCCC. 
;
; Altera el valor de los registros AF y HL.
; ----------------------------------------------------------------- 
CharCoord2PointerHR:
ld	 a, b      ; A = línea. Bits 0, 1 y 2 línea. Bits 3 y 4 tercio.
and  $18       ; Se queda con el tercio 0001 1000. 
               ; Scanline siempre a 0.
or 	 $40       ; Agrega la parte fija 0100 0000.
ld 	 h, a      ; H = A. Parte alta de la dirección calculada.
ld 	 a, b      ; A = línea.
and  $07       ; Se queda con la línea dentro del tercio.
rrca
rrca
rrca           ; Rota tres veces para pasar valor a bits 5, 6 y 7.
or 	 c         ; Agrega la columna.
ld 	 l, a      ; L = A. Parte baja de la dirección calculada.
ret

org $8000

ld   b, $10                   ; Carga en B la línea.
ld   c, $10                   ; Carga en C la columna.
call CharCoord2PointerHR      ; Calcula la posición de memoria.
ld   (hl), $ff                ; Activa todos los píxeles en la
                              ; posición de memoria.

inc  b                        ; Incrementa la línea.
inc  c                        ; Incrementa la columna.
call CharCoord2PointerHR      ; Calcula la posición de memoria.
ld   (hl), $ff                ; Activa todos los píxeles en la
                              ; posición de memoria.

inc  b                        ; Incrementa la línea.
dec  c                        ; Decrementa la columna.
call CharCoord2PointerHR      ; Calcula la posición de memoria.
ld   (hl), $ff                ; Activa todos los píxeles en la
                              ; posición de memoria.

ret

end	 $8000

; ---------------------------------------------------------------- 
; PointerHR2CharCoord: Obtiene las coordenadas de carácter
; correspondientes a la dirección de memoria especificada.
;
; Entrada: HL -> Puntero a memoria. 010T TSSS LLLC CCCC.
;
; Salida:  B -> Coordenada Y (0 a 23).
;          C -> Coordenada X (0 a 31).
;
; Altera el valor de los registros AF y BC.  
; ---------------------------------------------------------------- 
PointerHR2CharCoord: 
ld   a, h     ; A = parte alta de la dirección de memoria. 010T TSSS.
and  $18      ; Se queda con el tercio. Bits 4 y 5 de la
              ; coordenada Y. Scanline siempre a 0, son coordenadas
              ; de carácter.
ld   b, a     ; B = A.

ld   a, l     ; A = parte baja de la dirección de memoria. LLLC CCCC.
and  $e0      ; Se queda con la línea dentro del tercio.
rrca
rrca
rrca          ; Rota tres veces para pasar valor a bits 0, 1 y 3.
or   b        ; Agrega los bits 4 y 5.
ld   b, a     ; B = A. Coordenada Y calculada.

ld   a, l     ; A = parte baja de la dirección de memoria. LLLC CCCC.
and  $1f      ; Se queda con la columna.
ld   c, a     ; C = A. Coordenada X calculada.

ret

; ----------------------------------------------------------------
; PointerHRNextLine: obtiene la dirección de memoria
; correspondiente a la siguiente línea.
;
; Entrada: HL -> Dirección actual. 010T TSSS LLLC CCCC.
;
; Salida:  HL -> Dirección de la línea siguiente.
;               010T TSSS LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerHRNextLine:
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
add  a, $20   ; Añade una línea (LLLC CCCC + 0010 0000).
ld   l, a     ; L = A.
ret  nc       ; Si no hay acarreo, la línea sigue entre 0 y 7, sale.

; Hay acarreo, hay que cambiar el tercio de la pantalla.
ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
add  a, $08   ; Añade un tercio (010T TSSS + 0000 1000).
ld   h, a     ; H = A.

ret

; ----------------------------------------------------------------
; PointerHRPreviousLine: obtiene la dirección de memoria
; correspondiente a la línea anterior de carácter.
;
; Entrada: HL -> Dirección actual. 010T TSSS LLLC CCCC.
;
; Salida:  HL -> Dirección de la línea anterior.
;                010T TSSS LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerHRPreviousLine:
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
and  $e0      ; Se queda con la parte de la línea (1110 0000).
jr   z, PointerHRPreviousLine_continue   ; Si línea es 0,
                                       ; cambio de tercio.

; No hay cambio de tercio.
ld   a, l     ; A = parte baja de la dirección, LLLC CCCC.
sub  $20      ; Resta una línea (LLLC CCCC - 0010 0000).
ld   l, a     ; L = A. Dirección calculada.

ret

PointerHRPreviousLine_continue:
; Hay que cambiar el tercio.
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
or   $e0      ; Pone la línea a 7 (LLLC CCCC or 1110 0000).
ld   l, a     ; L = A. Parte baja de la dirección calculada.

ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
sub  $08      ; Resta uno al tercio (010T TSSS - 0000 1000).
ld   h, a     ; H = A. Parte baja de la dirección calculada.

ret
; ----------------------------------------------------------------
; PointerHRPreviousLine: obtiene la dirección de memoria
; correspondiente a la línea anterior de carácter.
;
; Entrada: HL -> Dirección actual. 010T TSSS LLLC CCCC.
;
; Salida:  HL -> Dirección de la línea anterior.
;                010T TSSS LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerHRPreviousLine:
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
and  $e0      ; Se queda con la parte de la línea (1110 0000).
jr   z, PointerHRPreviousLine_continue ; Si línea es 0,
                                       ; cambio de tercio.

; No hay cambio de tercio.
ld   a, l     ; A = parte baja de la dirección, LLLC CCCC.
sub  $20      ; Resta una línea (LLLC CCCC - 0010 0000).
ld   l, a     ; L = A. Dirección calculada.

ret

PointerHRPreviousLine_continue:
; Hay que cambiar el tercio.
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
or   $e0      ; Pone la línea a 7 (LLLC CCCC or 1110 0000).
ld   l, a     ; L = A. Parte baja de la dirección calculada.

ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
sub  $08      ; Resta uno al tercio (010T TSSS - 0000 1000).
ld   h, a     ; H = A. Parte baja de la dirección calculada.

ret

; ----------------------------------------------------------------
; PointerHRNextScanLine: obtiene la dirección de memoria
; correspondiente al siguiente scanline.
;
; Entrada: HL -> dirección actual. 010T TSSS LLLC CCCC.
;
; Salida:  HL -> dirección del siguiente scanline.
;                010T TSSS LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerHRNextScanLine:
ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
and  $07      ; Se queda con el scanline.
cp   $07      ; Comprueba si el scanline es 7.
jr   z, PointerHRNextScanLine_continue ; Es 7, cambio de línea.

; El scanline no es 7.
inc  h       ; Aumenta en 1 el scanline y sale.

ret

PointerHRNextScanLine_continue:
; Hay que cambiar la línea.
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
add  a, $20   ; Añade una línea (LLLC CCCC + 0010 0000).
ld   l, a     ; L = A.
ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
jr   nc, PointerHRNextScanLine_end ; Si no hay acarreo, salta
                                   ; para terminar el cálculo.

; Hay acarreo, hay que cambiar el tercio.
add  a, $08   ; Añade uno al tercio (010T TSSS + 0000 1000).

PointerHRNextScanLine_end:
and  $f8      ; Se queda con la parte fija y el tercio.
              ; Deja el scanline a 0.
ld   h, a     ; H = A. Dirección calculada.

ret

org  $8000

ld   hl, $4000    ; HL = dirección de inicio de la VideoRAM.
ld   b, $08       ; B = para dibujar 8 scanlines.

loop:
ld   (hl), $aa    ; Carga en pantalla el patrón $AA.
call PointerHRNextScanLine  ; Avanza al siguiente scanline.
djnz loop         ; Bucle hasta que B llegue a 0.

ret

end	 $8000

; ----------------------------------------------------------------
; PointerHRPreviousScanLine: obtiene la dirección de memoria
; correspondiente al scanline anterior.
;
; Entrada: HL -> dirección actual. 010T TSSS LLLC CCCC.
;
; Salida:  HL -> Dirección del scanline anterior.
;                010T TSSS LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerHRPreviousScanLine:
ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
and  $07      ; Se queda con el scanline.
or   a        ; Comprueba si está a 0.
jr   z, PointerHRPreviousScanLine_continue  ; Si es 0, cambiar línea.

; No hay cambio de línea.
dec  h        ; Decrementa el scanline y sale.

ret

PointerHRPreviousScanLine_continue:
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
and  $e0      ; Se queda con la parte de la línea.
or   a        ; Comprueba si está a cero.
jr   z, PointerHRPreviousScanLine_change  ; Si es 0, cambiar tercio.

; No hay que cambiar tercio.
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
sub  $20      ; Resta un línea, (LLLC CCCC - 0010 0000).
ld   l, a     ; L = A.
jr   PointerHRPreviousScanLine_end  ; Salta a fin de cálculo.

PointerHRPreviousScanLine_change:
; Hay que cambiar de tercio.
ld   a, l     ; A = parte baja de la dirección. LLLC CCCC.
or   $e0      ; Pone la línea en 7.
ld   l, a     ; L = A.

ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
sub  $08      ; Resta uno al tercio.
ld   h, a     ; H = A.

PointerHRPreviousScanLine_end:
ld   a, h     ; A = parte alta de la dirección. 010T TSSS.
and  $F8      ; Se queda con la parte fija y el tercio.
or   $07      ; Pone el scanline a 7.
ld   h, a     ; H = A.

ret

org  $8000

ld   hl, $57ff    ; HL = dirección de fin de la VideoRAM.
ld   b, $08       ; B = para dibujar 8 scanlines.

loop:
ld   (hl), $aa    ; Carga en pantalla el patrón $AA.
call PointerHRPreviousScanLine  ; Retrocede al scanline anterior.
djnz loop         ; Bucle hasta que B llegue a 0.

ret

end	 $8000

; ----------------------------------------------------------------
; CharCoord2PointerAttr: toma unas coordenadas de carácter y obtiene
; la dirección de memoria del atributo correspondiente.
;
; Entrada: B -> coordenada Y
;          C -> coordenada X
;
; Salida:  HL -> Dirección de memoria del atributo.
;                0101 10TT LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
CharCoord2PointerAttr:
ld   a, b    ; Carga la línea en A
and  $18     ; Se queda con los bits del tercio
rrca
rrca
rrca         ; Los pasa a los bits 0 y 1
or   $58     ; Añade los bits fijos de la parte alta de la dirección
ld   h, a    ; H = 0101 10TT
ld   a, b    ; Carga la línea en A
and  $07     ; Se queda con los bits de la línea
rrca
rrca
rrca         ; Los pasa a los bits 5, 6, y 7
or   c       ; Añade los bits de la columna
ld   l, a    ; L = LLLC CCCC

ret          ; HL = 0101 10TT LLLC CCCC (dirección del atributo)

; ----------------------------------------------------------------
; CharCoord2PointerAttr: toma unas coordenadas de carácter y obtiene
; la dirección de memoria del atributo correspondiente.
;
; Entrada: B -> coordenada Y
;          C -> coordenada X
;
; Salida:  HL -> Dirección de memoria del atributo.
;                0101 10TT LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
CharCoord2PointerAttr:
ld   a, b    ; Carga la línea en A
; Antes de quedarnos con los bits del tercio, realizamos las rotaciones
rrca
rrca         ; Pasa los bits del tercio a los bits 0 y 1
rrca         ; y los de la línea a los bits 5, 6 y 7
ld   l, a    ; Carga el resultado en L
and  $03     ; A = bits del tercio
or   $58     ; Añade los bits fijos de la parte alta de la dirección
ld   h, a    ; H = 0101 10TT
ld   a, l    ; A = línea en bits 5, 6 y 7 y tercio en bits 0 y 1
and  $e0     ; Se queda con los bits de la línea
or   c       ; Añade los bits de la columna
ld   l, a    ; L = LLLC CCCC

ret          ; HL = 0101 10TT LLLC CCCC (dirección del atributo)

; ----------------------------------------------------------------
; PointerAttr2CharCoord: toma una dirección de memoria de atributo 
; y devuelve las coordenadas de carácter correspondientes.
;
; Entrada:  HL -> Dirección de memoria del atributo.
;                0101 10TT LLLC CCCC.
;
; Salida:   B -> coordenada Y
;           C -> coordenada X
;
; Altera el valor de los registros AF y BC.
; ---------------------------------------------------------------- 
PointerAttr2CharCoord:
ld   a, h    ; Carga la parte alta de la dirección en A
and  $03     ; Se queda con los bits del tercio
rlca
rlca
rlca         ; Los pasa a los bits 3 y 4
ld   b, a    ; B = 000TT000
ld   a, l    ; Carga la parte baja de la dirección en A
and  $e0     ; Se queda con los bits de la línea
rlca
rlca
rlca         ; Los pasa a los bits 0, 1 y 2
or   b       ; Añade el tercio
ld   b, a    ; B = TTLLL (coordenada Y)
ld   a, l    ; Carga la parte baja de la dirección en A
and  $1f     ; Se queda con los bits de la columna
ld   c, a    ; C = 000CCCCC (coordenada X)

ret          ; BC = coordenadas de carácter

; ----------------------------------------------------------------
; PointerHR2PointerAttr: toma una dirección de memoria del área gráfica 
; y devuelve la dirección de memoria del atributo correspondiente.
;
; Entrada: HL -> Dirección de memoria del área gráfica.
;                010T TSSS LLLC CCCC.
;
; Salida:  HL -> Dirección de memoria del atributo.
;                0101 10TT LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerHR2PointerAttr:
ld   a, h    ; Carga en A la parte alta de la dirección
and  $18     ; Se queda con los bits del tercio
rrca
rrca
rrca         ; Los pasa a los bits 0 y 1
or   $58     ; Añade la parte fija
ld   h, a    ; A = 010110TT

ret          ; HL = dirección de memoria del atributo

; ----------------------------------------------------------------
; PointerAttr2PointerHR: toma una dirección de memoria de atributo
; y devuelve la dirección de memoria del área gráfica correspondiente
; al primer scanline.
;
; Entrada: HL -> Dirección de memoria del atributo.
;                0101 10TT LLLC CCCC.
;
; Salida:  HL -> Dirección de memoria del área gráfica.
;                010T TSSS LLLC CCCC.
;
; Altera el valor de los registros AF y HL.
; ---------------------------------------------------------------- 
PointerAttr2PointerHR:
ld   a, h    ; Carga en A la parte alta de la dirección
and  $03     ; Se queda con los bits del tercio
rlca
rlca
rlca         ; Los pasa a los bits 3 y 4
or   $40     ; Añade la parte fija
ld   h, a    ; A = 010TT000

ret          ; HL = dirección del primer scanline

MaxTies:        db $05                  ; Máximo tablas

TitleOptionTies:    db $10, INK7, $16, $10, $08, "4. ", $10, INK6
                    defm "Tablas"

jr      nz, menu_Ties           ; No, salta

menu_Ties:  
cp      KEY4                    ; ¿Pulsado 4?
jr      nz, menu_op             ; No, bucle
ld      a, (MaxTies)            ; A = tablas
add     a, $02                  ; A += 2
cp      $0a                     ; ¿A < 10?
jr      c, menu_TiesDo          ; Sí, salta
ld      a, $03                  ; A = 3
menu_TiesDo:
ld      (MaxTies), a            ; Actualiza tablas
jr      menu_op                 ; Bucle

ld      a, (MaxTies)            ; A = máximo tablas
ld      b, a                    ; B = A

call    PrintBCD        ; Lo pinta
ld      b, INI_TOP-$10  ; B = coord Y
call    AT              ; Posiciona cursor
ld      hl, MaxTies     ; HL = valor tiempo

; -------------------------------------------------------------------
; Comprueba si hay tablas.
; Para poder comprobar si hay tablas.
;
; Salida:   Z   ->  No hay tablas.
;           NZ  ->  Hay tablas.
;
; Altera el valor de los registros AF, BC, DE, HL e IX.
; -------------------------------------------------------------------
CheckTies:
ld      b, $f0              ; B = máscara celdas un jugador
ld      c, $0f              ; B = máscara celdas otro jugador

checkTies_check123:
ld      hl, Grid            ; HL = dirección grid
ld      a, (hl)             ; A = valor celda 1
inc     hl                  ; HL = dirección celda 2
add     a, (hl)             ; A+= valor celda 2
inc     hl                  ; HL = dirección celda 3
add     a, (hl)             ; A+= valor celda 2
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check456:
inc     hl                  ; A = dirección celda 4
ld      a, (hl)             ; A = valor celda 4
inc     hl                  ; HL = dirección celda 5
add     a, (hl)             ; A+= valor celda 5
inc     hl                  ; HL = dirección celda 6
add     a, (hl)             ; A+= valor celda 6
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check789:
inc     hl                  ; A = dirección celda 7
ld      a, (hl)             ; A = valor celda 7
inc     hl                  ; HL = dirección celda 8
add     a, (hl)             ; A+= valor celda 8
inc     hl                  ; HL = dirección celda 9
add     a, (hl)             ; A+= valor celda 9
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check147:
ld      ix, Grid-$01        ; IX = dirección  Grid - 1
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$04)         ; A+= valor celda 4
add     a, (ix+$07)         ; A+= valor celda 7
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check258:
ld      a, (ix+$02)         ; A = valor celda 2
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$08)         ; A+= valor celda 8
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check369:
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$06)         ; A+= valor celda 6
add     a, (ix+$09)         ; A+= valor celda 9
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check159:
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$09)         ; A+= valor celda 9
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret     z                   ; Ninguna, sale

checkTies_check357:
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$07)         ; A+= valor celda 7
ld      d, a                ; Preserva A en D
and     b                   ; A = celdas ocupadas por un jugador
ret     z                   ; Ninguna, sale
ld      a, d                ; Recupera A desde D
and     c                   ; A = celdas ocupadas por otro jugador
ret                         ; Sale con Z en estado correcto

ld      a, $09                  ; A = 9
cp      (hl)                    ; ¿Contador = 9?
jr      nz, loop_cont           ; No, salta

call    CheckTies               ; ¿Algún movimiento posible?
jr      z, loop_cont            ; No, salta

ld      a, (ix+1)               ; A = celda 1
add     a, (ix+2)               ; A+= celda 2
add     a, (ix+3)               ; A+= celda 3

ld      hl, Grid                ; HL = dirección celda 1
ld      a, (hl)                 ; A = valor celda 1
inc     hl                      ; HL = dirección celda 2
add     a, (hl)                 ; A+= valor celda 2
inc     hl                      ; HL = dirección celda 3
add     a, (hl)                 ; A+= valor celda 3

ld      a, (ix+4)               ; A = celda 4
add     a, (ix+5)               ; A+= celda 5
add     a, (ix+6)               ; A+= celda 6

inc     hl                      ; HL = dirección celda 4
ld      a, (hl)                 ; A = valor celda 4
inc     hl                      ; HL = dirección celda 5
add     a, (hl)                 ; A+= valor celda 5
inc     hl                      ; HL = dirección celda 6
add     a, (hl)                 ; A+= valor celda 6

ld      a, (ix+7)               ; A = celda 7
add     a, (ix+8)               ; A+= celda 8
add     a, (ix+9)               ; A+= celda 9

inc     hl                      ; HL = dirección celda 7
ld      a, (hl)                 ; A = valor celda 7
inc     hl                      ; HL = dirección celda 8
add     a, (hl)                 ; A+= valor celda 8
inc     hl                      ; HL = dirección celda 9
add     a, (hl)                 ; A+= valor celda 9

ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$02)         ; A+= valor celda 2
add     a, (ix+$03)         ; A+= valor celda 3

ld      hl, Grid            ; HL = dirección celda 1
ld      a, (hl)             ; A = valor celda 1
inc     hl                  ; HL = dirección celda 2
add     a, (hl)             ; A+= valor celda 2
inc     hl                  ; HL = dirección celda 3
add     a, (hl)             ; A+= valor celda 3

ld      a, (ix+$04)         ; A = valor celda 4
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$06)         ; A+= valor celda 6

ld      hl, Grid+$03        ; HL = dirección celda 4
ld      a, (hl)             ; A = valor celda 4
inc     hl                  ; HL = dirección celda 5
add     a, (hl)             ; A+= valor celda 5
inc     hl                  ; HL = dirección celda 6
add     a, (hl)             ; A+= valor celda 6

ld      a, (ix+$07)         ; A = valor celda 7
add     a, (ix+$08)         ; A+= valor celda 8
add     a, (ix+$09)         ; A+= valor celda 9

ld      hl, Grid+$06        ; HL = dirección celda 7
ld      a, (hl)             ; A = valor celda 7
inc     hl                  ; HL = dirección celda 8
add     a, (hl)             ; A+= valor celda 8
inc     hl                  ; HL = dirección celda 9
add     a, (hl)             ; A+= valor celda 9

ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$02)         ; A+= valor celda 2
add     a, (ix+$03)         ; A+= valor celda 3

ld      hl, Grid            ; HL = dirección celda 1
ld      a, (hl)             ; A = valor celda 1
inc     hl                  ; HL = dirección celda 2
add     a, (hl)             ; A+= valor celda 2
inc     hl                  ; HL = dirección celda 3
add     a, (hl)             ; A+= valor celda 3

ld      a, (ix+$04)         ; A = valor celda 4
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$06)         ; A+= valor celda 6

ld      hl, Grid+$03        ; HL = dirección celda 4
ld      a, (hl)             ; A = valor celda 4
inc     hl                  ; HL = dirección celda 5
add     a, (hl)             ; A+= valor celda 5
inc     hl                  ; HL = dirección celda 6
add     a, (hl)             ; A+= valor celda 6

ld      a, (ix+$07)         ; A = valor celda 7
add     a, (ix+$08)         ; A+= valor celda 8
add     a, (ix+$09)         ; A+= valor celda 9

ld      hl, Grid+$06        ; HL = dirección celda 7
ld      a, (hl)             ; A = valor celda 7
inc     hl                  ; HL = dirección celda 8
add     a, (hl)             ; A+= valor celda 8
inc     hl                  ; HL = dirección celda 9
add     a, (hl)             ; A+= valor celda 9

ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$04)         ; A+= valor celda 4

ld      hl, Grid+$02        ; A = dirección celda 3
ld      a, (hl)             ; A = valor celda 3
inc     hl                  ; HL = dirección celda 4
add     a, (hl)             ; A+= valor celda 4

ld      a, (ix+$06)         ; A = valor celda 6
add     a, (ix+$07)         ; A+= valor celda 7

ld      hl, Grid+$05        ; A = dirección celda 6
ld      a, (hl)             ; A = valor celda 6
inc     hl                  ; HL = dirección celda 7
add     a, (hl)             ; A+= valor celda 7

; -------------------------------------------------------------------
; Fichero: Sprite.asm
;
; Definición de los gráficos.
; -------------------------------------------------------------------
; Sprite de la cruceta
Sprite_CROSS:
db $18, $18, $18, $ff, $ff, $18, $18, $18   ; $90

; Sprite de la línea vertical
Sprite_SLASH:
db $18, $18, $18, $18, $18, $18, $18, $18   ; $91

; Sprite de la línea hortizontal
Sprite_MINUS:
db $00, $00, $00, $ff, $ff, $00, $00, $00   ; $92

; Sprite del jugador 1
Sprite_P1:
db $c0, $e0, $70, $38, $1c, $0e, $07, $03   ; $93
db $03, $07, $0e, $1c, $38, $70, $e0, $c0   ; $94

; ; Sprite del jugador 2
; Sprite_P2:
; db $03, $0f, $1c, $30, $60, $60, $c0, $c0 ; $95 Arriba/Izquierda
; db $c0, $f0, $38, $0c, $06, $06, $03, $03 ; $96 Arriba/Derecha
; db $c0, $c0, $60, $60, $30, $1c, $0f, $03 ; $97 Abajo/Izquierda
; db $03, $03, $06, $06, $0c, $38, $f0, $c0 ; $98 Abajo/Derecha

; Líneas verticales del tablero.
Board_1:
db $12, $00, $13, $00        
db $20, $20, $20, $20, $91, $20, $20, $20, $20, $91, $20, $20, $20
db $20, $ff

; Líneas horizontales del tablero.
Board_2:        
db $92, $92, $92, $92, $90, $92, $92, $92, $92, $90, $92, $92, $92
db $92, $ff

ld      hl, Sprite_P1       ; HL = dirección Sprite_P1

ld      hl, Sprite_CROSS    ; HL = dirección Sprite_CROSS

ld      a, $95              ; A = 1er sprite
ld      a, $98              ; A = 4º sprite

ld      a, $93              ; A = 1er sprite

ld      a, $96              ; A = 2º sprite
ld      a, $97              ; A = 3er sprite

ld      a, $94              ; A = 2º sprite

printOXO_X:
ld      a, INKPLAYER1       ; A = tinta jugador 1
call    INK                 ; Cambia tinta
ld      a, $93              ; A = 1er sprite
rst     $10                 ; Lo pinta
ld      a, $94              ; A = 2º sprite
rst     $10                 ; Lo pinta
dec     b                   ; B = línea inferior
call    AT                  ; Posiciona cursor
ld      a, $94              ; A = 2º sprite
rst     $10                 ; Lo pinta
ld      a, $93              ; A = 2º sprite
rst     $10                 ; Lo pinta
ret                         ; Sale

printOXO_Y:
ld      a, INKPLAYER2       ; A = tinta jugador 2
call    INK                 ; Cambia tinta
;ld      a, $95              ; A = 1er sprite
ld      a, $93              ; A = 1er sprite
rst     $10                 ; Lo pinta
;ld      a, $96              ; A = 2º sprite
ld      a, $94              ; A = 2º sprite
rst     $10                 ; Lo pinta
dec     b                   ; B = línea inferior
call    AT                  ; Posiciona cursor
;ld      a, $97              ; A = 3er sprite
ld      a, $94              ; A = 2º sprite
rst     $10                 ; Lo pinta
;ld      a, $98              ; A = 4º sprite
ld      a, $93              ; A = 1er sprite
rst     $10                 ; Lo pinta
ret                         ; Sale

player1_figure:     db $16, $04, $00, $90, $91, $0d, $91, $90

player1_figure:     db $16, $04, $00, $93, $94, $0d, $94, $93

player2_figure:     db $16, $04, $1b, $92, $93
                    db $16, $05, $1b, $94, $95, $ff

player2_figure:     db $16, $04, $1b, $93, $94
                    db $16, $05, $1b, $94, $93, $ff

; player2_figure:     db $16, $04, $1b, $95, $96
;                     db $16, $05, $1b, $97, $98, $ff

; -------------------------------------------------------------------
; Movimiento defensivo de esquina.
; -------------------------------------------------------------------
zxMoveDefence_corner24:
ld      a, (ix+$02)         ; A = valor celda 2
add     a, (ix+$04)         ; A+= valor celda 4
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_corner26  ; No, salta
ld      c, KEY1             ; C = tecla 1
call    ToMove              ; Mueve a celda 1
ret     z                   ; Si es correcto, sale

zxMoveDefence_corner26:
ld      a, (ix+$02)         ; A = valor celda 2
add     a, (ix+$06)         ; A+= valor celda 6
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_corner84  ; No, salta
ld      c, KEY3             ; C = tecla 3
call    ToMove              ; Mueve a celda 3
ret     z                   ; Si es correcto, sale
zxMoveDefence_corner84:
ld      a, (ix+$08)         ; A = valor celda 8
add     a, (ix+$04)         ; A+= valor celda 4
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_corner86  ; No, salta
ld      c, KEY7             ; C = tecla 7
call    ToMove              ; Mueve a celda 3
ret     z                   ; Si es correcto, sale
zxMoveDefence_corner86:
ld      a, (ix+$08)         ; A = valor celda 8
add     a, (ix+$06)         ; A+= valor celda 6
cp      b                   ; ¿A = B?
jr      nz, zxMoveAttack_123    ; No, salta
ld      c, KEY9             ; C = tecla 9
call    ToMove              ; Mueve a celda nueve
ret     z                   ; Si es correcto, sale

jr      nz, zxMoveDefence_corner24  ; No, no mov cruz, salta

Level:          db $02              ; Nivel de dificultad

TitleOptionStart:   db $10, INK1, $13, $01, $16, $07, $08, "0. "
                    db $10, INK5
                    defm "Empezar"
TitleOptionPlayer:  db $10, INK7, $13, $01, $16, $09, $08, "1. "
                    db $10, INK6
                    defm "Jugadores"
TitleOptionPoint:   db $10, INK7, $16, $0b, $08, "2. ", $10, INK6
                    defm "Puntos"
TitleOptionTime:    db $10, INK7, $16, $0d, $08, "3. ", $10, INK6
                    defm "Tiempo"
TitleOptionTies:    db $10, INK7, $16, $0f, $08, "4. ", $10, INK6
                    defm "Tablas"

TitleOptionLevel:   db $10, INK7, $16, $11, $08, "5. ", $10, INK6
                    defm "Dificultad"

call    PrintBCD        ; Lo pinta
ld      b, INI_TOP-$11  ; B = coord Y
call    AT              ; Posiciona cursor
ld      hl, Level       ; HL = valor dificultad

; -------------------------------------------------------------------
; Pinta los valores de las opciones.
;
; Altera el valor de los registros AF, BC y HL.
; -------------------------------------------------------------------
PrintOptions:
ld      a, INK4         ; A = tinta verde
call    INK             ; Cambia tinta
ld      b, INI_TOP-$09  ; B = coord Y
ld      c, INI_LEFT-$15 ; C = coord X
call    AT              ; Posiciona cursor
ld      hl, MaxPlayers  ; HL = valor jugadores
call    PrintBCD        ; Lo pinta
ld      b, INI_TOP-$0b  ; B = coord Y
call    AT              ; Posiciona cursor
ld      hl, MaxPoints   ; HL = valor puntos
call    PrintBCD        ; Lo pinta
ld      b, INI_TOP-$0d  ; B = coord Y
call    AT              ; Posiciona cursor
ld      hl, seconds     ; HL = valor tiempo
call    PrintBCD        ; Lo pinta
ld      b, INI_TOP-$0f  ; B = coord Y
call    AT              ; Posiciona cursor
ld      hl, MaxTies     ; HL = valor tiempo
call    PrintBCD        ; Lo pinta
ld      b, INI_TOP-$11  ; B = coord Y
call    AT              ; Posiciona cursor
ld      hl, Level       ; HL = valor dificultad
jp      PrintBCD        ; Lo pinta y sale

jr      nz, menu_Level      ; No, bucle

menu_Level:
cp      KEY5                    ; ¿Pulsado 5?
jr      nz, menu_op             ; No, bucle
ld      a, (Level)              ; A = dificultad
xor     $03                     ; Alterna entre 1 y 2
ld      (Level), a              ; Actualiza en memoria
jr      menu_op                 ; Bucle

ld      a, (Level)          ; A = dificultad
cp      $01                 ; ¿Dificultad = 1?
jr      z, zxMoveAttack_123 ; Sí, salta

 10 CLEAR 24200
 20 INK 0: PAPER 4: BORDER 4: CLS
 30 POKE 23610,255: POKE 23739,111
 40 LOAD ""CODE 24200
 50 LOAD ""CODE 24250
 60 RANDOMIZE USR 24200
 70 LOAD ""CODE 24200
 80 LOAD ""CODE 32348
 90 CLS
100 RANDOMIZE USR 24200

; -------------------------------------------------------------------
; LoadScr.asm
;
; La pantalla de carga se cargará en $5eba, y esta rutina la pasará
; a la VideoRAM para que aparezca de golpe y luego limpiará la zona
; dónde se había cargado inicialmente.
; La limpieza de ese área de memoria no es necesaria, pero lo hacemos
; por si tenemos que depurar, no encontrar código que en realidad sean
; restos de la pantalla de carga.
; -------------------------------------------------------------------
org     $5e88               ; Dirección de carga

ld      hl, $5eba           ; HL = dirección dónde está la pantalla
ld      de, $4000           ; DE = dirección VideoRAM
ld      bc, $1b00           ; Longitud de la pantalla
ldir                        ; Vuelca la pantalla

ld      hl, $5eba           ; HL = dirección dónde está la pantalla
ld      de, $5ebb           ; Dirección siguiente
ld      bc, $1aff           ; Longitud de la pantalla - 1
ld      (hl), $00           ; Limpia la primera posición
ldir                        ; Limpia el resto

ret

echo off
cls
echo Compilando oxo
pasmo --name TresEnRaya --tap Main.asm oxo.tap oxo.log
echo Compilando int
pasmo --name Int --tap Int.asm int.tap int.log
echo Compilando loadscr
pasmo --name LoadScr --tap LoadScr.asm loadscr.tap loadscr.log
echo Generando TresEnRaya
copy /b /y cargador.tap+loadscr.tap+TresEnRayaScr.Tap+oxo.tap+int.tap TresEnRaya.tap
echo Proceso finalizado

clear
echo Compilando oxo
pasmo --name TresEnRaya --tap Main.asm oxo.tap oxo.log
echo Compilando int
pasmo --name Int --tap Int.asm int.tap int.log
echo Compilando loadscr
pasmo --name LoadScr --tap LoadScr.asm loadscr.tap loadscr.log
echo Generando TresEnRaya
cat cargador.tap loadscr.tap TresEnRayaScr.Tap oxo.tap int.tap > TresEnRaya.tap
echo Proceso finalizado

; -------------------------------------------------------------------
; Obtiene un número pseudo aleatorio entre 1 y 9.
;
; Retorno:  A   ->  Número obtenido.
; -------------------------------------------------------------------
GetRandomN:
ld      a, r                ; A = R
and     $0f                 ; Deja bits 0 a 3
inc     a                   ; A+=1
cp      $0a                 ; ¿A > 9?
ret     c                   ; No, sale
rra                         ; A/=2, porque Carry = 0, si no SRL A
ret                         ; Sale

; -------------------------------------------------------------------
; Mueve ZX Spectrum.
;
; Altera el valor de los registros AF, BC e IX.
; -------------------------------------------------------------------
ZxMove:
ld      a, (MoveCounter)    ; A = movimientos
or      a                   ; ¿Movimientos = 0?
jr      nz, zxMove_center   ; No, salta
call    GetRandomN          ; A = número entre 1 y 9
add     a, '0'              ; A = código ascii
ld      c, a                ; C = A
call    ToMove              ; Mueve a celda
ret                         ; Sale
zxMove_center:
cp      $01                 ; ¿Movimientos > 1?
jr      nz, zxMove_cont     ; Sí, salta
ld      c, KEY5             ; C = tecla 5
call    ToMove              ; Mueve a celda 5
ret     z                   ; Si es correcto, sale

zxMove_cont:
ld      ix, Grid-$01        ; IX = dir Grid-1
ld      b, $20              ; B = valor Spectrum puede ganar
call    zxMoveToWin_123     ; Movimiento para ganar Spectrum
ret     z                   ; Si es válido, sale
ld      b, $02              ; B = valor jugador 1 puede ganar
call    zxMoveToWin_123     ; Movimiento para evitarlo
ret     z                   ; Si es válido sale
jp      zxMoveDefence_diagonally ; Movimientos defensivos

; -------------------------------------------------------------------
; Evalúa si el Spectrum tiene movimiento para ganar.
; -------------------------------------------------------------------
zxMoveToWin_123:
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$02)         ; A+= valor celda 2
add     a, (ix+$03)         ; A+= valor celda 3
cp      b                   ; ¿A = B?
jp      nz, zxMoveToWin_456 ; No, salta
; Spectrum puede ganar
ld      c, KEY1             ; C = tecla 1
call    ToMove              ; Mueve a celda 1
ret     z                   ; Si es correcto, sale
inc     c                   ; C = tecla 2
call    ToMove              ; Mueve a celda 2
ret     z                   ; Si es correcto, sale
inc     c                   ; C = tecla 3
call    ToMove              ; Mueve a celda 3
ret                         ; Sale

zxMoveToWin_456:
ld      a, (ix+$04)         ; A = valor celda 4
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$06)         ; A+= valor celda 6
cp      b                   ; ¿A = B?
jr      nz, zxMoveToWin_789 ; No, salta
; Spectrum puede ganar
ld      c, KEY4             ; C = tecla 4
call    ToMove              ; Mueve a celda 4
ret     z                   ; Si es correcto, sale
inc     c                   ; C = tecla 5
call    ToMove              ; Mueve a celda 5
ret     z                   ; Si es correcto, sale
inc     c                   ; C = tecla 6
call    ToMove              ; Mueve a celda 6
ret                         ; Sale

zxMoveToWin_789:
ld      a, (ix+$07)         ; A = valor celda 7
add     a, (ix+$08)         ; A+= valor celda 8
add     a, (ix+$09)         ; A+= valor celda 9
cp      b                   ; ¿A = B?
jr      nz, zxMoveToWin_147 ; No, salta
; Spectrum puede ganar
ld      c, KEY7             ; C = tecla 7
call    ToMove              ; Mueve a celda 7
ret     z                   ; Si es correcto, sale
inc     c                   ; C = tecla 8
call    ToMove              ; Mueve a celda 8
ret     z                   ; Si es correcto, sale
inc     c                   ; C = tecla 9
call    ToMove              ; Mueve a celda 9
ret                         ; Sale

zxMoveToWin_147:
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$04)         ; A+= valor celda 4
add     a, (ix+$07)         ; A+= valor celda 7
cp      b                   ; ¿A=B?
jr      nz, zxMoveToWin_258 ; No, salta
ld      c, KEY1             ; C = tecla 1
call    ToMove              ; Mueve a celda 1
ret     z                   ; Si es correcto, sale
ld      c, KEY4             ; C = tecla 4
call    ToMove              ; Mueve a celda 4
ret     z                   ; Si es correcto, sale
ld      c, KEY7             ; C = tecla 7
call    ToMove              ; Mueve a celda 7
ret                         ; Sale

zxMoveToWin_258:
ld      a, (ix+$02)         ; A = valor celda 2
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$08)         ; A+= valor celda 8
cp      b                   ; ¿A=B?
jr      nz, zxMoveToWin_369 ; No, salta
ld      c, KEY2             ; C = tecla 2
call    ToMove              ; Mueve a celda 2
ret     z                   ; Si es correcto, sale
ld      c, KEY5             ; C = tecla 5
call    ToMove              ; Mueve a celda 5
ret     z                   ; Si es correcto, sale
ld      c, KEY8             ; C = tecla 8
call    ToMove              ; Mueve a celda 8
ret                         ; Sale
    
zxMoveToWin_369:
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$06)         ; A+= valor celda 6
add     a, (ix+$09)         ; A+= valor celda 9
cp      b                   ; ¿A=B?
jr      nz, zxMoveToWin_159 ; No, salta
ld      c, KEY3             ; C = tecla 3
call    ToMove              ; Mueve a celda 3
ret     z                   ; Si es correcto, sale
ld      c, KEY6             ; C = tecla 6
call    ToMove              ; Mueve a celda 6
ret     z                   ; Si es correcto, sale
ld      c, KEY9             ; C = tecla 9
call    ToMove              ; Mueve a celda 9
ret                         ; Sale
    
zxMoveToWin_159:
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$09)         ; A+= valor celda 9
cp      b                   ; ¿A=B?
jr      nz, zxMoveToWin_357 ; No, salta
ld      c, KEY1             ; C = tecla 1
call    ToMove              ; Mueve a celda 1
ret     z                   ; Si es correcto, sale
ld      c, KEY5             ; C = tecla 5
call    ToMove              ; Mueve a celda 5
ret     z                   ; Si es correcto, sale
ld      c, KEY9             ; C = tecla 9
call    ToMove              ; Mueve a celda 9
ret                         ; Sale

zxMoveToWin_357:
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$05)         ; A+= valor celda 5
add     a, (ix+$07)         ; A+= valor celda 7
cp      b                   ; ¿A=B?
ret     nz
ld      c, KEY3             ; C = tecla 3
call    ToMove              ; Mueve a celda 3
ret     z                   ; Si es correcto, sale
ld      c, KEY5             ; C = tecla 5
call    ToMove              ; Mueve a celda 5
ret     z                   ; Si es correcto, sale
ld      c, KEY7             ; C = tecla 7
call    ToMove              ; Mueve a celda 7
ret                         ; Sale

; -------------------------------------------------------------------
; Movimiento defensivo diagonal.
; -------------------------------------------------------------------
zxMoveDefence_diagonally:
; Comprueba si jugador 1 tiene fichas en diagonal
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$09)         ; A+= valor celda 9
cp      b                   ; ¿A = B?
jr      z, zxMoveDefence_crossBlock   ; Sí, mov diagonal, salta
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$07)         ; A+= valor celda 7
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_crossBlock1 ; No, salta

zxMoveDefence_crossBlock:
; Bloqueo en cruz
ld      c, KEY4             ; C = tecla 4
call    ToMove              ; Mueve a celda 4
ret     z                   ; Si es correcto, sale
ld      c, KEY6             ; C = tecla 6
call    ToMove              ; Mueve a celda 6
ret     z                   ; Si es correcto, sale
ld      c, KEY2             ; C = tecla 2
call    ToMove              ; Mueve a celda 2
ret     z                   ; Si es correcto, sale
ld      c, KEY8             ; C = tecla 8
call    ToMove              ; Mueve a celda 8
ret     z                   ; Si es correcto, sale

; -------------------------------------------------------------------
; Movimiento defensivo de diagonal con el centro ocupado.
; -------------------------------------------------------------------
zxMoveDefence_crossBlock1:
ld      a, (ix+$05)         ; A = valor celda 5
and     $0f                 ; A = valor jugador 1
jr      z, zxMoveDefence_cornerBlock16  ; Z = no ocupada, salta
ld      a, (ix+$01)         ; A = valor celda 1
and     $0f                 ; A = valor jugador 1
jr      z, zxMoveDefence_crossBlock3    ; Z = no ocupada, salta
ld      c, KEY7             ; C = tecla 7
call    ToMove              ; Mueve a celda 7
ret     z                   ; Si es correcto, sale

zxMoveDefence_crossBlock3:
ld      a, (ix+$03)         ; A = valor celda 3
and     $0f                 ; A = valor jugador 1
jr      z, zxMoveDefence_crossBlock7    ; Z = no ocupada, salta
ld      c, KEY9             ; C = tecla 9
call    ToMove              ; Mueve a celda 9
ret     z                   ; Si es correcto, sale

zxMoveDefence_crossBlock7:
ld      a, (ix+$07)         ; A = valor celda 7
and     $0f                 ; A = valor jugador 1
jr      z, zxMoveDefence_crossBlock9    ; Z = no ocupada, salta
ld      c, KEY1             ; C = tecla 1
call    ToMove              ; Mueve a celda 1
ret     z                   ; Si es correcto, sale

zxMoveDefence_crossBlock9:
ld      a, (ix+$09)         ; A = valor celda 9
and     $0f                 ; A = valor jugador 1
jr      z, zxMoveDefence_cornerBlock16  ; Z = no ocupada, salta
ld      c, KEY3             ; C = tecla 3
call    ToMove              ; Mueve a celda 3
ret     z                   ; Si es correcto, sale

; -------------------------------------------------------------------
; Movimiento defensivo en cruz.
; -------------------------------------------------------------------
zxMoveDefence_cornerBlock16:
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$06)         ; A+= valor celda 6
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_cornerBlock34 ; No, no mov cruz, salta
ld      c, KEY3             ; C = tecla 3
call    ToMove              ; Mueve a celda 3
ret     z                   ; Si es correcto, sale

zxMoveDefence_cornerBlock34:
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$04)         ; A+= valor celda 4
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_cornerBlock67 ; No, no mov cruz, salta
ld      c, KEY1             ; C = tecla 1
call    ToMove              ; Mueve a celda 1
ret     z                   ; Si es correcto, sale

zxMoveDefence_cornerBlock67:
ld      a, (ix+$06)         ; A = valor celda 6
add     a, (ix+$07)         ; A+= valor celda 7
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_cornerBlock49 ; No, no mov cruz, salta
ld      c, KEY9             ; C = tecla 9
call    ToMove              ; Mueve a celda 9
ret     z                   ; Si es correcto, sale

zxMoveDefence_cornerBlock49:
ld      a, (ix+$04)         ; A = valor celda 4
add     a, (ix+$09)         ; A+= valor celda 9
cp      b                   ; ¿A = B?
jr      nz, zxMoveDefence_cornerBlock1827 ; No, no mov cruz, salta
ld      c, KEY7             ; C = tecla 7
call    ToMove              ; Mueve a celda 7
ret     z                   ; Si es correcto, sale

zxMoveDefence_cornerBlock1827:
ld      a, (ix+$01)         ; A = valor celda 1
add     a, (ix+$08)         ; A+= valor celda 8
cp      b                   ; ¿A = B?
jr      z, zxMoveDefence_cornerBlock1827Cont ; Sí, mov cruz, bloquear
ld      a, (ix+$02)         ; A = valor celda 2
add     a, (ix+$07)         ; A+= Valor celda 7
cp      b                   ; ¿ A= B?
jr      nz, zxMoveDefence_cornerBlock2938 ; No, no mov cruz, salta

zxMoveDefence_cornerBlock1827Cont:
ld      c, KEY4             ; C = tecla 4
call    ToMove              ; Mueve a celda 4
ret     z                   ; Si es correcto, sale

zxMoveDefence_cornerBlock2938:
ld      a, (ix+$02)         ; A = valor celda 2
add     a, (ix+$09)         ; A+= valor celda 9
cp      b                   ; ¿A = B?
jr      z, zxMoveDefence_cornerBlock2938Cont ; Sí, mov cruz, bloquear
ld      a, (ix+$03)         ; A = valor celda 3
add     a, (ix+$08)         ; A+= valor celda 8
cp      b                   ; ¿A = B?
jr      nz, zxMoveAttack_123 ; No, no mov cruz, salta

zxMoveDefence_cornerBlock2938Cont:
ld      c, KEY6             ; C = tecla 6
call    ToMove              ; Mueve a celda 6
ret     z                   ; Si es correcto, sale