;-----------------------------------------------------------------------
; PrintNum: Imprime en la pantalla un valor en decimal usando la ROM.
; Entrada:  BC = valor a imprimir por pantalla
;-----------------------------------------------------------------------
PrintNum:
    CALL $2D2B               ; ROM_STACK_BC
    CALL $2DE3               ; ROM_PRINT_FP
    RET

;-----------------------------------------------------------------------
; CLS: Borrado de la pantalla con el color indicado en (CLS_COLOR)
; CLSCOLOR: Direccion de memoria de ATTR_P (atributo para CLS)
; BORDER: Cambio del color del borde
; PAUSE: Pausar BC segundos
;-----------------------------------------------------------------------
CLS       EQU  $0DAF               ; ROM_CLS
CLS_COLOR EQU  $5C8D               ; Variable del Sistema ATTR_P
BORDER    EQU  $229B               ; Rutina del borde
PAUSE     EQU  $1F3D               ; PAUSAR BC/50 segundos (50 => 1s)

;-----------------------------------------------------------------------
; PrintChar: Hacer desde nuestro programa "CALL PrintChar", es el
;            equivalente a hacer un "CALL $0010", es decir, RST 16.
;            Es un simple envoltorio de abreviatura (pero ocupa 3 bytes)
; Entrada:   A = caracter a imprimir por pantalla
;-----------------------------------------------------------------------
PrintChar EQU $0010          ; $0010 = RST $10 = RST 16
                             ; Podriamos llamar a $15E6 en su lugar
                             ; que es donde llama internamente $0010.

;-----------------------------------------------------------------------
; PrintSpace y PrintCR: para abreviar codigo, imprimen SPACE o ENTER.
;-----------------------------------------------------------------------
PrintSpace:
    LD A, ' '
    RST 16
    RET

PrintCR:
    LD A, 13
    RST 16
    RET

;-----------------------------------------------------------------------
; CursorAt: Mueve el cursor a la posicion indicada por DE (XY)
;-----------------------------------------------------------------------
CursorAt:
    PUSH AF
    LD A, _AT       ; Codigo control "AT Y,X"
    RST 16
    LD A, E         ; Y
    RST 16
    LD A, D         ; X
    RST 16
    POP AF
    RET

;-----------------------------------------------------------------------
; PrintString: Imprime en la pantalla una cadena acabada en un byte de
;              valor $FF usando RST 16.
; Entrada:     DE = Dirección de la cadena a imprimir.
;              El valor de DE no se preserva (se incrementa)
;-----------------------------------------------------------------------
PrintString:
    LD A, (DE)               ; Leemos el caracter apuntado por DE
    CP $FF                   ; chequeamos si es $FF (fin de cadena)
    RET Z                    ; Si lo es, se activa el ZEROFLAG => SALIR
    RST 16                   ; No lo es, no hemos saltado, imprimirlo
    INC DE                   ; Avanzar al siguiente caracter de la cadena
    JR PrintString           ; Repetir hasta que alguno sea 0 y salgamos

;-----------------------------------------------------------------------
; PrintBin: Imprime en la pantalla un valor en binario usando RST 16.
;           Añade el prefijo '%' delante.
; Entrada: A = valor a imprimir por pantalla en binario
;-----------------------------------------------------------------------
PrintBin:
    PUSH AF
    PUSH BC                  ; Preservamos los registros que se usaran

    LD C, A                  ; Guardamos en C copia de A
    LD B, 8                  ; Imprimiremos el estado de los 8 bits

    LD A, '%'
    RST 16                   ; Imprimir prefijo

printbin_loop:
    LD A, '1'                ; Para bit = 1, imprimiremos '1'
    BIT 7, C                 ; Chequeamos el estado del bit 7
    JR NZ, printbin_es_uno   ; Dejamos A = 255
    LD A, '0'                ; A = '0'

printbin_es_uno:
    RST 16                   ; Imprimimos (A): contiene '0' o '1'
    RLC C                    ; Rotamos C a la izq para que podamos
                             ; usar de nuevo el BIT 7 en el bucle
    DJNZ printbin_loop       ; Repetimos 8 veces

    POP BC
    POP AF
    RET

;-----------------------------------------------------------------------
; PrintHex: Imprime en la pantalla un numero de 1 byte en hexadecimal.
;           Para ello convierte el valor numérico en una cadena llamando
;           a Byte2ASCII_Hex y luego llama a RST 16 para imprimir cada
;           caracter por separado. Imprime un $ delante y ESPACIO detrás.
; Entrada: A = valor a imprimir por pantalla en hexadecimal
;-----------------------------------------------------------------------
PrintHex:
    PUSH HL

    LD H, A                  ; Guardamos A
    LD A, '$'
    RST 16                   ; Imprimimos un "$"

    LD A, H                  ; Recuperamos A

    PUSH AF
    PUSH DE

    CALL Byte2ASCII_Hex      ; Convertimos A en Cadena HEX
    LD HL, Byte2ASCII_output ; HL apunta a la cadena

    LD A, (HL)
    RST 16                   ; Imprimimos primer valor HEX

    INC HL                   ; Avanzar en la cadena
    LD A, (HL)
    RST 16                   ; Imprimimos segundo valor HEX

    POP DE
    POP AF
    POP HL

    RET

