| Ambos lados, revisión anteriorRevisión previaPróxima revisión | Revisión previa |
| cursos:ensamblador:gfx4_fuentes [13-01-2024 11:03] – sromero | cursos:ensamblador:gfx4_fuentes [19-01-2024 08:23] (actual) – sromero |
|---|
| PrintChar_8x8: | PrintChar_8x8: |
| |
| LD BC, (FONT_X) ; B = Y, C = X | ld bc, (FONT_X) ; B = Y, C = X |
| EX AF, AF' ; Nos guardamos el caracter en A' | ex af, af' ; Nos guardamos el caracter en A' |
| |
| ;;; Calculamos las coordenadas destino de pantalla en DE: | ;;; Calculamos las coordenadas destino de pantalla en DE: |
| LD A, B | ld a, b |
| AND $18 | and $18 |
| ADD A, $40 | add a, $40 |
| LD D, A | ld d, a |
| LD A, B | ld a, b |
| AND 7 | and 7 |
| RRCA | rrca |
| RRCA | rrca |
| RRCA | rrca |
| ADD A, C | add a, c |
| LD E, A ; DE contiene ahora la direccion destino. | ld e, a ; DE contiene ahora la direccion destino. |
| |
| ;;; Calcular posicion origen (array sprites) en HL como: | ;;; Calcular posicion origen (array sprites) en HL como: |
| ;;; direccion = base_sprites + (NUM_SPRITE*8) | ;;; direccion = base_sprites + (NUM_SPRITE*8) |
| EX AF, AF' ; Recuperamos el caracter a dibujar de A' | ex af, af' ; Recuperamos el caracter a dibujar de A' |
| LD BC, (FONT_CHARSET) | ld bc, (FONT_CHARSET) |
| LD H, 0 | ld h, 0 |
| LD L, A | ld l, a |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, BC ; HL = BC + HL = FONT_CHARSET + (A * 8) | add hl, bc ; HL = BC + HL = FONT_CHARSET + (A * 8) |
| |
| EX DE, HL ; Intercambiamos DE y HL (DE=origen, HL=destino) | ex de, hl ; Intercambiamos DE y HL (DE=origen, HL=destino) |
| |
| ;;; Dibujar 7 scanlines (DE) -> (HL) y bajar scanline (y DE++) | ;;; Dibujar 7 scanlines (DE) -> (HL) y bajar scanline (y DE++) |
| LD B, 7 ; 7 scanlines a dibujar | ld b, 7 ; 7 scanlines a dibujar |
| |
| drawchar8_loop: | drawchar8_loop: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE ; Incrementamos puntero en caracter | inc de ; Incrementamos puntero en caracter |
| INC H ; Incrementamos puntero en pantalla (scanline+=1) | inc h ; Incrementamos puntero en pantalla (scanline+=1) |
| DJNZ drawchar8_loop | djnz drawchar8_loop |
| |
| ;;; La octava iteracion (8o scanline) aparte, para evitar los INCs | ;;; La octava iteracion (8o scanline) aparte, para evitar los INCs |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| |
| LD A, H ; Recuperamos el valor inicial de HL | ld a, h ; Recuperamos el valor inicial de HL |
| SUB 7 ; Restando los 7 "INC H"'s realizados | sub 7 ; Restando los 7 "inc h"'s realizados |
| |
| ;;; Calcular posicion destino en area de atributos en DE. | ;;; Calcular posicion destino en area de atributos en DE. |
| ; Tenemos A = H | ; Tenemos A = H |
| RRCA ; Codigo de Get_Attr_Offset_From_Image | rrca ; Codigo de Get_Attr_Offset_From_Image |
| RRCA | rrca |
| RRCA | rrca |
| AND 3 | and 3 |
| OR $58 | or $58 |
| LD D, A | ld d, a |
| LD E, L | ld e, l |
| |
| ;;; Escribir el atributo en memoria | ;;; Escribir el atributo en memoria |
| LD A, (FONT_ATTRIB) | ld a, (FONT_ATTRIB) |
| LD (DE), A ; Escribimos el atributo en memoria | ld (de), a ; Escribimos el atributo en memoria |
| RET | ret |
| </code> | </code> |
| |
| La rutina es muy parecida a las que ya vimos en el capítulo anterior para impresión de sprites 8x8, pero eliminando el cálculo del atributo origen al establecerlo desde la variable ''FONT_ATTRIB''. | La rutina es muy parecida a las que ya vimos en el capítulo anterior para impresión de sprites 8x8, pero eliminando el cálculo del atributo origen al establecerlo desde la variable ''FONT_ATTRIB''. |
| |
| Además, hemos semi-desenrollado el bucle de impresión para hacer 7 iteraciones y después escribir el último scanline fuera del bucle. De esta forma evitamos el ''INC DE'' + ''INC H'' que se realizaría para el último scanline y que es innecesario. De nuevo, desenrollar totalmente el bucle sería lo más óptimo, ya que evitaríamos el ''LD B, 7'' y el ''DJNZ''. | Además, hemos semi-desenrollado el bucle de impresión para hacer 7 iteraciones y después escribir el último scanline fuera del bucle. De esta forma evitamos el ''inc de'' + ''inc h'' que se realizaría para el último scanline y que es innecesario. De nuevo, desenrollar totalmente el bucle sería lo más óptimo, ya que evitaríamos el ''ld b, 7'' y el ''DJNZ''. |
| |
| La impresión se realiza por transferencia, pero podemos convertirla en impresión por operación lógica cambiando los: | La impresión se realiza por transferencia, pero podemos convertirla en impresión por operación lógica cambiando los: |
| |
| <code z80> | <code z80> |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| </code> | </code> |
| |
| |
| <code z80> | <code z80> |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| OR (HL) ; Hacemos OR entre dato y pantalla | or (hl) ; Hacemos OR entre dato y pantalla |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| </code> | </code> |
| |
| Para llamar a nuestra nueva rutina establecemos los valores de impresión en las variables de memoria y realizamos el ''CALL'' correspondiente. Aunque en esta rutina podríamos utilizar el paso por registros, vamos a emplear paso de parámetros por variables de memoria por 2 motivos: | Para llamar a nuestra nueva rutina establecemos los valores de impresión en las variables de memoria y realizamos el ''call'' correspondiente. Aunque en esta rutina podríamos utilizar el paso por registros, vamos a emplear paso de parámetros por variables de memoria por 2 motivos: |
| |
| * Para que sean utilizables desde BASIC. | * Para que sean utilizables desde BASIC. |
| ;;; Establecimiento de valores iniciales | ;;; Establecimiento de valores iniciales |
| |
| LD HL, charset1-256 ; Saltamos los 32 caracteres iniciales | ld hl, charset1-256 ; Saltamos los 32 caracteres iniciales |
| LD (FONT_CHARSET), HL ; Establecemos el valor del charset | ld (FONT_CHARSET), hl ; Establecemos el valor del charset |
| LD A, 6 | ld a, 6 |
| LD (FONT_ATTRIB), A ; Color amarillo sobre negro | ld (FONT_ATTRIB), a ; Color amarillo sobre negro |
| |
| ;;; Impresion de un caracter "X" en 15,8 | ;;; Impresion de un caracter "X" en 15,8 |
| LD A, 15 | ld a, 15 |
| LD (FONT_X), A | ld (FONT_X), a |
| LD A, 8 | ld a, 8 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| LD A, 'X' | ld a, 'X' |
| CALL PrintChar_8x8 ; Imprimimos el caracter | call PrintChar_8x8 ; Imprimimos el caracter |
| </code> | </code> |
| |
| ORG 35000 | ORG 35000 |
| |
| LD H, 0 | ld h, 0 |
| LD L, A | ld l, a |
| CALL ClearScreenAttrib ; Borramos la pantalla | call ClearScreenAttrib ; Borramos la pantalla |
| |
| LD HL, charset1-256 ; Saltamos los 32 caracteres iniciales | ld hl, charset1-256 ; Saltamos los 32 caracteres iniciales |
| LD (FONT_CHARSET), HL | ld (FONT_CHARSET), hl |
| XOR A | xor a |
| LD (FONT_X), A | ld (FONT_X), a |
| INC A | inc a |
| LD (FONT_Y), A ; Empezamos en (0,1) | ld (FONT_Y), a ; Empezamos en (0,1) |
| LD A, 6 | ld a, 6 |
| LD (FONT_ATTRIB), A ; Color amarillo sobre negro | ld (FONT_ATTRIB), a ; Color amarillo sobre negro |
| |
| LD C, 32 ; Empezamos en caracter 32 | ld c, 32 ; Empezamos en caracter 32 |
| |
| ;;; Bucle vertical | ;;; Bucle vertical |
| LD E, 4 | ld e, 4 |
| |
| bucle_y: | bucle_y: |
| |
| ;;; Bucle horizontal | ;;; Bucle horizontal |
| LD B, 16 ; Imprimimos 16 caracteres horiz | ld b, 16 ; Imprimimos 16 caracteres horiz |
| |
| bucle_x: | bucle_x: |
| LD A, (FONT_X) | ld a, (FONT_X) |
| INC A | inc a |
| LD (FONT_X), A ; X = X + 1 | ld (FONT_X), a ; X = X + 1 |
| |
| LD A, C | ld a, c |
| PUSH BC | push bc |
| PUSH DE ; Preservamos registros | push de ; Preservamos registros |
| CALL PrintChar_8x8 ; Imprimimos el caracter "C" | call PrintChar_8x8 ; Imprimimos el caracter "C" |
| POP DE | pop de |
| POP BC | pop bc |
| |
| INC C ; Siguiente caracter | inc c ; Siguiente caracter |
| DJNZ bucle_x ; Repetir 16 veces | djnz bucle_x ; Repetir 16 veces |
| |
| LD A, (FONT_Y) ; Siguiente linea: | ld a, (FONT_Y) ; Siguiente linea: |
| INC A | inc a |
| INC A ; Y = Y + 2 | inc a ; Y = Y + 2 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| XOR A | xor a |
| LD (FONT_X), A ; X = 0 | ld (FONT_X), a ; X = 0 |
| |
| DEC E | dec e |
| JR NZ, bucle_y ; Repetir 4 veces (16*4=64 caracteres) | jr nz, bucle_y ; Repetir 4 veces (16*4=64 caracteres) |
| |
| loop: | loop: |
| JR loop | jr loop |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| </code> | </code> |
| |
| Un apunte: en este caso hemos usado ''FONT_CHARSET'' como una variable ''DW'' (2 bytes) embebida en el código, pero podríamos haber aprovechado la variable del sistema ''CHARS'' para ello, cambiando el ''FONT_CHARSET DW 0'' por ''FONT_CHARSET EQU $5C36'' (una referencia a memoria, no un espacio en ella), de forma que ''FONT_CHARSET'' apunte a ''CHARS'', y ahorrar esos 2 bytes. | Un apunte: en este caso hemos usado ''FONT_CHARSET'' como una variable ''DW'' (2 bytes) embebida en el código, pero podríamos haber aprovechado la variable del sistema ''CHARS'' para ello, cambiando el ''FONT_CHARSET DW 0'' por ''FONT_CHARSET EQU $5c36'' (una referencia a memoria, no un espacio en ella), de forma que ''FONT_CHARSET'' apunte a ''CHARS'', y ahorrar esos 2 bytes. |
| |
| \\ | \\ |
| ;;; Bucle de impresion de caracter | ;;; Bucle de impresion de caracter |
| pstring8_loop: | pstring8_loop: |
| LD A, (HL) ; Leemos un caracter de la cadena | ld a, (hl) ; Leemos un caracter de la cadena |
| OR A | or a |
| RET Z ; Si es 0 (fin de cadena) volver | ret z ; Si es 0 (fin de cadena) volver |
| INC HL ; Siguiente caracter en la cadena | inc hl ; Siguiente caracter en la cadena |
| PUSH HL ; Salvaguardamos HL | push hl ; Salvaguardamos HL |
| CALL PrintChar_8x8 ; Imprimimos el caracter | call PrintChar_8x8 ; Imprimimos el caracter |
| POP HL ; Recuperamos HL | pop hl ; Recuperamos HL |
| |
| ;;; Ajustamos coordenadas X e Y | ;;; Ajustamos coordenadas X e Y |
| LD A, (FONT_X) ; Incrementamos la X | ld a, (FONT_X) ; Incrementamos la X |
| INC A ; pero comprobamos si borde derecho | inc a ; pero comprobamos si borde derecho |
| CP 31 ; X > 31? | cp 31 ; X > 31? |
| JR C, pstring8_noedgex ; No, se puede guardar el valor | jr c, pstring8_noedgex ; No, se puede guardar el valor |
| |
| LD A, (FONT_Y) ; Cogemos coordenada Y | ld a, (FONT_Y) ; Cogemos coordenada Y |
| CP 23 ; Si ya es 23, no incrementar | cp 23 ; Si ya es 23, no incrementar |
| JR NC, pstring8_noedgey ; Si es 23, saltar | jr nc, pstring8_noedgey ; Si es 23, saltar |
| |
| INC A ; No es 23, cambiar Y | inc a ; No es 23, cambiar Y |
| LD (FONT_Y), A | ld (FONT_Y), a |
| |
| pstring8_noedgey: | pstring8_noedgey: |
| LD (FONT_Y), A ; Guardamos la coordenada Y | ld (FONT_Y), a ; Guardamos la coordenada Y |
| XOR A ; Y ademas hacemos A = X = 0 | xor a ; Y ademas hacemos A = X = 0 |
| |
| pstring8_noedgex | pstring8_noedgex |
| LD (FONT_X), A ; Almacenamos el valor de X | ld (FONT_X), a ; almacenamos el valor de X |
| JR pstring8_loop | jr pstring8_loop |
| </code> | </code> |
| |
| ;;; Prueba de impresion de cadenas: | ;;; Prueba de impresion de cadenas: |
| |
| LD HL, charset1-256 ; Saltamos los 32 caracteres iniciales | ld hl, charset1-256 ; Saltamos los 32 caracteres iniciales |
| LD (FONT_CHARSET), HL | ld (FONT_CHARSET), hl |
| LD A, 64+3 | ld a, 64+3 |
| LD (FONT_ATTRIB), A | ld (FONT_ATTRIB), a |
| LD HL, cadena | ld hl, cadena |
| LD A, 0 | ld a, 0 |
| LD (FONT_X), A | ld (FONT_X), a |
| LD A, 15 | ld a, 15 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| CALL PrintString_8x8 | call PrintString_8x8 |
| RET | ret |
| |
| cadena DB "PRUEBA DE IMPRESION DE TEXTO DE UNA CADENA LARGA.", 0 | cadena DB "PRUEBA DE IMPRESION DE TEXTO DE UNA CADENA LARGA.", 0 |
| \\ | \\ |
| |
| La forma más óptima de programar la rutina de impresión consistiría en integrar el código de ''PrintChar_8x8'' dentro de ''PrintString_8x8'' evitando el recálculo de offset en pantalla en cada carácter. Se utilizaría DE como puntero en la fuente y HL como puntero en pantalla. Una vez calculada la posición inicial en pantalla para el primer carácter se variaría HL apropiadamente, incrementandolo en 1 para avances hacia la derecha tras la impresión de un carácter. Los retornos de carro se realizarían restando 31 a L y ejecutando //Caracter_Abajo_HL//. De esta forma se evitaría no sólo el ''CALL'' y ''RET'' contra ''PrintChar_8x8'' sino que tampoco habría que realizar el continuo cálculo de la posición destino. Después habría que trazar los atributos repitiendo el proceso desde el inicio de la cadena. | La forma más óptima de programar la rutina de impresión consistiría en integrar el código de ''PrintChar_8x8'' dentro de ''PrintString_8x8'' evitando el recálculo de offset en pantalla en cada carácter. Se utilizaría DE como puntero en la fuente y HL como puntero en pantalla. Una vez calculada la posición inicial en pantalla para el primer carácter se variaría HL apropiadamente, incrementandolo en 1 para avances hacia la derecha tras la impresión de un carácter. Los retornos de carro se realizarían restando 31 a L y ejecutando //Caracter_Abajo_HL//. De esta forma se evitaría no sólo el ''call'' y ''RET'' contra ''PrintChar_8x8'' sino que tampoco habría que realizar el continuo cálculo de la posición destino. Después habría que trazar los atributos repitiendo el proceso desde el inicio de la cadena. |
| |
| Normalmente no se suele imprimir texto durante el desarrollo del juego (al menos no en el bucle principal de juego), por lo que puede no ser necesario llegar a este extremo de optimización a cambio de una mayor ocupación de las rutinas en memoria. | Normalmente no se suele imprimir texto durante el desarrollo del juego (al menos no en el bucle principal de juego), por lo que puede no ser necesario llegar a este extremo de optimización a cambio de una mayor ocupación de las rutinas en memoria. |
| <code z80> | <code z80> |
| ;;; Guardar en L el valor a convertir y llamar a rutina | ;;; Guardar en L el valor a convertir y llamar a rutina |
| LD L, A | ld l, a |
| CALL Dec2String_8 | call Dec2String_8 |
| |
| ;;; Imprimir la cadena resultante de la conversion: | ;;; Imprimir la cadena resultante de la conversion: |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 | call PrintString_8x8 |
| </code> | </code> |
| |
| |
| Bin2String_16: ; Punto de entrada de 16 bits | Bin2String_16: ; Punto de entrada de 16 bits |
| LD DE, conv2string ; DE = puntero cadena destino | ld de, conv2string ; DE = puntero cadena destino |
| LD C, H ; C = a convertir (parte alta) | ld c, h ; C = a convertir (parte alta) |
| CALL Bin2String_convert ; Llamamos a rutina conversora | call Bin2String_convert ; Llamamos a rutina conversora |
| JR Bin2String_8b ; Convertimos la parte baja, | jr Bin2String_8b ; Convertimos la parte baja, |
| ; saltando el LD DE, conv2string | ; saltando el ld de, conv2string |
| |
| Bin2String_8: ; Punto de entrada de 8 bits | Bin2String_8: ; Punto de entrada de 8 bits |
| LD DE, conv2string ; DE = puntero cadena destino | ld de, conv2string ; DE = puntero cadena destino |
| |
| Bin2String_8b: | Bin2String_8b: |
| LD C, L ; C = a convertir (parte baja) | ld c, l ; C = a convertir (parte baja) |
| CALL Bin2String_convert ; Llamamos a rutina conversora | call Bin2String_convert ; Llamamos a rutina conversora |
| XOR A | xor a |
| LD (DE), A ; Guardar End Of String | ld (de), a ; Guardar End Of String |
| RET | ret |
| |
| Bin2String_convert: | Bin2String_convert: |
| LD B, 8 ; 8 iteraciones | ld b, 8 ; 8 iteraciones |
| b2string_loop: ; Bucle de conversion | b2string_loop: ; Bucle de conversion |
| RL C | rl c |
| LD A, '1' ; Valor en A por defecto | ld a, '1' ; Valor en A por defecto |
| JR NC, b2string_noC | jr nc, b2string_noC |
| LD (DE), A ; Lo almacenamos en la cadena | ld (de), a ; Lo almacenamos en la cadena |
| INC DE | inc de |
| DJNZ b2string_loop | djnz b2string_loop |
| RET | ret |
| b2string_noC: | b2string_noC: |
| DEC A ; A = '0' | dec a ; A = '0' |
| LD (DE), A | ld (de), a |
| INC DE ; Lo almacenamos y avanzamos | inc de ; Lo almacenamos y avanzamos |
| DJNZ b2string_loop | djnz b2string_loop |
| RET | ret |
| </code> | </code> |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Hex2String_16: | Hex2String_16: |
| LD DE, conv2string ; Cadena destino | ld de, conv2string ; Cadena destino |
| LD A, H | ld a, h |
| CALL B2AHex_Num1 ; Convertir Hex1 de H | call B2AHex_Num1 ; Convertir Hex1 de H |
| LD A, H | ld a, h |
| CALL B2AHex_Num2 ; Convertir Hex2 de H | call B2AHex_Num2 ; Convertir Hex2 de H |
| JR Hex2String_8b ; Realizar conversion de L | jr Hex2String_8b ; Realizar conversion de L |
| |
| Hex2String_8: ; Entrada para la rutina de 8 bits | Hex2String_8: ; Entrada para la rutina de 8 bits |
| LD DE, conv2string | ld de, conv2string |
| |
| Hex2String_8b: | Hex2String_8b: |
| LD A, L | ld a, l |
| CALL B2AHex_Num1 ; Convertir Hex1 de L | call B2AHex_Num1 ; Convertir Hex1 de L |
| LD A, L | ld a, l |
| CALL B2AHex_Num2 ; Convertir Hex2 de L | call B2AHex_Num2 ; Convertir Hex2 de L |
| XOR A | xor a |
| LD (DE), A ; Guardar End Of String | ld (de), a ; Guardar End Of String |
| RET | ret |
| |
| B2AHex_Num1: | B2AHex_Num1: |
| RRA | rra |
| RRA | rra |
| RRA ; Desplazamos 4 veces >> | rra ; Desplazamos 4 veces >> |
| RRA ; para poder usar el siguiente bloque | rra ; para poder usar el siguiente bloque |
| |
| B2AHex_Num2: | B2AHex_Num2: |
| OR $F0 ; Enmascaramos 11110000 | or $f0 ; Enmascaramos 11110000 |
| DAA ; Ajuste BCD | daa ; Ajuste BCD |
| ADD A, $A0 | add a, $a0 |
| ADC A, $40 | adc a, $40 |
| LD (DE), A ; Guardamos dato | ld (de), a ; Guardamos dato |
| INC DE | inc de |
| RET | ret |
| </code> | </code> |
| |
| ;----------------------------------------------------------------- | ;----------------------------------------------------------------- |
| Int2String_16: | Int2String_16: |
| LD DE, conv2string ; Apuntamos a cadena destino | ld de, conv2string ; Apuntamos a cadena destino |
| LD BC, -10000 ; Calcular digito decenas de miles | ld bc, -10000 ; Calcular digito decenas de miles |
| CALL Int2Dec_num1 | call Int2Dec_num1 |
| LD BC, -1000 ; Calcular digito miles | ld bc, -1000 ; Calcular digito miles |
| CALL Int2Dec_num1 | call Int2Dec_num1 |
| JR Int2String_8b ; Continuar en rutina de 8 bits (2) | jr Int2String_8b ; Continuar en rutina de 8 bits (2) |
| |
| Int2String_8: ; Punto de entrada de rutina 8 bits | Int2String_8: ; Punto de entrada de rutina 8 bits |
| LD DE, conv2string ; Apuntar a cadena destino | ld de, conv2string ; Apuntar a cadena destino |
| LD H, 0 ; Parte alta de HL = 0 | ld h, 0 ; Parte alta de HL = 0 |
| |
| Int2String_8b: ; rutina de 8 bits (2) | Int2String_8b: ; rutina de 8 bits (2) |
| LD BC, -100 ; Calcular digito de centenas | ld bc, -100 ; Calcular digito de centenas |
| CALL Int2Dec_num1 | call Int2Dec_num1 |
| LD C, -10 ; Calcular digito de decenas | ld c, -10 ; Calcular digito de decenas |
| CALL Int2Dec_num1 | call Int2Dec_num1 |
| LD C, B ; Calcular unidades | ld c, b ; Calcular unidades |
| CALL Int2Dec_num1 | call Int2Dec_num1 |
| XOR A | xor a |
| LD (DE), A ; Almacenar un fin de cadena | ld (de), a ; Almacenar un fin de cadena |
| RET | ret |
| |
| Int2Dec_num1: | Int2Dec_num1: |
| LD A,'0'-1 ; Contador unidades, empieza '0'-1 | ld a,'0'-1 ; Contador unidades, empieza '0'-1 |
| |
| Int2Dec_num2: | Int2Dec_num2: |
| INC A ; Incrementamos el digito ('0', ... '9') | inc a ; Incrementamos el digito ('0', ... '9') |
| ADD HL, BC ; Restamos "unidades" hasta sobrepasarlo | add hl, bc ; Restamos "unidades" hasta sobrepasarlo |
| JR C, Int2Dec_num2 ; Repetir n veces | jr c, Int2Dec_num2 ; Repetir n veces |
| SBC HL, BC ; Deshacemos el último paso | sbc hl, bc ; Deshacemos el último paso |
| LD (DE), A ; Almacenamos el valor | ld (de), a ; Almacenamos el valor |
| INC DE | inc de |
| RET | ret |
| </code> | </code> |
| |
| ;----------------------------------------------------------------- | ;----------------------------------------------------------------- |
| INC_HL_Remove_Leading_Zeros: | INC_HL_Remove_Leading_Zeros: |
| LD A, (HL) ; Leemos caracter de la cadena | ld a, (hl) ; Leemos caracter de la cadena |
| OR A | or a |
| RET Z ; Fin de cadena -> volver | ret z ; Fin de cadena -> volver |
| CP '0' | cp '0' |
| RET NZ ; Distinto de '0', volver | ret nz ; Distinto de '0', volver |
| INC HL ; '0', incrementar HL y repetir | inc hl ; '0', incrementar HL y repetir |
| JR INC_HL_Remove_Leading_Zeros | jr INC_HL_Remove_Leading_Zeros |
| </code> | </code> |
| |
| <code z80> | <code z80> |
| ;;; Imprimir variable de 8 bits (podría ser un registro) | ;;; Imprimir variable de 8 bits (podría ser un registro) |
| LD A, (variable_8bits) | ld a, (variable_8bits) |
| LD L, A | ld l, a |
| CALL Int2String_8 | call Int2String_8 |
| LD HL, conv2string | ld hl, conv2string |
| CALL INC_HL_Remove_Leading_Zeros | call INC_HL_Remove_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| |
| ;;; Imprimir variable de 16 bits | ;;; Imprimir variable de 16 bits |
| LD BC, (variable_16bits) | ld bc, (variable_16bits) |
| PUSH BC | push bc |
| POP HL ; HL = BC | pop hl ; HL = BC |
| CALL Int2String_16 | call Int2String_16 |
| LD HL, conv2string | ld hl, conv2string |
| CALL INC_HL_Remove_Leading_Zeros | call INC_HL_Remove_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| </code> | </code> |
| |
| <code z80> | <code z80> |
| INC_HL_Justify_Leading_Zeros: | INC_HL_Justify_Leading_Zeros: |
| LD A, (HL) ; Leemos caracter de la cadena | ld a, (hl) ; Leemos caracter de la cadena |
| OR A | or a |
| RET Z ; Fin de cadena -> volver | ret z ; Fin de cadena -> volver |
| CP '0' | cp '0' |
| RET NZ ; Distinto de '0', volver | ret nz ; Distinto de '0', volver |
| INC HL ; '0', incrementar HL y repetir | inc hl ; '0', incrementar HL y repetir |
| LD A, ' ' | ld a, ' ' |
| CALL Font_Blank ; Imprimimos espacio y avanzamos | call Font_Blank ; Imprimimos espacio y avanzamos |
| JR INC_HL_Justify_Leading_Zeros | jr INC_HL_Justify_Leading_Zeros |
| </code> | </code> |
| |
| De esta forma, podemos tener en pantalla un valor "12345" que se vea sobreescrito por un valor "100" al imprimir " 100" (con 2 espacios delante). | De esta forma, podemos tener en pantalla un valor "12345" que se vea sobreescrito por un valor "100" al imprimir " 100" (con 2 espacios delante). |
| |
| También podemos sustituir ''CALL Font_Blank'' por un simple ''CALL Font_Inc_X'' para que se realice el avance del cursor horizontalmente pero sin la impresión del carácter espacio. | También podemos sustituir ''call Font_Blank'' por un simple ''call Font_Inc_X'' para que se realice el avance del cursor horizontalmente pero sin la impresión del carácter espacio. |
| |
| \\ | \\ |
| ;----------------------------------------------------------------------- | ;----------------------------------------------------------------------- |
| Int2String_8_2Digits: | Int2String_8_2Digits: |
| LD D, '0' ; Empezar en ASCII '0' | ld d, '0' ; Empezar en ASCII '0' |
| DEC D ; Decrementar porque el bucle hace INC | dec d ; Decrementar porque el bucle hace INC |
| LD E, 10 ; Base 10 | ld e, 10 ; Base 10 |
| AND A ; Carry Flag = 0 | and a ; Carry Flag = 0 |
| |
| dtoa2dloop: | dtoa2dloop: |
| INC D ; Incrementar numero de decenas | inc d ; Incrementar numero de decenas |
| SUB E ; Quitar una unidad de decenas de A | sub e ; Quitar una unidad de decenas de A |
| JR NC, dtoa2dloop ; Si A todavia no es negativo, seguir | jr nc, dtoa2dloop ; Si A todavia no es negativo, seguir |
| ADD A, E ; Decrementado demasiado, volver atras | add a, e ; Decrementado demasiado, volver atras |
| ADD A, '0' ; Convertir a ASCII | add a, '0' ; Convertir a ASCII |
| LD E, A ; E contiene las unidades | ld e, a ; E contiene las unidades |
| RET | ret |
| </code> | </code> |
| |
| |
| <code z80> | <code z80> |
| LD A, (vidas) | ld a, (vidas) |
| CALL Int2String_8_2Digits | call Int2String_8_2Digits |
| |
| ;; Imprimir parte alta (decenas) | ;; Imprimir parte alta (decenas) |
| LD A, 0 | ld a, 0 |
| LD (FONT_X), A | ld (FONT_X), a |
| LD A, D | ld a, d |
| CALL PrintChar_8x8 | call PrintChar_8x8 |
| |
| ;;; Imprimir parte baja (unidades) | ;;; Imprimir parte baja (unidades) |
| LD A, 1 | ld a, 1 |
| LD (FONT_X), A | ld (FONT_X), a |
| LD A, E | ld a, e |
| CALL PrintChar_8x8 | call PrintChar_8x8 |
| </code> | </code> |
| |
| ===== Fuente estándar 8x8 de la ROM ===== | ===== Fuente estándar 8x8 de la ROM ===== |
| |
| En el Spectrum disponemos de un tipo de letra estándar de 8x8 pregrabado en ROM. Los caracteres imprimibles alojados en la ROM del Spectrum van desde el 32 (espacio) al 127 (carácter de copyright), empezando el primero en **$3D00** (15161 decimal) y acabando el último en **$3FFF** (16383, el último byte de la ROM). | En el Spectrum disponemos de un tipo de letra estándar de 8x8 pregrabado en ROM. Los caracteres imprimibles alojados en la ROM del Spectrum van desde el 32 (espacio) al 127 (carácter de copyright), empezando el primero en **$3d00** (15161 decimal) y acabando el último en **$3fff** (16383, el último byte de la ROM). |
| |
| Existe una variable del sistema llamada ''CHARS'' (de 16 bits, ubicada en las direcciones 23606 y 23607) que contiene la dirección de memoria del juego de caracteres que esté en uso por BASIC. | Existe una variable del sistema llamada ''CHARS'' (de 16 bits, ubicada en las direcciones 23606 y 23607) que contiene la dirección de memoria del juego de caracteres que esté en uso por BASIC. |
| |
| Por defecto, ''CHARS'' contiene el valor **$3D00** (la fuente de letras estándar) menos 256. El hecho de restar 256 al inicio real de la fuente es porque los caracteres definidos en la ROM empiezan en el 32 y restando 256 (8 bytes por carácter para 32 caracteres = 256 bytes), al igual que hicimos nosotros con nuestro charset personalizado, podemos hacer coincidir un ASCII > 32 con **CHARS + (8 * VALOR_ASCII)**. | Por defecto, ''CHARS'' contiene el valor **$3d00** (la fuente de letras estándar) menos 256. El hecho de restar 256 al inicio real de la fuente es porque los caracteres definidos en la ROM empiezan en el 32 y restando 256 (8 bytes por carácter para 32 caracteres = 256 bytes), al igual que hicimos nosotros con nuestro charset personalizado, podemos hacer coincidir un ASCII > 32 con **CHARS + (8 * VALOR_ASCII)**. |
| |
| El valor por defecto de ''CHARS'' es, pues, $3D00 - $0100 = $3C00. | El valor por defecto de ''CHARS'' es, pues, $3d00 - $0100 = $3c00. |
| |
| El juego de caracteres estándar es inmutable al estar en ROM. La variable ''CHARS'' permite, en el BASIC del Spectrum, definir un juego de caracteres personalizado en RAM y apuntar ''CHARS'' a su dirección en memoria. La definición de los 21 UDGs (19 en el +2A/+3) también está en RAM (desde $FF58 a $FFFF), ya que deben de ser personalizables por el usuario. | El juego de caracteres estándar es inmutable al estar en ROM. La variable ''CHARS'' permite, en el BASIC del Spectrum, definir un juego de caracteres personalizado en RAM y apuntar ''CHARS'' a su dirección en memoria. La definición de los 21 UDGs (19 en el +2A/+3) también está en RAM (desde $ff58 a $ffff), ya que deben de ser personalizables por el usuario. |
| |
| Veamos el aspecto de la tipográfia estándar del Spectrum: | Veamos el aspecto de la tipográfia estándar del Spectrum: |
| \\ | \\ |
| |
| El formato en memoria de la fuente de la ROM es idéntico a un spriteset de 8x8 sin atributos, tal y como hemos definido las fuentes de texto personalizadas de nuestras rutinas y ejemplos anteriores. A partir de $3D00 empiezan los 8 bytes de datos (8 scanlines) del carácter 32, a los que siguen los 8 scanlines del carácter 33, etc., así hasta el carácter 127. | El formato en memoria de la fuente de la ROM es idéntico a un spriteset de 8x8 sin atributos, tal y como hemos definido las fuentes de texto personalizadas de nuestras rutinas y ejemplos anteriores. A partir de $3d00 empiezan los 8 bytes de datos (8 scanlines) del carácter 32, a los que siguen los 8 scanlines del carácter 33, etc., así hasta el carácter 127. |
| |
| Gracias a esto podemos utilizar esta tipografía en nuestros juegos y programas (ahorrando así tener que definir nuestro propio charset y ocupar memoria con él) directamente con las rutinas de impresión de caracteres y cadenas que hemos utilizado con las fuentes de texto personalizables. Basta con establecer ''FONT_CHARSET'' a la dirección adecuada, $3C00: | Gracias a esto podemos utilizar esta tipografía en nuestros juegos y programas (ahorrando así tener que definir nuestro propio charset y ocupar memoria con él) directamente con las rutinas de impresión de caracteres y cadenas que hemos utilizado con las fuentes de texto personalizables. Basta con establecer ''FONT_CHARSET'' a la dirección adecuada, $3c00: |
| |
| <code z80> | <code z80> |
| LD HL, 15616-256 ; Saltamos los 32 caracteres iniciales | ld hl, 15616-256 ; Saltamos los 32 caracteres iniciales |
| LD (FONT_CHARSET), HL ; Ya podemos utilizar la tipografia del | ld (FONT_CHARSET), hl ; Ya podemos utilizar la tipografia del |
| ; Spectrum con nuestras rutinas. | ; Spectrum con nuestras rutinas. |
| </code> | </code> |
| |
| * **FONT_X**, **FONT_Y** : Coordenadas X e Y en baja resolución (comenzando en 0) de la posición actual para la próxima impresión de un carácter (cursor). | * **FONT_X**, **FONT_Y** : Coordenadas X e Y en baja resolución (comenzando en 0) de la posición actual para la próxima impresión de un carácter (cursor). |
| * **FONT_CHARSET** : Apunta al spriteset de la fuente de texto (charset) a utilizar. El valor por defecto es $3D00-256 (la fuente de la ROM). | * **FONT_CHARSET** : Apunta al spriteset de la fuente de texto (charset) a utilizar. El valor por defecto es $3d00-256 (la fuente de la ROM). |
| * **FONT_ATTRIB** : Almacena el atributo en uso para la impresión de caracteres. | * **FONT_ATTRIB** : Almacena el atributo en uso para la impresión de caracteres. |
| * **FONT_STYLE** : Almacena un valor numérico que define el estilo de impresión a utilizar. Por defecto es 0 (estilo normal). | * **FONT_STYLE** : Almacena un valor numérico que define el estilo de impresión a utilizar. Por defecto es 0 (estilo normal). |
| |
| <code z80> | <code z80> |
| FONT_CHARSET DEFW $3D00-256 | FONT_CHARSET DEFW $3d00-256 |
| FONT_ATTRIB DEFB 56 ; Negro sobre gris | FONT_ATTRIB DEFB 56 ; Negro sobre gris |
| FONT_STYLE DEFB 0 | FONT_STYLE DEFB 0 |
| <code z80> | <code z80> |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| FONT_CHARSET DW $3D00-256 | FONT_CHARSET DW $3d00-256 |
| FONT_ATTRIB DB 56 ; Negro sobre gris | FONT_ATTRIB DB 56 ; Negro sobre gris |
| FONT_STYLE DB 0 | FONT_STYLE DB 0 |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Charset: | Font_Set_Charset: |
| LD (FONT_CHARSET), HL | ld (FONT_CHARSET), hl |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Style: | Font_Set_Style: |
| LD (FONT_STYLE), A | ld (FONT_STYLE), a |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_X: | Font_Set_X: |
| LD (FONT_X), A | ld (FONT_X), a |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Y: | Font_Set_Y: |
| LD (FONT_Y), A | ld (FONT_Y), a |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_XY: | Font_Set_XY: |
| LD (FONT_X), BC | ld (FONT_X), bc |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Ink: | Font_Set_Ink: |
| PUSH BC ; Preservamos registros | push bc ; Preservamos registros |
| AND 7 ; Borramos bits 7-3 | and 7 ; Borramos bits 7-3 |
| LD B, A ; Lo guardamos en B | ld b, a ; Lo guardamos en B |
| LD A, (FONT_ATTRIB) ; Cogemos el atributo actual | ld a, (FONT_ATTRIB) ; Cogemos el atributo actual |
| AND %11111000 ; Borramos el valor de INK | and %11111000 ; Borramos el valor de INK |
| OR B ; Insertamos INK en A | or b ; Insertamos INK en A |
| LD (FONT_ATTRIB), A ; Guardamos el valor de INK | ld (FONT_ATTRIB), a ; Guardamos el valor de INK |
| POP BC | pop bc |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Paper: | Font_Set_Paper: |
| PUSH BC ; Preservamos registros | push bc ; Preservamos registros |
| AND 7 ; Borramos bits 7-3 | and 7 ; Borramos bits 7-3 |
| RLCA ; A = 00000XXX -> 0000XXX0 | rlca ; A = 00000XXX -> 0000XXX0 |
| RLCA ; A = 000XXX00 | rlca ; A = 000XXX00 |
| RLCA ; A = 00XXX000 <-- Valor en paper | rlca ; A = 00XXX000 <-- Valor en paper |
| LD B, A ; Lo guardamos en B | ld b, a ; Lo guardamos en B |
| LD A, (FONT_ATTRIB) ; Cogemos el atributo actual | ld a, (FONT_ATTRIB) ; Cogemos el atributo actual |
| AND %11000111 ; Borramos los datos de PAPER | and %11000111 ; Borramos los datos de PAPER |
| OR B ; Insertamos PAPER en A | or b ; Insertamos PAPER en A |
| LD (FONT_ATTRIB), A ; Guardamos el valor de PAPER | ld (FONT_ATTRIB), a ; Guardamos el valor de PaPER |
| POP BC | pop bc |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Attrib: | Font_Set_Attrib: |
| LD (FONT_ATTRIB), A | ld (FONT_ATTRIB), a |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Bright: | Font_Set_Bright: |
| AND 1 ; A = solo bit 0 de A | and 1 ; A = solo bit 0 de A |
| LD A, (FONT_ATTRIB) ; Cargamos en A el atributo | ld a, (FONT_ATTRIB) ; Cargamos en A el atributo |
| JR NZ, fsbright_1 ; Si el bit solicitado era | jr nz, fsbright_1 ; Si el bit solicitado era |
| RES 6, A ; Seteamos a 0 el bit de flash | res 6, a ; Seteamos a 0 el bit de flash |
| LD (FONT_ATTRIB), A ; Escribimos el atributo | ld (FONT_ATTRIB), a ; Escribimos el atributo |
| RET | ret |
| fsbright_1: | fsbright_1: |
| SET 6, A ; Seteamos a 1 el bit de brillo | set 6, a ; Seteamos a 1 el bit de brillo |
| LD (FONT_ATTRIB), A ; Escribimos el atributo | ld (FONT_ATTRIB), a ; Escribimos el atributo |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Set_Flash: | Font_Set_Flash: |
| AND 1 ; A = solo bit 0 de A | and 1 ; A = solo bit 0 de A |
| LD A, (FONT_ATTRIB) ; Cargamos en A el atributo | ld a, (FONT_ATTRIB) ; Cargamos en A el atributo |
| JR NZ, fsflash_1 ; Si el bit solicitado era | jr nz, fsflash_1 ; Si el bit solicitado era |
| RES 7, A ; Seteamos a 0 el bit de flash | res 7, a ; Seteamos a 0 el bit de flash |
| LD (FONT_ATTRIB), A ; Escribimos el atributo | ld (FONT_ATTRIB), a ; Escribimos el atributo |
| RET | ret |
| fsflash_1: | fsflash_1: |
| SET 7, A ; Seteamos a 1 el bit de flash | set 7, a ; Seteamos a 1 el bit de flash |
| LD (FONT_ATTRIB), A ; Escribimos el atributo | ld (FONT_ATTRIB), a ; Escribimos el atributo |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Blank: | Font_Blank: |
| LD A, ' ' ; Imprimir caracter espacio | ld a, ' ' ; Imprimir caracter espacio |
| PUSH BC | push bc |
| PUSH DE | push de |
| PUSH HL | push hl |
| CALL PrintChar_8x8 ; Sobreescribir caracter | call PrintChar_8x8 ; Sobreescribir caracter |
| POP HL | pop hl |
| POP DE | pop de |
| POP BC | pop bc |
| CALL Font_Inc_X ; Incrementamos la coord X | call Font_Inc_X ; Incrementamos la coord X |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Inc_X: | Font_Inc_X: |
| LD A, (FONT_X) ; Incrementamos la X | ld a, (FONT_X) ; Incrementamos la X |
| INC A ; pero comprobamos si borde derecho | inc a ; pero comprobamos si borde derecho |
| CP FONT_SCRWIDTH-1 ; X > ANCHO-1? | cp FONT_SCRWIDTH-1 ; X > ANCHO-1? |
| JR C, fincx_noedgex ; No, se puede guardar el valor | jr c, fincx_noedgex ; No, se puede guardar el valor |
| CALL Font_CRLF | call Font_CRLF |
| RET | ret |
| |
| fincx_noedgex: | fincx_noedgex: |
| LD (FONT_X), A ; Establecemos el valor de X | ld (FONT_X), a ; Establecemos el valor de X |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_LF: | Font_LF: |
| LD A, (FONT_Y) ; Cogemos coordenada Y | ld a, (FONT_Y) ; Cogemos coordenada Y |
| CP FONT_SCRHEIGHT-1 ; Estamos en la parte inferior | cp FONT_SCRHEIGHT-1 ; Estamos en la parte inferior |
| JR NC, fontlf_noedge ; de pantalla? -> No avanzar | jr nc, fontlf_noedge ; de pantalla? -> No avanzar |
| INC A ; No estamos, avanzar | inc a ; No estamos, avanzar |
| LD (FONT_Y), A | ld (FONT_Y), a |
| |
| fontlf_noedge: | fontlf_noedge: |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_CR: | Font_CR: |
| XOR A | xor a |
| LD (FONT_X), A | ld (FONT_X), a |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_CRLF: | Font_CRLF: |
| CALL Font_LF | call Font_LF |
| CALL Font_CR | call Font_CR |
| RET | ret |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Tab: | Font_Tab: |
| PUSH BC | push bc |
| PUSH DE | push de |
| PUSH HL | push hl |
| LD HL, font_tab_string | ld hl, font_tab_string |
| CALL PrintString_8x8 ; Imprimimos 3 espacios | call PrintString_8x8 ; Imprimimos 3 espacios |
| POP HL | pop hl |
| POP DE | pop de |
| POP BC | pop bc |
| RET | ret |
| |
| font_tab_string DB " ", 0 | font_tab_string DB " ", 0 |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Dec_X: | Font_Dec_X: |
| LD A, (FONT_X) ; Cargamos la coordenada X | ld a, (FONT_X) ; Cargamos la coordenada X |
| OR A | or a |
| RET Z ; Es cero? no se hace nada (salir) | ret z ; Es cero? no se hace nada (salir) |
| DEC A ; No es cero? Decrementar | dec a ; No es cero? Decrementar |
| LD (FONT_X), A | ld (FONT_X), a |
| RET ; Salir | ret ; Salir |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_Backspace: | Font_Backspace: |
| CALL Font_Dec_X | call Font_Dec_X |
| LD A, ' ' ; Imprimir caracter espacio | ld a, ' ' ; Imprimir caracter espacio |
| PUSH BC | push bc |
| PUSH DE | push de |
| PUSH HL | push hl |
| CALL PrintChar_8x8 ; Sobreescribir caracter | call PrintChar_8x8 ; Sobreescribir caracter |
| POP HL | pop hl |
| POP DE | pop de |
| POP BC | pop bc |
| RET ; Salir | ret ; Salir |
| </code> | </code> |
| |
| |
| <code z80> | <code z80> |
| LD HL, micharset | ld hl, micharset |
| CALL Font_Set_Charset | call Font_Set_Charset |
| |
| LD A, 1+(7*8) | ld a, 1+(7*8) |
| Call Font_Set_Attrib | Call Font_Set_Attrib |
| |
| LD A, FONT_NORMAL | ld a, FONT_NORMAL |
| CALL Font_Set_Style | call Font_Set_Style |
| (...) | (...) |
| </code> | </code> |
| |
| Nótese que hemos creado funciones del tipo ''Font_Set_X'' o ''Font_Set_Y'' que simplemente modifican valores en nuestras variables por temas ilustrativos, ya que lo normal sería en nuestro ejemplo escribir directamente en las variables en lugar de hacer un ''CALL''. | Nótese que hemos creado funciones del tipo ''Font_Set_X'' o ''Font_Set_Y'' que simplemente modifican valores en nuestras variables por temas ilustrativos, ya que lo normal sería en nuestro ejemplo escribir directamente en las variables en lugar de hacer un ''call''. |
| |
| |
| <code> | <code> |
| ;--- Variables de fuente -------------------- | ;--- Variables de fuente -------------------- |
| FONT_CHARSET DW $3D00-256 | FONT_CHARSET DW $3d00-256 |
| FONT_ATTRIB DB 56 ; Negro sobre gris | FONT_ATTRIB DB 56 ; Negro sobre gris |
| FONT_STYLE DB 0 | FONT_STYLE DB 0 |
| PrintChar_8x8: | PrintChar_8x8: |
| |
| LD BC, (FONT_X) ; B = Y, C = X | ld bc, (FONT_X) ; B = Y, C = X |
| EX AF, AF' ; Nos guardamos el caracter en A' | ex af, af' ; Nos guardamos el caracter en A' |
| |
| ;;; Calculamos las coordenadas destino de pantalla en DE: | ;;; Calculamos las coordenadas destino de pantalla en DE: |
| LD A, B | ld a, b |
| AND $18 | and $18 |
| ADD A, $40 | add a, $40 |
| LD D, A | ld d, a |
| LD A, B | ld a, b |
| AND 7 | and 7 |
| RRCA | rrca |
| RRCA | rrca |
| RRCA | rrca |
| ADD A, C | add a, c |
| LD E, A ; DE contiene ahora la direccion destino. | ld e, a ; DE contiene ahora la direccion destino. |
| |
| ;;; Calcular posicion origen (array sprites) en HL como: | ;;; Calcular posicion origen (array sprites) en HL como: |
| ;;; direccion = base_sprites + (NUM_SPRITE*8) | ;;; direccion = base_sprites + (NUM_SPRITE*8) |
| EX AF, AF' ; Recuperamos el caracter a dibujar de A' | ex af, af' ; Recuperamos el caracter a dibujar de A' |
| LD BC, (FONT_CHARSET) | ld bc, (FONT_CHARSET) |
| LD H, 0 | ld h, 0 |
| LD L, A | ld l, a |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, BC ; HL = BC + HL = FONT_CHARSET + (A * 8) | add hl, bc ; HL = BC + HL = FONT_CHARSET + (A * 8) |
| |
| EX DE, HL ; Intercambiamos DE y HL (DE=origen, HL=destino) | ex de, hl ; Intercambiamos DE y HL (DE=origen, HL=destino) |
| |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| ;;; Impresion de atributos | ;;; Impresion de atributos |
| LD A, H ; Recuperamos el valor inicial de HL | ld a, h ; Recuperamos el valor inicial de HL |
| SUB 8 ; Restando los 8 scanlines avanzados | sub 8 ; Restando los 8 scanlines avanzados |
| |
| ;;; Calcular posicion destino en area de atributos en DE. | ;;; Calcular posicion destino en area de atributos en DE. |
| ; A = H | ; A = H |
| RRCA ; Codigo de Get_Attr_Offset_From_Image | rrca ; Codigo de Get_Attr_Offset_From_Image |
| RRCA | rrca |
| RRCA | rrca |
| AND 3 | and 3 |
| OR $58 | or $58 |
| LD D, A | ld d, a |
| LD E, L | ld e, l |
| |
| ;;; Escribir el atributo en memoria | ;;; Escribir el atributo en memoria |
| LD A, (FONT_ATTRIB) | ld a, (FONT_ATTRIB) |
| LD (DE), A ; Escribimos el atributo en memoria | ld (de), a ; Escribimos el atributo en memoria |
| RET | ret |
| </code> | </code> |
| |
| <code z80> | <code z80> |
| ;;;;;; Estilo NORMAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo NORMAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| LD B, 8 ; 8 scanlines a dibujar | ld b, 8 ; 8 scanlines a dibujar |
| drawchar_loop_normal: | drawchar_loop_normal: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_normal | djnz drawchar_loop_normal |
| JR pchar8_printattr ; Impresion de atributos | jr pchar8_printattr ; Impresion de atributos |
| </code> | </code> |
| |
| <code z80> | <code z80> |
| ;;;;;; Estilo NEGRITA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo NEGRITA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| LD B, 8 ; 8 scanlines a dibujar | ld b, 8 ; 8 scanlines a dibujar |
| drawchar_loop_bold: | drawchar_loop_bold: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD C, A ; Creamos copia de A | ld c, a ; Creamos copia de A |
| RRCA ; Desplazamos A | rrca ; Desplazamos A |
| OR C ; Y agregamos C | or c ; Y agregamos C |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_bold | djnz drawchar_loop_bold |
| JR pchar8_printattr ; Impresion de atributos | jr pchar8_printattr ; Impresion de atributos |
| </code> | </code> |
| |
| <code z80> | <code z80> |
| ;;;;;; Estilo SUBRAYADO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo SUBRAYADO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| LD B, 7 ; 7 scanlines a dibujar normales | ld b, 7 ; 7 scanlines a dibujar normales |
| drawchar_loop_undersc: | drawchar_loop_undersc: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_undersc | djnz drawchar_loop_undersc |
| |
| ;;; El octavo scanline, una linea de subrayado | ;;; El octavo scanline, una linea de subrayado |
| LD A, 255 ; Ultima linea = subrayado | ld a, 255 ; Ultima linea = subrayado |
| LD (HL), A | ld (hl), a |
| INC H ; Necesario para el SUB A, 8 | inc h ; Necesario para el sub a, 8 |
| JR pchar8_printattr ; Impresion de atributos | jr pchar8_printattr ; Impresion de atributos |
| </code> | </code> |
| |
| ;;;;;; Estilo ITALICA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo ITALICA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;; 3 primeros scanlines, a la derecha, | ;;; 3 primeros scanlines, a la derecha, |
| LD B, 3 | ld b, 3 |
| drawchar_loop_italic1: | drawchar_loop_italic1: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| SRA A ; Desplazamos A a la derecha | sra a ; Desplazamos A a la derecha |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_italic1 | djnz drawchar_loop_italic1 |
| |
| ;;; 2 siguientes scanlines, sin tocar | ;;; 2 siguientes scanlines, sin tocar |
| LD B, 2 | ld b, 2 |
| |
| drawchar_loop_italic2: | drawchar_loop_italic2: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_italic2 | djnz drawchar_loop_italic2 |
| |
| LD B, 3 | ld b, 3 |
| drawchar_loop_italic3: | drawchar_loop_italic3: |
| ;;; 3 ultimos scanlines, a la izquierda, | ;;; 3 ultimos scanlines, a la izquierda, |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| SLA A ; Desplazamos A | sla a ; Desplazamos A |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_italic3 | djnz drawchar_loop_italic3 |
| JR pchar8_printattr | jr pchar8_printattr |
| </code> | </code> |
| |
| PrintChar_8x8: | PrintChar_8x8: |
| |
| LD BC, (FONT_X) ; B = Y, C = X | ld bc, (FONT_X) ; B = Y, C = X |
| EX AF, AF' ; Nos guardamos el caracter en A' | ex af, af' ; Nos guardamos el caracter en A' |
| |
| ;;; Calculamos las coordenadas destino de pantalla en DE: | ;;; Calculamos las coordenadas destino de pantalla en DE: |
| LD A, B | ld a, b |
| AND $18 | and $18 |
| ADD A, $40 | add a, $40 |
| LD D, A | ld d, a |
| LD A, B | ld a, b |
| AND 7 | and 7 |
| RRCA | rrca |
| RRCA | rrca |
| RRCA | rrca |
| ADD A, C | add a, c |
| LD E, A ; DE contiene ahora la direccion destino. | ld e, a ; DE contiene ahora la direccion destino. |
| |
| ;;; Calcular posicion origen (array sprites) en HL como: | ;;; Calcular posicion origen (array sprites) en HL como: |
| ;;; direccion = base_sprites + (NUM_SPRITE*8) | ;;; direccion = base_sprites + (NUM_SPRITE*8) |
| EX AF, AF' ; Recuperamos el caracter a dibujar de A' | ex af, af' ; Recuperamos el caracter a dibujar de A' |
| LD BC, (FONT_CHARSET) | ld bc, (FONT_CHARSET) |
| LD H, 0 | ld h, 0 |
| LD L, A | ld l, a |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, BC ; HL = BC + HL = FONT_CHARSET + (A * 8) | add hl, bc ; HL = BC + HL = FONT_CHARSET + (A * 8) |
| |
| EX DE, HL ; Intercambiamos DE y HL (DE=origen, HL=destino) | ex de, hl ; Intercambiamos DE y HL (DE=origen, HL=destino) |
| |
| ;;; NUEVO: Verificacion del estilo actual | ;;; NUEVO: Verificacion del estilo actual |
| LD A, (FONT_STYLE) ; Obtenemos el estilo actual | ld a, (FONT_STYLE) ; Obtenemos el estilo actual |
| OR A | or a |
| JR NZ, pchar8_estilos_on ; Si es != cero, saltar | jr nz, pchar8_estilos_on ; Si es != cero, saltar |
| |
| ;;;;;; Estilo NORMAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo NORMAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| LD B, 8 ; 8 scanlines a dibujar | ld b, 8 ; 8 scanlines a dibujar |
| drawchar_loop_normal: | drawchar_loop_normal: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_normal | djnz drawchar_loop_normal |
| JR pchar8_printattr ; Imprimir atributos | jr pchar8_printattr ; Imprimir atributos |
| |
| pchar8_estilos_on: | pchar8_estilos_on: |
| CP FONT_BOLD ; ¿Es estilo NEGRITA? | cp FONT_BOLD ; ¿Es estilo NEGRITA? |
| JR NZ, pchar8_nobold ; No, saltar | jr nz, pchar8_nobold ; No, saltar |
| |
| ;;;;;; Estilo NEGRITA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo NEGRITA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| LD B, 8 ; 8 scanlines a dibujar | ld b, 8 ; 8 scanlines a dibujar |
| drawchar_loop_bold: | drawchar_loop_bold: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD C, A ; Creamos copia de A | ld c, a ; Creamos copia de A |
| RRCA ; Desplazamos A | rrca ; Desplazamos A |
| OR C ; Y agregamos C | or c ; Y agregamos C |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE ; Incrementamos puntero en caracter | inc de ; Incrementamos puntero en caracter |
| INC H ; Incrementamos puntero en pantalla (scanline+=1) | inc h ; Incrementamos puntero en pantalla (scanline+=1) |
| DJNZ drawchar_loop_bold | djnz drawchar_loop_bold |
| JR pchar8_printattr | jr pchar8_printattr |
| |
| pchar8_nobold: | pchar8_nobold: |
| CP FONT_UNDERSC ; ¿Es estilo SUBRAYADO? | cp FONT_UNDERSC ; ¿Es estilo SUBRAYADO? |
| JR NZ, pchar8_noundersc ; No, saltar | jr nz, pchar8_noundersc ; No, saltar |
| |
| ;;;;;; Estilo SUBRAYADO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo SUBRAYADO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| LD B, 7 ; 7 scanlines a dibujar normales | ld b, 7 ; 7 scanlines a dibujar normales |
| drawchar_loop_undersc: | drawchar_loop_undersc: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_undersc | djnz drawchar_loop_undersc |
| |
| ;;; El octavo scanline, una linea de subrayado | ;;; El octavo scanline, una linea de subrayado |
| LD A, 255 ; Ultima linea = subrayado | ld a, 255 ; Ultima linea = subrayado |
| LD (HL), A | ld (hl), a |
| INC H ; Necesario para el SUB A, 8 | inc h ; Necesario para el sub a, 8 |
| JR pchar8_printattr | jr pchar8_printattr |
| |
| pchar8_noundersc: | pchar8_noundersc: |
| CP FONT_ITALIC ; ¿Es estilo ITALICA? | cp FONT_ITALIC ; ¿Es estilo ITALICA? |
| JR NZ, pchar8_UNKNOWN ; No, saltar | jr nz, pchar8_UNKNOWN ; No, saltar |
| |
| ;;;;;; Estilo ITALICA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | ;;;;;; Estilo ITALICA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;; 3 primeros scanlines, a la derecha, | ;;; 3 primeros scanlines, a la derecha, |
| LD B, 3 | ld b, 3 |
| drawchar_loop_italic1: | drawchar_loop_italic1: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| SRA A ; Desplazamos A a la derecha | sra a ; Desplazamos A a la derecha |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_italic1 | djnz drawchar_loop_italic1 |
| |
| ;;; 2 siguientes scanlines, sin tocar | ;;; 2 siguientes scanlines, sin tocar |
| LD B, 2 | ld b, 2 |
| |
| drawchar_loop_italic2: | drawchar_loop_italic2: |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_italic2 | djnz drawchar_loop_italic2 |
| |
| LD B, 3 | ld b, 3 |
| drawchar_loop_italic3: | drawchar_loop_italic3: |
| ;;; 3 ultimos scanlines, a la izquierda, | ;;; 3 ultimos scanlines, a la izquierda, |
| LD A, (DE) ; Tomamos el dato del caracter | ld a, (de) ; Tomamos el dato del caracter |
| SLA A ; Desplazamos A | sla a ; Desplazamos A |
| LD (HL), A ; Establecemos el valor en videomemoria | ld (hl), a ; Establecemos el valor en videomemoria |
| INC DE | inc de |
| INC H | inc h |
| DJNZ drawchar_loop_italic3 | djnz drawchar_loop_italic3 |
| JR pchar8_printattr | jr pchar8_printattr |
| |
| pchar8_UNKNOWN: ; Estilo desconocido... | pchar8_UNKNOWN: ; Estilo desconocido... |
| LD B, 8 ; Lo imprimimos con el normal | ld b, 8 ; Lo imprimimos con el normal |
| JR drawchar_loop_normal ; (estilo por defecto) | jr drawchar_loop_normal ; (estilo por defecto) |
| |
| ;;; Impresion de los atributos | ;;; Impresion de los atributos |
| pchar8_printattr: | pchar8_printattr: |
| |
| LD A, H ; Recuperamos el valor inicial de HL | ld a, h ; Recuperamos el valor inicial de HL |
| SUB 8 ; Restando los 8 scanlines avanzados | sub 8 ; Restando los 8 scanlines avanzados |
| |
| ;;; Calcular posicion destino en area de atributos en DE. | ;;; Calcular posicion destino en area de atributos en DE. |
| ; A = H | ; A = H |
| RRCA ; Codigo de Get_Attr_Offset_From_Image | rrca ; Codigo de Get_Attr_Offset_From_Image |
| RRCA | rrca |
| RRCA | rrca |
| AND 3 | and 3 |
| OR $58 | or $58 |
| LD D, A | ld d, a |
| LD E, L | ld e, l |
| |
| ;;; Escribir el atributo en memoria | ;;; Escribir el atributo en memoria |
| LD A, (FONT_ATTRIB) | ld a, (FONT_ATTRIB) |
| LD (DE), A ; Escribimos el atributo en memoria | ld (de), a ; Escribimos el atributo en memoria |
| RET | ret |
| </code> | </code> |
| |
| ORG 35000 | ORG 35000 |
| |
| LD HL, $3D00-256 ; Saltamos los 32 caracteres iniciales | ld hl, $3d00-256 ; Saltamos los 32 caracteres iniciales |
| LD (FONT_CHARSET), HL | ld (FONT_CHARSET), hl |
| LD A, 1+(7*8) | ld a, 1+(7*8) |
| LD (FONT_ATTRIB), A | ld (FONT_ATTRIB), a |
| |
| ;;; Probamos los diferentes estilos: NORMAL | ;;; Probamos los diferentes estilos: NORMAL |
| LD A, FONT_NORMAL | ld a, FONT_NORMAL |
| LD (FONT_STYLE), A | ld (FONT_STYLE), a |
| LD HL, cadena1 | ld hl, cadena1 |
| LD A, 4 | ld a, 4 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| XOR A | xor a |
| LD (FONT_X), A | ld (FONT_X), a |
| CALL PrintString_8x8 | call PrintString_8x8 |
| |
| ;;; Probamos los diferentes estilos: NEGRITA | ;;; Probamos los diferentes estilos: NEGRITA |
| LD A, FONT_BOLD | ld a, FONT_BOLD |
| LD (FONT_STYLE), A | ld (FONT_STYLE), a |
| LD HL, cadena2 | ld hl, cadena2 |
| LD A, 6 | ld a, 6 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| XOR A | xor a |
| LD (FONT_X), A | ld (FONT_X), a |
| CALL PrintString_8x8 | call PrintString_8x8 |
| |
| ;;; Probamos los diferentes estilos: CURSIVA | ;;; Probamos los diferentes estilos: CURSIVA |
| LD A, FONT_ITALIC | ld a, FONT_ITALIC |
| LD (FONT_STYLE), A | ld (FONT_STYLE), a |
| LD HL, cadena3 | ld hl, cadena3 |
| LD A, 8 | ld a, 8 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| XOR A | xor a |
| LD (FONT_X), A | ld (FONT_X), a |
| CALL PrintString_8x8 | call PrintString_8x8 |
| |
| ;;; Probamos los diferentes estilos: SUBRAYADO | ;;; Probamos los diferentes estilos: SUBRAYADO |
| LD A, FONT_UNDERSC | ld a, FONT_UNDERSC |
| LD (FONT_STYLE), A | ld (FONT_STYLE), a |
| LD HL, cadena4 | ld hl, cadena4 |
| LD A, 10 | ld a, 10 |
| LD (FONT_Y), A | ld (FONT_Y), a |
| XOR A | xor a |
| LD (FONT_X), A | ld (FONT_X), a |
| CALL PrintString_8x8 | call PrintString_8x8 |
| |
| loop: | loop: |
| JR loop | jr loop |
| |
| RET | ret |
| |
| cadena1 DB "IMPRESION CON ESTILO NORMAL.", 0 | cadena1 DB "IMPRESION CON ESTILO NORMAL.", 0 |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| FONT_CHARSET DW $3D00-256 | FONT_CHARSET DW $3d00-256 |
| FONT_ATTRIB DB 56 ; Negro sobre gris | FONT_ATTRIB DB 56 ; Negro sobre gris |
| FONT_STYLE DB 0 | FONT_STYLE DB 0 |
| |
| <code z80> | <code z80> |
| LD A, (FONT_STYLE) | ld a, (FONT_STYLE) |
| OR A | or a |
| JR NZ, pchar8_estilos_on ; Aqui no se produce salto | jr nz, pchar8_estilos_on ; Aqui no se produce salto |
| |
| + | + |
| |
| JR pchar8_printattr ; Este salto si se produce | jr pchar8_printattr ; Este salto si se produce |
| </code> | </code> |
| |
| Son 13 (''LD'') + 4 (''OR'') + 7 (''JR NZ sin salto'') + 12 (''JR'') = 36 t-estados adicionales por carácter en estilo normal a cambio de la posibilidad de disponer de 4 estilos de texto diferentes para cualquier charset, incluído el de la ROM. | Son 13 (''LD'') + 4 (''OR'') + 7 (''jr NZ sin salto'') + 12 (''jr'') = 36 t-estados adicionales por carácter en estilo normal a cambio de la posibilidad de disponer de 4 estilos de texto diferentes para cualquier charset, incluído el de la ROM. |
| |
| En la rutina se han utilizado operaciones de transferencia LD para imprimir los caracteres, lo que implica que no se respeta el fondo sobre el que se imprime, y se ponen a cero en pantalla todos los píxeles a cero en el charset. Este suele ser el sistema de impresión habitual puesto que el texto, para hacerlo legible, suele imprimirse sobre áreas en blanco de la pantalla, y un caracter impreso sobre otro debe sobreescribir totalmente al primero. | En la rutina se han utilizado operaciones de transferencia LD para imprimir los caracteres, lo que implica que no se respeta el fondo sobre el que se imprime, y se ponen a cero en pantalla todos los píxeles a cero en el charset. Este suele ser el sistema de impresión habitual puesto que el texto, para hacerlo legible, suele imprimirse sobre áreas en blanco de la pantalla, y un caracter impreso sobre otro debe sobreescribir totalmente al primero. |
| ;;; Avanzar el puntero FONT_X | ;;; Avanzar el puntero FONT_X |
| ;;; Si HL es menor que 31 : | ;;; Si HL es menor que 31 : |
| ;;; Si es CERO, salir de la rutina con RET Z. | ;;; Si es CERO, salir de la rutina con ret z. |
| ;;; Si es FONT_SET_SETSTYLE (1): | ;;; Si es FONT_SET_SETSTYLE (1): |
| ;;; Coger el siguiente byte de la cadena (el estilo) | ;;; Coger el siguiente byte de la cadena (el estilo) |
| ;;; Si es FONT_TAB (15): | ;;; Si es FONT_TAB (15): |
| ;;; Llamar a funcion Font_Tab | ;;; Llamar a funcion Font_Tab |
| ;;; Saltar a bucle (se saldrá con el RET Z) | ;;; Saltar a bucle (se saldrá con el ret z) |
| </code> | </code> |
| |
| PrintString_8x8_Format: | PrintString_8x8_Format: |
| bucle: | bucle: |
| ;;; Coger caracter apuntador por HL. | ;;; Coger caracter apuntado por HL. |
| ;;; Incrementar HL | ;;; Incrementar HL |
| ;;; Si HL es mayor que 32 : | ;;; Si HL es mayor que 32 : |
| ;;; Avanzar el puntero FONT_X | ;;; Avanzar el puntero FONT_X |
| ;;; Si HL es menor que 31 : | ;;; Si HL es menor que 31 : |
| ;;; Si es CERO, salir de la rutina con RET Z. | ;;; Si es CERO, salir de la rutina con ret z. |
| ;;; Calculamos DIR_SALTO = TABLA_SALTOS [ COD_CONTROL ] | ;;; Calculamos DIR_SALTO = TABLA_SALTOS [ COD_CONTROL ] |
| ;;; Como la tabla es de 2 bytes -> DIR_SALTO = TABLA_SALTOS + COD_CONTROL*2 | ;;; Como la tabla es de 2 bytes -> DIR_SALTO = TABLA_SALTOS + COD_CONTROL*2 |
| ;;; Si es mayor que 10, no requiere recoger parametro | ;;; Si es mayor que 10, no requiere recoger parametro |
| ;;; Saltar a la dirección DIR_SALTO | ;;; Saltar a la dirección DIR_SALTO |
| ;;; Saltar a bucle (se saldrá con el RET Z) | ;;; Saltar a bucle (se saldrá con el ret z) |
| </code> | </code> |
| |
| ;;; Bucle de impresion de caracter | ;;; Bucle de impresion de caracter |
| pstring8_loop: | pstring8_loop: |
| LD A, (HL) ; Leemos un caracter de la cadena | ld a, (hl) ; Leemos un caracter de la cadena |
| INC HL ; Apuntamos al siguiente caracter | inc hl ; Apuntamos al siguiente caracter |
| |
| CP 32 ; Es menor que 32? | cp 32 ; Es menor que 32? |
| JP C, pstring8_ccontrol ; Si, es un codigo de control, saltar | jp c, pstring8_ccontrol ; Si, es un codigo de control, saltar |
| |
| PUSH HL ; Salvaguardamos HL | push hl ; Salvaguardamos HL |
| CALL PrintChar_8x8 ; Imprimimos el caracter | call PrintChar_8x8 ; Imprimimos el caracter |
| POP HL ; Recuperamos HL | pop hl ; Recuperamos HL |
| |
| ;;; Avanzamos el cursor usando Font_Blank, que incrementa X | ;;; Avanzamos el cursor usando Font_Blank, que incrementa X |
| ;;; y actualiza X e Y si se llega al borde de la pantalla | ;;; y actualiza X e Y si se llega al borde de la pantalla |
| CALL Font_Inc_X ; Avanzar coordenada X | call Font_Inc_X ; Avanzar coordenada X |
| JR pstring8_loop ; Continuar impresion hasta CHAR=0 | jr pstring8_loop ; Continuar impresion hasta CHAR=0 |
| |
| pstring8_ccontrol: | pstring8_ccontrol: |
| OR A ; A es cero? | or a ; A es cero? |
| RET Z ; Si es 0 (fin de cadena) volver | ret z ; Si es 0 (fin de cadena) volver |
| |
| ;;; Si estamos aqui es porque es un codigo de control distinto > 0 | ;;; Si estamos aqui es porque es un codigo de control distinto > 0 |
| ;;; Calculamos la direccion destino a la que saltar usando | ;;; Calculamos la direccion destino a la que saltar usando |
| ;;; la tabla de saltos y el codigo de control como indice | ;;; la tabla de saltos y el codigo de control como indice |
| EX DE, HL | ex de, hl |
| LD HL, FONT_CALL_JUMP_TABLE | ld hl, FONT_CALL_JUMP_TABLE |
| RLCA ; A = A * 2 = codigo de control * 2 | rlca ; A = A * 2 = codigo de control * 2 |
| LD C, A | ld c, a |
| LD B, 0 ; BC = A*2 | ld b, 0 ; BC = A*2 |
| ADD HL, BC ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) | add hl, bc ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) |
| LD C, (HL) ; Leemos la parte baja de la direccion en C... | ld c, (hl) ; Leemos la parte baja de la direccion en C... |
| INC HL ; ... para no corromper HL y poder leer ... | inc hl ; ... para no corromper HL y poder leer ... |
| LD H, (HL) ; ... la parte alta sobre H ... | ld h, (hl) ; ... la parte alta sobre H ... |
| LD L, C ; No hemos usado A porque se usa en el CP | ld l, c ; No hemos usado A porque se usa en el CP |
| |
| ;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina | ;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina |
| ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida | ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida |
| CP 18 ; Comprobamos si (CCONTROL-1)*2 < 18 | cp 18 ; Comprobamos si (CCONTROL-1)*2 < 18 |
| JP NC, pstring8_noparam ; Es decir, si CCONTROL > 9, no hay param | jp nc, pstring8_noparam ; Es decir, si CCONTROL > 9, no hay param |
| |
| ;;; Si CCONTROL < 10 -> recoger parametro: | ;;; Si CCONTROL < 10 -> recoger parametro: |
| LD A, (DE) ; Cogemos el parametro en cuestion de la cadena | ld a, (de) ; Cogemos el parametro en cuestion de la cadena |
| INC DE ; Apuntamos al siguiente caracter | inc de ; Apuntamos al siguiente caracter |
| |
| ;;; Realizamos el salto a la rutina con o sin parametro recogido | ;;; Realizamos el salto a la rutina con o sin parametro recogido |
| pstring8_noparam: | pstring8_noparam: |
| LD BC, pstring8_retaddr ; Ponemos en BC la dir de retorno | ld bc, pstring8_retaddr ; Ponemos en BC la dir de retorno |
| PUSH BC ; Hacemos un push de la dir de retorno | push bc ; Hacemos un push de la dir de retorno |
| JP (HL) ; Saltamos a la rutina seleccionada | jp (hl) ; Saltamos a la rutina seleccionada |
| |
| ;;; Este es el punto al que volvemos tras la rutina | ;;; Este es el punto al que volvemos tras la rutina |
| pstring8_retaddr: | pstring8_retaddr: |
| EX DE, HL ; Recuperamos en HL el puntero a cadena | ex de, hl ; Recuperamos en HL el puntero a cadena |
| JR pstring8_loop ; Continuamos en el bucle | jr pstring8_loop ; Continuamos en el bucle |
| |
| </code> | </code> |
| ;;; Calculamos la direccion destino a la que saltar usando | ;;; Calculamos la direccion destino a la que saltar usando |
| ;;; la tabla de saltos y el codigo de control como indice | ;;; la tabla de saltos y el codigo de control como indice |
| EX DE, HL | ex de, hl |
| LD HL, FONT_CALL_JUMP_TABLE | ld hl, FONT_CALL_JUMP_TABLE |
| RLCA ; A = A * 2 = codigo de control * 2 | rlca ; A = A * 2 = codigo de control * 2 |
| LD C, A | ld c, a |
| LD B, 0 ; BC = A*2 | ld b, 0 ; BC = A*2 |
| ADD HL, BC ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) | add hl, bc ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) |
| LD C, (HL) ; Leemos la parte baja de la direccion en C... | ld c, (hl) ; Leemos la parte baja de la direccion en C... |
| INC HL ; ... para no corromper HL y poder leer ... | inc hl ; ... para no corromper HL y poder leer ... |
| LD H, (HL) ; ... la parte alta sobre H ... | ld h, (hl) ; ... la parte alta sobre H ... |
| LD L, C ; No hemos usado A porque se usa en el CP | ld l, c ; No hemos usado A porque se usa en el CP |
| ; HL = FONT_CALL_JUMP_TABLE+(CodControl*2) | ; HL = FONT_CALL_JUMP_TABLE+(CodControl*2) |
| |
| ; (...) ; Codigo de recogida de parametro si procede | ; (...) ; Codigo de recogida de parametro si procede |
| |
| LD BC, pstring8_retaddr ; Ponemos en BC la dir de retorno | ld bc, pstring8_retaddr ; Ponemos en BC la dir de retorno |
| PUSH BC ; Hacemos un push de la dir de retorno | push bc ; Hacemos un push de la dir de retorno |
| JP (HL) ; Saltamos a la rutina seleccionada | jp (hl) ; Saltamos a la rutina seleccionada |
| |
| ;;; Este es el punto al que volvemos tras la rutina | ;;; Este es el punto al que volvemos tras la rutina |
| Con el anterior cálculo, por ejemplo, si recibimos un código de control 6, se pondrá en HL la dirección de memoria contenida en FONT_CALL_JUMP_TABLE+(6*2), que es el valor ''Font_Set_Attrib'', que el ensamblador sustituirá en la tabla durante el proceso de ensamblado por la dirección de memoria de dicha rutina. | Con el anterior cálculo, por ejemplo, si recibimos un código de control 6, se pondrá en HL la dirección de memoria contenida en FONT_CALL_JUMP_TABLE+(6*2), que es el valor ''Font_Set_Attrib'', que el ensamblador sustituirá en la tabla durante el proceso de ensamblado por la dirección de memoria de dicha rutina. |
| |
| Nótese cómo después de calcular el valor de salto correcto para HL tenemos que simular un ''CALL HL'' que no forma parte del juego de instrucciones del Spectrum. ¿Cómo realizamos esto? Utilizando la pila y la instrucción JP. Recordemos que un CALL es un salto a subrutina, lo cual implica introducir en la pila la dirección de retorno y salta a la dirección de la rutina. Cuando la rutina realice el RET, se extrae de la pila la dirección de retorno para continuar el flujo del programa. | Nótese cómo después de calcular el valor de salto correcto para HL tenemos que simular un ''call HL'' que no forma parte del juego de instrucciones del Spectrum. ¿Cómo realizamos esto? Utilizando la pila y la instrucción jp. Recordemos que un call es un salto a subrutina, lo cual implica introducir en la pila la dirección de retorno y salta a la dirección de la rutina. Cuando la rutina realice el ret, se extrae de la pila la dirección de retorno para continuar el flujo del programa. |
| |
| En el código anterior introducimos en el registro BC la dirección de la etiqueta ''pstring8_retaddr'', que es la posición exacta de memoria después del salto. Una vez introducida en la pila la dirección de retorno, saltamos con el salto incondicional ''JP (HL)'' a la rutina especificada por el código de control. La subrutina efectuará la tarea correspondiente y volverá con un RET, provocando que la rutina de impresión de cadenas continúe en ''pstring8_retaddr'', que es la dirección que el ''RET'' extraerá de la pila para volver. | En el código anterior introducimos en el registro BC la dirección de la etiqueta ''pstring8_retaddr'', que es la posición exacta de memoria después del salto. Una vez introducida en la pila la dirección de retorno, saltamos con el salto incondicional ''jp (hl)'' a la rutina especificada por el código de control. La subrutina efectuará la tarea correspondiente y volverá con un ret, provocando que la rutina de impresión de cadenas continúe en ''pstring8_retaddr'', que es la dirección que el ''RET'' extraerá de la pila para volver. |
| |
| Hemos hecho distinción de 2 tipos de subrutinas de control, ya que las 9 primeras requieren recoger un parámetro de la cadena (apuntado por HL) y las restantes no. El cálculo de la dirección de salto es igual en todos los casos pero para las 9 primeras es necesario obtener el dato adicional al código de control en el registro A antes de saltar. El registro A es el parámetro común en todas las subrutinas de gestión de códigos de control que requieren parámetros, algo necesario para poder usar las rutinas vía tabla de saltos. | Hemos hecho distinción de 2 tipos de subrutinas de control, ya que las 9 primeras requieren recoger un parámetro de la cadena (apuntado por HL) y las restantes no. El cálculo de la dirección de salto es igual en todos los casos pero para las 9 primeras es necesario obtener el dato adicional al código de control en el registro A antes de saltar. El registro A es el parámetro común en todas las subrutinas de gestión de códigos de control que requieren parámetros, algo necesario para poder usar las rutinas vía tabla de saltos. |
| ;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina | ;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina |
| ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida | ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida |
| CP 18 ; Comprobamos si (CCONTROL-1)*2 < 18 | cp 18 ; Comprobamos si (CCONTROL-1)*2 < 18 |
| JP NC, pstring8_noparam ; Es decir, si CCONTROL > 9, no hay param | jp nc, pstring8_noparam ; Es decir, si CCONTROL > 9, no hay param |
| </code> | </code> |
| |
| ORG 35000 | ORG 35000 |
| |
| LD HL, $3D00-256 ; Saltamos los 32 caracteres iniciales | ld hl, $3d00-256 ; Saltamos los 32 caracteres iniciales |
| CALL Font_Set_Charset | call Font_Set_Charset |
| |
| LD A, 1+(7*8) | ld a, 1+(7*8) |
| Call Font_Set_Attrib | Call Font_Set_Attrib |
| |
| ;;; Probamos los diferentes estilos: NORMAL | ;;; Probamos los diferentes estilos: NORMAL |
| LD A, FONT_NORMAL | ld a, FONT_NORMAL |
| CALL Font_Set_Style | call Font_Set_Style |
| LD HL, cadena1 | ld hl, cadena1 |
| LD B, 4 | ld b, 4 |
| LD C, 0 | ld c, 0 |
| CALL Font_Set_XY | call Font_Set_XY |
| CALL PrintString_8x8_Format | call PrintString_8x8_Format |
| |
| loop: | loop: |
| JR loop | jr loop |
| |
| cadena1 DB "SALTO DE", FONT_LF, "LINEA ", FONT_SET_X, 4, FONT_SET_Y, 9 | cadena1 DB "SALTO DE", FONT_LF, "LINEA ", FONT_SET_X, 4, FONT_SET_Y, 9 |
| Recomendamos al lector que utilice siempre en sus cadenas los códigos de control mediante las constantes EQU en lugar de utilizar los códigos numéricos en sí mismos. Esto permite reubicar los valores numéricos (los EQUs) sin modificar las cadenas. Recordemos que el ensamblador sustituirá las constantes por sus valores numéricos durante el proceso de ensamblado, por lo que la ocupación en las cadenas definitivas no será "mayor" al usar las constantes. El único código de control que no debe reubicarse nunca es FONT_EOS (0). | Recomendamos al lector que utilice siempre en sus cadenas los códigos de control mediante las constantes EQU en lugar de utilizar los códigos numéricos en sí mismos. Esto permite reubicar los valores numéricos (los EQUs) sin modificar las cadenas. Recordemos que el ensamblador sustituirá las constantes por sus valores numéricos durante el proceso de ensamblado, por lo que la ocupación en las cadenas definitivas no será "mayor" al usar las constantes. El único código de control que no debe reubicarse nunca es FONT_EOS (0). |
| |
| Finalmente, creemos importante indicar al lector que para marcar claramente la dirección de salto del código de control 9 (que no está en uso) se ha usado la cadena "0000", pero probablemente sería más seguro el colocar la dirección de una rutina como FONT_TAB o FONT_CRLF. De esta forma, ante un error del programador al escribir una cadena y utilizar el inexistente código 9 en ella, evitaremos que se produzca un reset (''JP $0000'') que nos cueste gran cantidad de horas de encontrar / depurar. | Finalmente, creemos importante indicar al lector que para marcar claramente la dirección de salto del código de control 9 (que no está en uso) se ha usado la cadena "0000", pero probablemente sería más seguro el colocar la dirección de una rutina como FONT_TAB o FONT_CRLF. De esta forma, ante un error del programador al escribir una cadena y utilizar el inexistente código 9 en ella, evitaremos que se produzca un reset (''jp $0000'') que nos cueste gran cantidad de horas de encontrar / depurar. |
| |
| En cuanto a las diferencias en tiempo de ejecución de PrintString_8x8_Format vs PrintString_8x8, cabe destacar que el coste adicional de la rutina para la impresión del texto normal (ASCIIs < 32) se reduce a las siguientes 2 instrucciones adicionales: | En cuanto a las diferencias en tiempo de ejecución de PrintString_8x8_Format vs PrintString_8x8, cabe destacar que el coste adicional de la rutina para la impresión del texto normal (ASCIIs < 32) se reduce a las siguientes 2 instrucciones adicionales: |
| |
| <code z80> | <code z80> |
| CP 32 ; Es menor que 32? | cp 32 ; Es menor que 32? |
| JP C, pstring8_ccontrol ; Si, es un codigo de control, saltar | jp c, pstring8_ccontrol ; Si, es un codigo de control, saltar |
| </code> | </code> |
| |
| Aparte de eso, se ha sustituído el código de avance de la coordenada X por el de las rutinas genéricas vistas anteriormente, lo que añade un ''CALL Font_Inc_X'' (y su ''RET'') adicional. Así pues, el coste en tiempo de ejecución no difiere apenas de la función sin códigos de control. | Aparte de eso, se ha sustituído el código de avance de la coordenada X por el de las rutinas genéricas vistas anteriormente, lo que añade un ''call Font_Inc_X'' (y su ''RET'') adicional. Así pues, el coste en tiempo de ejecución no difiere apenas de la función sin códigos de control. |
| |
| En el caso del código de fin de cadena (EOS = 0), ya no se sale de la rutina con un RET Z sino que se pasa por el ''CP 32'' y se realiza el salto a ''pstring8_ccontrol''. | En el caso del código de fin de cadena (EOS = 0), ya no se sale de la rutina con un ret z sino que se pasa por el ''cp 32'' y se realiza el salto a ''pstring8_ccontrol''. |
| |
| Sí que hay un coste real en la ocupación de memoria, puesto que todas las funciones auxiliares de control que hemos definido seguramente pueden no resultarnos útiles en la programación de un juego donde no se utilice apenas texto. Ese código adicional sumado a la gestión de códigos de control de la rutina y a la tabla de saltos puede ser espacio utilizable por nosotros si empleados la rutina sin formato ''PrintString_8x8''. | Sí que hay un coste real en la ocupación de memoria, puesto que todas las funciones auxiliares de control que hemos definido seguramente pueden no resultarnos útiles en la programación de un juego donde no se utilice apenas texto. Ese código adicional sumado a la gestión de códigos de control de la rutina y a la tabla de saltos puede ser espacio utilizable por nosotros si empleados la rutina sin formato ''PrintString_8x8''. |
| ;;; Avanzar el puntero FONT_X | ;;; Avanzar el puntero FONT_X |
| ;;; Si HL es menor que 31 : | ;;; Si HL es menor que 31 : |
| ;;; Si es CERO, salir de la rutina con RET Z. | ;;; Si es CERO, salir de la rutina con ret z. |
| (...) | (...) |
| |
| <code z80> | <code z80> |
| loop: | loop: |
| LD A, (HL) ; Leemos un caracter de la cadena | ld a, (hl) ; Leemos un caracter de la cadena |
| |
| ;;; (...) | ;;; (...) |
| |
| CP '%' ; Es un caracter %? | cp '%' ; Es un caracter %? |
| JR NZ, pstring8_novar ; Comprobamos si es variable | jr nz, pstring8_novar ; Comprobamos si es variable |
| LD A, (HL) ; Cogemos en A el siguiente char | ld a, (hl) ; Cogemos en A el siguiente char |
| INC HL | inc hl |
| CP '%' ; Es otro caracter %? (leido %%?) | cp '%' ; Es otro caracter %? (leido %%?) |
| JR NZ, pstring8v_var ; No, es una variable -> Saltar | jr nz, pstring8v_var ; No, es una variable -> Saltar |
| ; Si, era %, seguir para imprimirlo | ; Si, era %, seguir para imprimirlo |
| (...) | (...) |
| pstring8v_var: | pstring8v_var: |
| ;;; comprobamos los tipos y saltamos a sus rutinas de gestion | ;;; comprobamos los tipos y saltamos a sus rutinas de gestion |
| CP 'd' | cp 'd' |
| JR Z, pstring8v_int8 | jr z, pstring8v_int8 |
| CP 't' | cp 't' |
| JR Z, pstring8v_int8_2d | jr z, pstring8v_int8_2d |
| CP 'D' | cp 'D' |
| JR Z, pstring8v_int16 | jr z, pstring8v_int16 |
| CP 's' | cp 's' |
| JR Z, pstring8v_string | jr z, pstring8v_string |
| CP 'x' | cp 'x' |
| JR Z, pstring8v_hex8 | jr z, pstring8v_hex8 |
| CP 'X' | cp 'X' |
| JR Z, pstring8v_hex16 | jr z, pstring8v_hex16 |
| CP 'b' | cp 'b' |
| JP Z, pstring8v_bin8 | jp z, pstring8v_bin8 |
| CP 'B' | cp 'B' |
| JP Z, pstring8v_bin16 | jp z, pstring8v_bin16 |
| JP pstring8_novar ; Otro: imprimir caracter tal cual | jp pstring8_novar ; Otro: imprimir caracter tal cual |
| </code> | </code> |
| |
| |
| <code z80> | <code z80> |
| CP 'd' | cp 'd' |
| JR Z, pstring8v_int8 | jr z, pstring8v_int8 |
| |
| (...) | (...) |
| pstring8v_int8: | pstring8v_int8: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_8 | call Int2String_8 |
| LD HL, conv2string | ld hl, conv2string |
| CALL INC_HL_Remove_Leading_Zeros | call INC_HL_Remove_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| </code> | </code> |
| |
| ;;; Bucle de impresion de caracter | ;;; Bucle de impresion de caracter |
| pstring8v_loop: | pstring8v_loop: |
| LD A, (HL) ; Leemos un caracter de la cadena | ld a, (hl) ; Leemos un caracter de la cadena |
| INC HL ; Apuntamos al siguiente caracter | inc hl ; Apuntamos al siguiente caracter |
| |
| CP 32 ; Es menor que 32? | cp 32 ; Es menor que 32? |
| JP C, pstring8v_ccontrol ; Si, es un codigo de control, saltar | jp c, pstring8v_ccontrol ; Si, es un codigo de control, saltar |
| |
| CP '%' ; Es un caracter %? | cp '%' ; Es un caracter %? |
| JR NZ, pstring8_novar ; Comprobamos si es variable | jr nz, pstring8_novar ; Comprobamos si es variable |
| LD A, (HL) ; Cogemos en A el siguiente char | ld a, (hl) ; Cogemos en A el siguiente char |
| INC HL | inc hl |
| CP '%' ; Es otro caracter %? (leido %%?) | cp '%' ; Es otro caracter %? (leido %%?) |
| JR NZ, pstring8v_var ; No, es una variable -> Saltar | jr nz, pstring8v_var ; No, es una variable -> Saltar |
| ; Si, era %, seguir para imprimirlo | ; Si, era %, seguir para imprimirlo |
| pstring8_novar: | pstring8_novar: |
| PUSH HL ; Salvaguardamos HL | push hl ; Salvaguardamos HL |
| CALL PrintChar_8x8 ; Imprimimos el caracter | call PrintChar_8x8 ; Imprimimos el caracter |
| POP HL ; Recuperamos HL | pop hl ; Recuperamos HL |
| |
| ;;; Avanzamos el cursor usando Font_Blank, que incrementa X | ;;; Avanzamos el cursor usando Font_Blank, que incrementa X |
| ;;; y actualiza X e Y si se llega al borde de la pantalla | ;;; y actualiza X e Y si se llega al borde de la pantalla |
| CALL Font_Inc_X ; Avanzar coordenada X | call Font_Inc_X ; Avanzar coordenada X |
| JR pstring8v_loop ; Continuar impresion hasta CHAR=0 | jr pstring8v_loop ; Continuar impresion hasta CHAR=0 |
| |
| pstring8v_ccontrol: | pstring8v_ccontrol: |
| OR A ; A es cero? | or a ; A es cero? |
| RET Z ; Si es 0 (fin de cadena) volver | ret z ; Si es 0 (fin de cadena) volver |
| |
| ;;; Si estamos aqui es porque es un codigo de control distinto > 0 | ;;; Si estamos aqui es porque es un codigo de control distinto > 0 |
| ;;; Calculamos la direccion destino a la que saltar usando | ;;; Calculamos la direccion destino a la que saltar usando |
| ;;; la tabla de saltos y el codigo de control como indice | ;;; la tabla de saltos y el codigo de control como indice |
| EX DE, HL | ex de, hl |
| LD HL, FONT_CALL_JUMP_TABLE | ld hl, FONT_CALL_JUMP_TABLE |
| DEC A ; Decrementamos A (puntero en tabla) | dec a ; Decrementamos A (puntero en tabla) |
| RLCA ; A = A * 2 = codigo de control * 2 | rlca ; A = A * 2 = codigo de control * 2 |
| LD C, A | ld c, a |
| LD B, 0 ; BC = A*2 | ld b, 0 ; BC = A*2 |
| ADD HL, BC ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) | add hl, bc ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) |
| LD C, (HL) | ld c, (hl) |
| INC HL | inc hl |
| LD H, (HL) | ld h, (hl) |
| LD L, C ; Leemos la direccion de la tabla en HL | ld l, c ; Leemos la direccion de la tabla en HL |
| |
| ;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina | ;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina |
| ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida | ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida |
| CP 18 ; Comprobamos si (CCONTROL-1)*2 < 18 | cp 18 ; Comprobamos si (CCONTROL-1)*2 < 18 |
| JP NC, pstring8v_noparam ; Es decir, si CCONTROL > 9, no hay param | jp nc, pstring8v_noparam ; Es decir, si CCONTROL > 9, no hay param |
| |
| ;;; Si CCONTROL < 10 -> recoger parametro: | ;;; Si CCONTROL < 10 -> recoger parametro: |
| LD A, (DE) ; Cogemos el parametro en cuestion de la cadena | ld a, (de) ; Cogemos el parametro en cuestion de la cadena |
| INC DE ; Apuntamos al siguiente caracter | inc de ; Apuntamos al siguiente caracter |
| |
| ;;; Realizamos el salto a la rutina con o sin parametro recogido | ;;; Realizamos el salto a la rutina con o sin parametro recogido |
| pstring8v_noparam: | pstring8v_noparam: |
| LD BC, pstring8v_retaddr ; Ponemos en BC la dir de retorno | ld bc, pstring8v_retaddr ; Ponemos en BC la dir de retorno |
| PUSH BC ; Hacemos un push de la dir de retorno | push bc ; Hacemos un push de la dir de retorno |
| JP (HL) ; Saltamos a la rutina seleccionada | jp (hl) ; Saltamos a la rutina seleccionada |
| |
| ;;; Este es el punto al que volvemos tras la rutina | ;;; Este es el punto al que volvemos tras la rutina |
| pstring8v_retaddr: | pstring8v_retaddr: |
| EX DE, HL ; Recuperamos en HL el puntero a cadena | ex de, hl ; Recuperamos en HL el puntero a cadena |
| JR pstring8v_loop ; Continuamos en el bucle | jr pstring8v_loop ; Continuamos en el bucle |
| |
| ;;; Aqui se gestionan los codigos de control con % (tipo = A) | ;;; Aqui se gestionan los codigos de control con % (tipo = A) |
| pstring8v_var: | pstring8v_var: |
| ;;; comprobamos los tipos y saltamos a sus rutinas de gestion | ;;; comprobamos los tipos y saltamos a sus rutinas de gestion |
| CP 'd' | cp 'd' |
| JR Z, pstring8v_int8 | jr z, pstring8v_int8 |
| CP 't' | cp 't' |
| JR Z, pstring8v_int8_2d | jr z, pstring8v_int8_2d |
| CP 'D' | cp 'D' |
| JR Z, pstring8v_int16 | jr z, pstring8v_int16 |
| CP 's' | cp 's' |
| JR Z, pstring8v_string | jr z, pstring8v_string |
| CP 'x' | cp 'x' |
| JR Z, pstring8v_hex8 | jr z, pstring8v_hex8 |
| CP 'X' | cp 'X' |
| JP Z, pstring8v_hex16 | jp z, pstring8v_hex16 |
| CP 'b' | cp 'b' |
| JP Z, pstring8v_bin8 | jp z, pstring8v_bin8 |
| CP 'B' | cp 'B' |
| JP Z, pstring8v_bin16 | jp z, pstring8v_bin16 |
| JP pstring8_novar ; Otro: imprimir caracter tal cual | jp pstring8_novar ; Otro: imprimir caracter tal cual |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int8: | pstring8v_int8: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_8 | call Int2String_8 |
| LD HL, conv2string | ld hl, conv2string |
| CALL INC_HL_Remove_Leading_Zeros | call INC_HL_Remove_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int8_2d: | pstring8v_int8_2d: |
| PUSH HL | push hl |
| LD A, (IX+0) | ld a, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_8_2Digits | call Int2String_8_2Digits |
| LD A, D ; Resultado conversion en DE | ld a, d ; Resultado conversion en DE |
| PUSH DE | push de |
| CALL PrintChar_8x8 ; Imprimir parte alta (decenas) | call PrintChar_8x8 ; Imprimir parte alta (decenas) |
| CALL Font_Inc_X | call Font_Inc_X |
| POP DE | pop de |
| LD A, E | ld a, e |
| CALL PrintChar_8x8 ; Imprimir parte alta (decenas) | call PrintChar_8x8 ; Imprimir parte alta (decenas) |
| CALL Font_Inc_X | call Font_Inc_X |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int16: | pstring8v_int16: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| LD H, (IX+0) | ld h, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_16 | call Int2String_16 |
| LD HL, conv2string | ld hl, conv2string |
| CALL INC_HL_Remove_Leading_Zeros | call INC_HL_Remove_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_string: | pstring8v_string: |
| PUSH HL | push hl |
| PUSH IX ; HL = IX | push ix ; HL = IX |
| POP HL | pop hl |
| call PrintString_8x8 ; Imprimimos cadena | call PrintString_8x8 ; Imprimimos cadena |
| POP HL | pop hl |
| pstring8v_strloop: ; Incrementamos IX hasta el fin | pstring8v_strloop: ; Incrementamos IX hasta el fin |
| LD A, (IX+0) ; de la cadena, recorriendola | ld a, (ix+0) ; de la cadena, recorriendola |
| INC IX ; hasta (IX) = 0 | inc ix ; hasta (IX) = 0 |
| OR A | or a |
| JR NZ, pstring8v_strloop | jr nz, pstring8v_strloop |
| |
| ; De esta forma IX ya apunta al siguiente argumento | ; De esta forma IX ya apunta al siguiente argumento |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_hex8: | pstring8v_hex8: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| LD L, 40 | ld l, 40 |
| CALL Hex2String_8 | call Hex2String_8 |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_hex16: | pstring8v_hex16: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| LD H, (IX+0) | ld h, (ix+0) |
| INC IX | inc ix |
| CALL Hex2String_16 | call Hex2String_16 |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_bin8: | pstring8v_bin8: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| CALL Bin2String_8 | call Bin2String_8 |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_bin16: | pstring8v_bin16: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| LD H, (IX+0) | ld h, (ix+0) |
| INC IX | inc ix |
| CALL Bin2String_16 | call Bin2String_16 |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| </code> | </code> |
| |
| ORG 35000 | ORG 35000 |
| |
| LD HL, $3D00-256 | ld hl, $3d00-256 |
| CALL Font_Set_Charset | call Font_Set_Charset |
| |
| LD BC, $0400 | ld bc, $0400 |
| CALL Font_Set_XY | call Font_Set_XY |
| |
| LD HL, cadena1 | ld hl, cadena1 |
| LD IX, args1 | ld ix, args1 |
| CALL PrintString_8x8_Format_Args | call PrintString_8x8_Format_Args |
| |
| LD HL, cadena2 | ld hl, cadena2 |
| LD IX, args2 | ld ix, args2 |
| CALL PrintString_8x8_Format_Args | call PrintString_8x8_Format_Args |
| |
| loop: | loop: |
| JR loop | jr loop |
| RET | ret |
| |
| cadena1 DB "VALOR 8 bits: 40", FONT_CRLF, FONT_CRLF | cadena1 DB "Valor 8 bits: 40", FONT_CRLF, FONT_CRLF |
| DB "Decimal: %d" , FONT_CRLF | DB "Decimal: %d" , FONT_CRLF |
| DB "Hexadecimal: $%x" , FONT_CRLF | DB "Hexadecimal: $%x" , FONT_CRLF |
| DB "Binario: %%%b" , FONT_CRLF | DB "Binario: %%%b" , FONT_CRLF |
| DB FONT_CRLF, FONT_CRLF | DB FONT_CRLF, FONT_CRLF |
| DB "VALOR 16 bits: 1205", FONT_CRLF, FONT_CRLF | DB "Valor 16 bits: 1205", FONT_CRLF, FONT_CRLF |
| DB "Decimal: %D" , FONT_CRLF | DB "Decimal: %D" , FONT_CRLF |
| DB "Hexadecimal: $%X" , FONT_CRLF | DB "Hexadecimal: $%X" , FONT_CRLF |
| |
| <code z80> | <code z80> |
| LD HL, cadvidas ; Cadena | ld hl, cadvidas ; Cadena |
| LD IX, vidas ; Variable de argumentos | ld ix, vidas ; Variable de argumentos |
| CALL PrintString_8x8_Format_Args ; Imprimir | call PrintString_8x8_Format_Args ; Imprimir |
| |
| (...) | (...) |
| ;;; comprobamos los tipos y saltamos a sus rutinas de gestion | ;;; comprobamos los tipos y saltamos a sus rutinas de gestion |
| (...) | (...) |
| CP 'z' | cp 'z' |
| JR Z, pstring8v_int8_zeros | jr z, pstring8v_int8_zeros |
| CP 'Z' | cp 'Z' |
| JR Z, pstring8v_int16_zeros | jr z, pstring8v_int16_zeros |
| CP 'j' | cp 'j' |
| JR Z, pstring8v_int8_justify | jr z, pstring8v_int8_justify |
| CP 'J' | cp 'J' |
| JR Z, pstring8v_int16_justify | jr z, pstring8v_int16_justify |
| JP pstring8_novar | jp pstring8_novar |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int8_zeros: | pstring8v_int8_zeros: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_8 | call Int2String_8 |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 ; No llamamos a Remove_Leading_Zeros | call PrintString_8x8 ; No llamamos a Remove_Leading_Zeros |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int16_zeros: | pstring8v_int16_zeros: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| LD H, (IX+0) | ld h, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_16 | call Int2String_16 |
| LD HL, conv2string | ld hl, conv2string |
| CALL PrintString_8x8 ; No llamamos a Remove_Leading_Zeros | call PrintString_8x8 ; No llamamos a Remove_Leading_Zeros |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int8_justify: | pstring8v_int8_justify: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_8 | call Int2String_8 |
| LD HL, conv2string ; Llamamos a funcion Justify | ld hl, conv2string ; Llamamos a funcion Justify |
| CALL INC_HL_Justify_Leading_Zeros | call INC_HL_Justify_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| ;---------------------------------------------------------- | ;---------------------------------------------------------- |
| pstring8v_int16_justify: | pstring8v_int16_justify: |
| PUSH HL | push hl |
| LD L, (IX+0) | ld l, (ix+0) |
| INC IX | inc ix |
| LD H, (IX+0) | ld h, (ix+0) |
| INC IX | inc ix |
| CALL Int2String_16 | call Int2String_16 |
| LD HL, conv2string ; Llamamos a funcion Justify | ld hl, conv2string ; Llamamos a funcion Justify |
| CALL INC_HL_Justify_Leading_Zeros | call INC_HL_Justify_Leading_Zeros |
| CALL PrintString_8x8 | call PrintString_8x8 |
| POP HL | pop hl |
| JP pstring8v_loop ; Volvemos al bucle principal | jp pstring8v_loop ; Volvemos al bucle principal |
| |
| (...) | (...) |
| En el artículo dedicado al teclado estudiamos rutinas de lectura del mismo que nos proporcionaban scancodes de las teclas pulsadas. También vimos rutinas de obtención del código ASCII correspondiente a un scancode dado. | En el artículo dedicado al teclado estudiamos rutinas de lectura del mismo que nos proporcionaban scancodes de las teclas pulsadas. También vimos rutinas de obtención del código ASCII correspondiente a un scancode dado. |
| |
| En este caso vamos a utilizar para nuestro ejemplo la rutina de la ROM ''KEY_SCAN'', la cual permite detectar el uso de CAPS SHIFT y DELETE (CAPS SHIFT + '0') y que distingue por tanto entre mayúsculas y minúsculas. ''KEY_SCAN'' está ubicada en la dirección de memoria $028E de la ROM. | En este caso vamos a utilizar para nuestro ejemplo la rutina de la ROM ''KEY_SCAN'', la cual permite detectar el uso de CAPS SHIFT y DELETE (CAPS SHIFT + '0') y que distingue por tanto entre mayúsculas y minúsculas. ''KEY_SCAN'' está ubicada en la dirección de memoria $028e de la ROM. |
| |
| Al realizar un CALL a ''KEY_SCAN'' se produce una lectura de todas las filas del teclado seguida de una decodificación del resultado de la lectura. La rutina de la ROM coloca entonces en la variable del sistema ''LAST_K'' (dirección 23560) el código ASCII de la tecla pulsada. ''KEY_SCAN'' también decodifica las teclas extendidas y ''LAST_K'' nos puede servir también para detectar ENTER (código ASCII 13) o DELETE (código ASCII 12). | Al realizar un call a ''KEY_SCAN'' se produce una lectura de todas las filas del teclado seguida de una decodificación del resultado de la lectura. La rutina de la ROM coloca entonces en la variable del sistema ''LAST_K'' (dirección 23560) el código ASCII de la tecla pulsada. ''KEY_SCAN'' también decodifica las teclas extendidas y ''LAST_K'' nos puede servir también para detectar ENTER (código ASCII 13) o DELETE (código ASCII 12). |
| |
| El desarrollo de la rutina será el siguiente: | El desarrollo de la rutina será el siguiente: |
| <code z80> | <code z80> |
| LAST_K EQU 23560 | LAST_K EQU 23560 |
| KEY_SCAN EQU $028E | KEY_SCAN EQU $028e |
| |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| InputString_8x8: | InputString_8x8: |
| |
| PUSH HL ; Guardamos el puntero a la cadena | push hl ; Guardamos el puntero a la cadena |
| PUSH DE | push de |
| PUSH BC ; Modificados por KEY_SCAN | push bc ; Modificados por KEY_SCAN |
| |
| LD (inputs_counter), A ; Contador de caracteres a usar | ld (inputs_counter), a ; Contador de caracteres a usar |
| LD (inputs_limit), A ; Guardamos la longitud maxima | ld (inputs_limit), a ; Guardamos la longitud maxima |
| |
| inputs_start: | inputs_start: |
| LD A, '_' ; Imprimir nuevo cursor | ld a, '_' ; Imprimir nuevo cursor |
| CALL Font_SafePrintChar_8x8 | call Font_SafePrintChar_8x8 |
| |
| XOR A | xor a |
| LD (LAST_K), A ; Limpiar ultima tecla pulsada | ld (LAST_K), a ; Limpiar ultima tecla pulsada |
| |
| inputs_loop: | inputs_loop: |
| PUSH HL ; KEY_SCAN modifica HL -> preservar | push hl ; KEY_SCAN modifica HL -> preservar |
| CALL KEY_SCAN ; Escanear el teclado | call KEY_SCAN ; Escanear el teclado |
| POP HL | pop hl |
| LD A, (LAST_K) ; Obtener el valor decodificado | ld a, (LAST_K) ; Obtener el valor decodificado |
| |
| CP 13 | cp 13 |
| JR Z, inputs_end ; Es enter? -> fin de rutina | jr z, inputs_end ; Es enter? -> fin de rutina |
| |
| CP 12 | cp 12 |
| JR Z, inputs_delete ; Es DELETE? -> borrar caracter | jr z, inputs_delete ; Es DELETE? -> borrar caracter |
| |
| CP 32 | cp 32 |
| JR C, inputs_loop ; Es < 32? -> repetir bucle escaneo | jr c, inputs_loop ; Es < 32? -> repetir bucle escaneo |
| |
| ;;; Si estamos aqui, ASCII >= 32 -> Es caracter valido -> Guardiar | ;;; Si estamos aqui, ASCII >= 32 -> Es caracter valido -> Guardiar |
| EX AF, AF' ; Nos guardamos el valor ASCII en A' | ex af, af' ; Nos guardamos el valor ASCII en A' |
| |
| ;;; Comprobacion de longitud maxima de cadena | ;;; Comprobacion de longitud maxima de cadena |
| LD A, (inputs_counter) ; A = caracteres disponibles | ld a, (inputs_counter) ; A = caracteres disponibles |
| OR A ; Comprobar si es 0 | or a ; Comprobar si es 0 |
| JR Z, inputs_loop ; Si es cero, no insertar caracter | jr z, inputs_loop ; Si es cero, no insertar caracter |
| DEC A | dec a |
| LD (inputs_counter), A ; Decrementar espacio disponible | ld (inputs_counter), a ; Decrementar espacio disponible |
| |
| EX AF, AF' ; Recuperamos ASCII de A' | ex af, af' ; Recuperamos ASCII de A' |
| LD (HL), A ; Guardamos el caracter leido | ld (hl), a ; Guardamos el caracter leido |
| INC HL ; Avanzamos al siguiente caracter e imprimir | inc hl ; Avanzamos al siguiente caracter e imprimir |
| CALL Font_SafePrintChar_8x8 | call Font_SafePrintChar_8x8 |
| CALL Font_Inc_X | call Font_Inc_X |
| JR inputs_start ; Repetir continuamente hasta ENTER | jr inputs_start ; Repetir continuamente hasta ENTER |
| |
| ;;; Codigo a ejecutar cuando se pulsa enter | ;;; Codigo a ejecutar cuando se pulsa enter |
| inputs_end: ; ENTER pulsado -> Fin de la rutina | inputs_end: ; ENTER pulsado -> Fin de la rutina |
| |
| LD A, ' ' ; Borramos de la pantalla el cursor | ld a, ' ' ; Borramos de la pantalla el cursor |
| CALL Font_SafePrintChar_8x8 | call Font_SafePrintChar_8x8 |
| XOR A | xor a |
| LD (HL), A ; Almacenamos un FIN DE CADENA en HL | ld (hl), a ; Almacenamos un FIN DE CADENA en HL |
| POP BC | pop bc |
| POP DE ; Recuperamos valores de registros | pop de ; Recuperamos valores de registros |
| POP HL ; Recuperamos el inicio de la cadena | pop hl ; Recuperamos el inicio de la cadena |
| RET | ret |
| |
| ;;; Codigo a ejecutar cuando se pulsa DELETE | ;;; Codigo a ejecutar cuando se pulsa DELETE |
| inputs_delete: ; DELETE pulsado -> Borrar caracter | inputs_delete: ; DELETE pulsado -> Borrar caracter |
| LD A, (inputs_limit) | ld a, (inputs_limit) |
| LD B, A | ld b, a |
| LD , (inputs_counter) | LD , (inputs_counter) |
| CP B ; Si char_disponibles-limite == 0 ... | cp b ; Si char_disponibles-limite == 0 ... |
| JR Z, inputs_loop ; ... no podemos borrar (inicio de cadena) | jr z, inputs_loop ; ... no podemos borrar (inicio de cadena) |
| |
| INC A ; Si no, si que podemos borrar: | inc a ; Si no, si que podemos borrar: |
| LD (inputs_counter), A ; incrementar espacio disponible | ld (inputs_counter), a ; incrementar espacio disponible |
| |
| DEC HL ; Decrementar puntero en la cadena | dec hl ; Decrementar puntero en la cadena |
| LD A, ' ' ; Borrar cursor y caracter anterior | ld a, ' ' ; Borrar cursor y caracter anterior |
| CALL Font_SafePrintChar_8x8 | call Font_SafePrintChar_8x8 |
| CALL Font_Dec_X | call Font_Dec_X |
| JR inputs_start ; Bucle principal | jr inputs_start ; Bucle principal |
| |
| inputs_counter DB 0 | inputs_counter DB 0 |
| ;------------------------------------------------------------- | ;------------------------------------------------------------- |
| Font_SafePrintChar_8x8 | Font_SafePrintChar_8x8 |
| PUSH BC | push bc |
| PUSH DE | push de |
| PUSH HL ; Preservar registros | push hl ; Preservar registros |
| CALL PrintChar_8x8 ; Imprimir caracter | call PrintChar_8x8 ; Imprimir caracter |
| POP HL ; Recuperar registros | pop hl ; Recuperar registros |
| POP DE | pop de |
| POP BC | pop bc |
| RET | ret |
| </code> | </code> |
| |
| ORG 35000 | ORG 35000 |
| |
| LD HL, $3D00-256 | ld hl, $3d00-256 |
| CALL Font_Set_Charset | call Font_Set_Charset |
| |
| ;;; Imprimir cadena "Introduce un texto:" | ;;; Imprimir cadena "Introduce un texto:" |
| LD HL, cadena1 | ld hl, cadena1 |
| LD B, 4 | ld b, 4 |
| LD C, 0 | ld c, 0 |
| CALL Font_Set_XY | call Font_Set_XY |
| CALL PrintString_8x8_Format | call PrintString_8x8_Format |
| |
| ;;; Obtener el input del usuario | ;;; Obtener el input del usuario |
| LD HL, input1 | ld hl, input1 |
| LD A, 20 | ld a, 20 |
| CALL InputString_8x8 | call InputString_8x8 |
| |
| ;;; Imprimir "Tu cadena es:" + la cadena resultante | ;;; Imprimir "Tu cadena es:" + la cadena resultante |
| LD HL, cadena2 | ld hl, cadena2 |
| CALL PrintString_8x8_Format | call PrintString_8x8_Format |
| |
| LD HL, input1 | ld hl, input1 |
| CALL PrintString_8x8_Format | call PrintString_8x8_Format |
| |
| RET | ret |
| |
| cadena1 DB "Introduce un texto:", FONT_CRLF, FONT_CRLF | cadena1 DB "Introduce un texto:", FONT_CRLF, FONT_CRLF |
| DB $00,$75,$25,$25,$25,$25,$22,$00,$00,$55,$55,$55,$55,$27,$25,$00 | DB $00,$75,$25,$25,$25,$25,$22,$00,$00,$55,$55,$55,$55,$27,$25,$00 |
| DB $00,$55,$55,$25,$22,$52,$52,$00,$00,$73,$12,$22,$22,$42,$72,$03 | DB $00,$55,$55,$25,$22,$52,$52,$00,$00,$73,$12,$22,$22,$42,$72,$03 |
| DB $00,$46,$42,$22,$22,$12,$12,$06,$00,$20,$50,$00,$00,$00,$00,$0F | DB $00,$46,$42,$22,$22,$12,$12,$06,$00,$20,$50,$00,$00,$00,$00,$0f |
| DB $00,$20,$10,$03,$05,$05,$03,$00,$00,$40,$40,$63,$54,$54,$63,$00 | DB $00,$20,$10,$03,$05,$05,$03,$00,$00,$40,$40,$63,$54,$54,$63,$00 |
| DB $00,$10,$10,$32,$55,$56,$33,$00,$00,$10,$20,$73,$25,$25,$43,$06 | DB $00,$10,$10,$32,$55,$56,$33,$00,$00,$10,$20,$73,$25,$25,$43,$06 |
| DB $00,$00,$20,$75,$25,$25,$12,$00,$00,$00,$00,$55,$55,$27,$25,$00 | DB $00,$00,$20,$75,$25,$25,$12,$00,$00,$00,$00,$55,$55,$27,$25,$00 |
| DB $00,$00,$00,$55,$25,$25,$53,$06,$00,$01,$02,$72,$34,$62,$72,$01 | DB $00,$00,$00,$55,$25,$25,$53,$06,$00,$01,$02,$72,$34,$62,$72,$01 |
| DB $00,$24,$22,$22,$21,$22,$22,$04,$00,$56,$A9,$06,$04,$06,$09,$06 | DB $00,$24,$22,$22,$21,$22,$22,$04,$00,$56,$a9,$06,$04,$06,$09,$06 |
| </code> | </code> |
| |
| PrintChar_4x8: | PrintChar_4x8: |
| |
| RRA ; Dividimos A por 2 (resto en CF) | rra ; Dividimos A por 2 (resto en CF) |
| PUSH AF ; Guardamos caracter y CF en A' | push af ; Guardamos caracter y CF en A' |
| |
| ;;; Calcular posicion origen (array fuente) en HL como: | ;;; Calcular posicion origen (array fuente) en HL como: |
| ;;; direccion = base_charset + ((CARACTER/2)*8) | ;;; direccion = base_charset + ((CARACTER/2)*8) |
| LD BC, (FONT_CHARSET) | ld bc, (FONT_CHARSET) |
| LD H, 0 | ld h, 0 |
| LD L, A | ld l, a |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, HL | add hl, hl |
| ADD HL, BC ; HL = Direccion origen de A en fuente | add hl, bc ; HL = Direccion origen de A en fuente |
| |
| ;;; Calculamos las coordenadas destino de pantalla en DE: | ;;; Calculamos las coordenadas destino de pantalla en DE: |
| LD BC, (FONT_X) ; B = Y, C = X | ld bc, (FONT_X) ; B = Y, C = X |
| RR C | rr c |
| LD A, B | ld a, b |
| AND $18 | and $18 |
| ADD A, $40 | add a, $40 |
| LD D, A | ld d, a |
| LD A, B | ld a, b |
| AND 7 | and 7 |
| RRCA | rrca |
| RRCA | rrca |
| RRCA | rrca |
| ADD A, C | add a, c |
| LD E, A ; DE contiene ahora la direccion destino. | ld e, a ; DE contiene ahora la direccion destino. |
| |
| ;;; Calculamos posición en pantalla. Tenemos que dividirla por 2 porque | ;;; Calculamos posición en pantalla. Tenemos que dividirla por 2 porque |
| ;;; en cada columna de pantalla caben 2 caracteres. Usaremos el resto | ;;; en cada columna de pantalla caben 2 caracteres. Usaremos el resto |
| ;;; (Carry) para saber si va en la izq (CF=0) o der (CF=1) del caracter. | ;;; (Carry) para saber si va en la izq (CF=0) o der (CF=1) del caracter. |
| LD A, (FONT_X) ; Volvemos a leer coordenada X | ld a, (FONT_X) ; Volvemos a leer coordenada X |
| RRA ; Dividimos por 2 (posicion X en pantalla) | rra ; Dividimos por 2 (posicion X en pantalla) |
| ; Ademas el carry tiene el resto (par/impar) | ; Ademas el carry tiene el resto (par/impar) |
| JR NC, pchar4_x_odd ; Saltar si es columna impar (por el CF) | jr nc, pchar4_x_odd ; Saltar si es columna impar (por el CF) |
| |
| ;;; Ahora tenemos que imprimir el caracter en pantalla. Hemos saltado | ;;; Ahora tenemos que imprimir el caracter en pantalla. Hemos saltado |
| ;;; Posicion de columna en pantalla par: | ;;; Posicion de columna en pantalla par: |
| pchar4_x_even : | pchar4_x_even : |
| POP AF ; Restaura A=char y CF=si es char par/impar | pop af ; Restaura A=char y CF=si es char par/impar |
| JR C, pchar4_l_on_l | jr c, pchar4_l_on_l |
| JR pchar4_r_on_l | jr pchar4_r_on_l |
| |
| pchar4_x_odd: | pchar4_x_odd: |
| POP AF ; Restaura A=char y CF=si es char par/impar | pop af ; Restaura A=char y CF=si es char par/impar |
| JR NC, pchar4_r_on_r | jr nc, pchar4_r_on_r |
| JR pchar4_l_on_r | jr pchar4_l_on_r |
| |
| pchar4_continue: | pchar4_continue: |
| pchar4_printattr: | pchar4_printattr: |
| |
| LD A, D ; Recuperamos el valor inicial de DE | ld a, d ; Recuperamos el valor inicial de DE |
| SUB 8 ; Restando los 8 scanlines avanzados | sub 8 ; Restando los 8 scanlines avanzados |
| |
| ;;; Calcular posicion destino en area de atributos en HL. | ;;; Calcular posicion destino en area de atributos en HL. |
| RRCA ; A ya es = D, listo para rotar | rrca ; A ya es = D, listo para rotar |
| RRCA ; Codigo de Get_Attr_Offset_From_Image | rrca ; Codigo de Get_Attr_Offset_From_Image |
| RRCA | rrca |
| AND 3 | and 3 |
| OR $58 | or $58 |
| LD H, A | ld h, a |
| LD L, E | ld l, e |
| |
| ;;; Escribir el atributo en memoria | ;;; Escribir el atributo en memoria |
| LD A, (FONT_ATTRIB) | ld a, (FONT_ATTRIB) |
| LD (HL), A ; Escribimos el atributo en memoria | ld (hl), a ; Escribimos el atributo en memoria |
| RET | ret |
| |
| ;;;------------------------------------------------------------------ | ;;;------------------------------------------------------------------ |
| ;;;---------------------------------------------------- | ;;;---------------------------------------------------- |
| pchar4_l_on_l: | pchar4_l_on_l: |
| LD B, 8 ; 8 scanlines / iteraciones | ld b, 8 ; 8 scanlines / iteraciones |
| pchar4_ll_lp: | pchar4_ll_lp: |
| LD A, (DE) ; Leer byte de la pantalla | ld a, (de) ; Leer byte de la pantalla |
| AND %11110000 | and %11110000 |
| LD C, A ; Nos lo guardamos en C | ld c, a ; Nos lo guardamos en C |
| LD A, (HL) ; Cogemos el byte de la fuente | ld a, (hl) ; Cogemos el byte de la fuente |
| AND %00001111 | and %00001111 |
| OR C ; Lo combinamos con el fondo | or c ; Lo combinamos con el fondo |
| LD (DE), A ; Y lo escribimos en pantalla | ld (de), a ; Y lo escribimos en pantalla |
| INC D ; Siguiente scanline | inc d ; Siguiente scanline |
| INC HL ; Siguiente dato del "sprite" | inc hl ; Siguiente dato del "sprite" |
| DJNZ pchar4_ll_lp | djnz pchar4_ll_lp |
| JR pchar4_continue ; Volver tras impresion | jr pchar4_continue ; Volver tras impresion |
| |
| ;;;---------------------------------------------------- | ;;;---------------------------------------------------- |
| pchar4_r_on_r: | pchar4_r_on_r: |
| LD B, 8 ; 8 scanlines / iteraciones | ld b, 8 ; 8 scanlines / iteraciones |
| pchar4_rr_lp: | pchar4_rr_lp: |
| LD A, (DE) ; Leer byte de la pantalla | ld a, (de) ; Leer byte de la pantalla |
| AND %00001111 | and %00001111 |
| LD C, A ; Nos lo guardamos en C | ld c, a ; Nos lo guardamos en C |
| LD A, (HL) ; Cogemos el byte de la fuente | ld a, (hl) ; Cogemos el byte de la fuente |
| AND %11110000 | and %11110000 |
| OR C ; Lo combinamos con el fondo | or c ; Lo combinamos con el fondo |
| LD (DE), A ; Y lo escribimos en pantalla | ld (de), a ; Y lo escribimos en pantalla |
| INC D ; Siguiente scanline | inc d ; Siguiente scanline |
| INC HL ; Siguiente dato del "sprite" | inc hl ; Siguiente dato del "sprite" |
| DJNZ pchar4_rr_lp | djnz pchar4_rr_lp |
| JR pchar4_continue ; Volver tras impresion | jr pchar4_continue ; Volver tras impresion |
| |
| ;;;---------------------------------------------------- | ;;;---------------------------------------------------- |
| pchar4_l_on_r: | pchar4_l_on_r: |
| LD B, 8 ; 8 scanlines / iteraciones | ld b, 8 ; 8 scanlines / iteraciones |
| pchar4_lr_lp: | pchar4_lr_lp: |
| LD A, (DE) ; Leer byte de la pantalla | ld a, (de) ; Leer byte de la pantalla |
| AND %00001111 | and %00001111 |
| LD C, A ; Nos lo guardamos en C | ld c, a ; Nos lo guardamos en C |
| LD A, (HL) ; Cogemos el byte de la fuente | ld a, (hl) ; Cogemos el byte de la fuente |
| RRCA ; Lo desplazamos 4 veces >> dejando | rrca ; Lo desplazamos 4 veces >> dejando |
| RRCA ; lo bits 4 al 7 vacios | rrca ; lo bits 4 al 7 vacios |
| RRCA | rrca |
| RRCA | rrca |
| AND %11110000 | and %11110000 |
| OR C ; Lo combinamos con el fondo | or c ; Lo combinamos con el fondo |
| LD (DE), A ; Y lo escribimos en pantalla | ld (de), a ; Y lo escribimos en pantalla |
| INC D ; Siguiente scanline | inc d ; Siguiente scanline |
| INC HL ; Siguiente dato del "sprite" | inc hl ; Siguiente dato del "sprite" |
| DJNZ pchar4_lr_lp | djnz pchar4_lr_lp |
| JR pchar4_continue ; Volver tras impresion | jr pchar4_continue ; Volver tras impresion |
| |
| ;;;---------------------------------------------------- | ;;;---------------------------------------------------- |
| pchar4_r_on_l: | pchar4_r_on_l: |
| LD B, 8 ; 8 scanlines / iteraciones | ld b, 8 ; 8 scanlines / iteraciones |
| pchar4_rl_lp: | pchar4_rl_lp: |
| LD A, (DE) ; Leer byte de la pantalla | ld a, (de) ; Leer byte de la pantalla |
| AND %11110000 | and %11110000 |
| LD C, A ; Nos lo guardamos en C | ld c, a ; Nos lo guardamos en C |
| LD A, (HL) ; Cogemos el byte de la fuente | ld a, (hl) ; Cogemos el byte de la fuente |
| RLCA ; Lo desplazamos 4 veces << dejando | rlca ; Lo desplazamos 4 veces << dejando |
| RLCA ; los bits 0 al 3 vacios | rlca ; los bits 0 al 3 vacios |
| RLCA | rlca |
| RLCA | rlca |
| AND %00001111 | and %00001111 |
| OR C ; Lo combinamos con el fondo | or c ; Lo combinamos con el fondo |
| LD (DE), A ; Y lo escribimos en pantalla | ld (de), a ; Y lo escribimos en pantalla |
| INC D ; Siguiente scanline | inc d ; Siguiente scanline |
| INC HL ; Siguiente dato del "sprite" | inc hl ; Siguiente dato del "sprite" |
| DJNZ pchar4_rl_lp | djnz pchar4_rl_lp |
| JR pchar4_continue ; Volver tras impresion | jr pchar4_continue ; Volver tras impresion |
| </code> | </code> |
| |
| <code z80> | <code z80> |
| Font_Backspace: | Font_Backspace: |
| CALL Font_Dec_X | call Font_Dec_X |
| LD A, ' ' ; Imprimir caracter espacio | ld a, ' ' ; Imprimir caracter espacio |
| PUSH BC | push bc |
| PUSH DE | push de |
| PUSH HL | push hl |
| CALL PrintChar_4x8 ; Sobreescribir caracter | call PrintChar_4x8 ; Sobreescribir caracter |
| POP HL | pop hl |
| POP DE | pop de |
| POP BC | pop bc |
| RET ; Salir | ret ; Salir |
| </code> | </code> |
| |
| ORG 35000 | ORG 35000 |
| |
| LD HL, charset_4x8-128 ; Inicio charset - (256/2) | ld hl, charset_4x8-128 ; Inicio charset - (256/2) |
| CALL Font_Set_Charset | call Font_Set_Charset |
| |
| LD HL, cadena1 | ld hl, cadena1 |
| LD BC, $0400 ; X=00, Y=04 | ld bc, $0400 ; X=00, Y=04 |
| CALL Font_Set_XY | call Font_Set_XY |
| CALL PrintString_4x8_Format | call PrintString_4x8_Format |
| |
| loop: | loop: |
| JR loop | jr loop |
| RET | ret |
| |
| cadena1 DB "Fuente de 4x8", FONT_CRLF, FONT_CRLF | cadena1 DB "Fuente de 4x8", FONT_CRLF, FONT_CRLF |