;-----------------------------------------------------------------------
; PrintHex16: Imprime en la pantalla un numero de 2 bytes en hexadecimal.
; Entrada: BC = valor a imprimir por pantalla en hexadecimal
;-----------------------------------------------------------------------
PrintHex16:
    PUSH HL
    PUSH AF

    LD A, '$'
    RST 16                   ; Imprimimos un "$"

    LD H, B
    CALL Byte2ASCII_Hex      ; Convertimos A en Cadena HEX
    LD HL, Byte2ASCII_output ; HL apunta a la cadena
    LD A, (HL)
    RST 16                   ; Imprimimos primer valor HEX
    INC HL                   ; Avanzar en la cadena
    LD A, (HL)
    RST 16                   ; Imprimimos segundo valor HEX

    LD H, C
    CALL Byte2ASCII_Hex      ; Convertimos A en Cadena HEX
    LD HL, Byte2ASCII_output ; HL apunta a la cadena
    LD A, (HL)
    RST 16                   ; Imprimimos primer valor HEX
    INC HL                   ; Avanzar en la cadena
    LD A, (HL)
    RST 16                   ; Imprimimos segundo valor HEX

    POP AF
    POP HL
    RET

;-----------------------------------------------------------------------
; Byte2ASCII_Hex: Convierte el valor del registro H en una cadena
; de texto de max. 2 caracteres hexadecimales, para poder imprimirla.
; Rutina adaptada de Num2Hex en http://baze.au.com/misc/z80bits.html .
;
; IN:   H = Numero a convertir
; OUT:  [Byte2ASCII_output] = Espacio de 2 bytes con los ASCIIs
;-----------------------------------------------------------------------
Byte2ASCII_Hex:

    PUSH AF
    PUSH DE
    PUSH HL
    LD DE, Byte2ASCII_output
    LD A, H
    CALL B2AHex_Num1
    LD A, H
    CALL B2AHex_Num2
    JP B2AHex_Exit

B2AHex_Num1:
    RRA
    RRA
    RRA
    RRA

B2AHex_Num2:
    OR $F0
    DAA
    ADD A, $A0
    ADC A, $40
    LD (DE), A
    INC DE
    RET

B2AHex_Exit:
    POP HL
    POP DE
    POP AF
    RET

Byte2ASCII_output DB 0, 0
;-----------------------------------------------------------------------

;-----------------------------------------------------------------------
; PrintFlags: Imprime en la pantalla en binario el registro F (flags).
;-----------------------------------------------------------------------
PrintFlags:
    PUSH AF
    PUSH BC

    PUSH AF            ; Metemos AF en al pila pero sacamos BC
    POP BC             ; Ahora C contiene el valor de F
    LD A, C
    CALL PrintBin
    POP BC
    POP AF
    RET

;-----------------------------------------------------------------------
; PrintFlag: Imprime en la pantalla en binario el flag indicado.
; IN:     A = FLAG a imprimir, con constantes como "FLAG_Z".
;-----------------------------------------------------------------------
PrintFlag:
    PUSH AF
    PUSH BC

    PUSH AF              ; Metemos AF en al pila pero sacamos BC
    POP BC               ; Ahora C contiene el valor de F
                         ; y B contiene el antiguo valor A
    LD A, C
loopPrintFlag:
    RLC A                ; rotamos A veces el bit
    DJNZ loopPrintFlag

    AND %00000001        ; Borramos todos los bits menos bit 0
    ADD A, '0'           ; Sumamos '0' para obtener ASCII

    RST 16
    POP BC
    POP AF
    RET

;-----------------------------------------------------------------------
; WAIT_FOR_KEY: Pausa la ejecución hasta que pulse alguna tecla.
; Devuelve el ASCII de la tecla pulsada en A.
;-----------------------------------------------------------------------
Wait_For_Key:
    LD A, ($5C05)               ; Variable del Sistema KSTATE5
    CP 5
    JR Z, Wait_For_Key          ; Esperar a que != 5 (teclas no pulsadas)
WaitForKeyPressed:
    LD A, ($5C05)               ; Volvemos a leerla
    CP 5
    JR NZ, WaitForKeyPressed    ; Esperar a que valga == 5 (tecla pulsada)
    LD A, ($5C08)               ; Devolver Variable LAST-K en A
    RET

;-----------------------------------------------------------------------
; Constantes definidas para usar con cadenas o RST
;-----------------------------------------------------------------------
_EOS        EQU $FF
_CR         EQU 13
_INK        EQU 16
_PAPER      EQU 17
_FLASH      EQU 18
_BRIGHT     EQU 19
_INVERSE    EQU 20
_OVER       EQU 21
_AT         EQU 22
_TAB        EQU 23

_BLACK      EQU 0
_BLUE       EQU 1
_RED        EQU 2
_MAGENTA    EQU 3
_GREEN      EQU 4
_CYAN       EQU 5
_YELLOW     EQU 6
_WHITE      EQU 7

_FLAG_S     EQU 1
_FLAG_Z     EQU 2
_FLAG_H     EQU 4
_FLAG_PV    EQU 6
_FLAG_N     EQU 7
_FLAG_C     EQU 8