¡Esta es una revisión vieja del documento!
Gráficos (y IV): Fuentes de texto
En prácticamente cualquier programa o juego nos encontraremos con la necesidad de imprimir en pantalla texto y datos numéricos en diferentes posiciones de pantalla: los menúes, los nombres de los niveles, los marcadores y puntuaciones, etc.
La impresión de fuentes de texto es una aplicación directa de las rutinas de impresión de sprites en baja resolución que creamos en el capítulo anterior. Cada carácter es un sprite de 8×8 píxeles a dibujar en coordenadas (c,f) de baja resolución.
Crearemos una rutina de impresión de caracteres y, basada en esta, una rutina de impresión de cadenas, con la posibilidad de añadir códigos de control y de formato, e impresión de datos numéricos o variables decimales, hexadecimales, binarias y de cadena.
Aprovechando la rutina de escaneo de teclado de la ROM, analizaremos también una rutina de INPUT de datos para nuestros programas en ensamblador basados en texto (aventuras, juegos de gestión, etc).
Finalmente, examinaremos una fuente de texto de 4×8 píxeles que nos permitirá una resolución en pantalla de 64 columnas de caracteres en pantalla.
Fuentes de texto 8x8
Si creamos un juego gráfico de caracteres como un tileset de sprites de 8×8 píxeles cada uno conteniendo una letra del alfabeto, podemos utilizar las rutinas de impresión de sprites de 8×8 para trazar en pantalla cualquier carácter (visto como un sprite de 1×1 bloques).
Parte de un tileset de caracteres en SevenuP
Ubicando las letras en el spriteset con el mismo orden que el código ASCII (empezando por el espacio, código 32, como sprite cero), podemos utilizar el código ASCII de la letra a imprimir como número de sprite dentro del tileset.
Los 95 caracteres imprimibles (96 en el Spectrum) del código ASCII.
Fuente: Wikipedia
Podríamos diseñar una fuente de 256 caracteres en el editor de Sprites, pero se requerirían 256*8 = 4096 bytes (4KB!) para almacenar los datos en memoria. En realidad, no es necesario crear 256 caracteres en el editor, puesto que en el Spectrum:
- Los primeros 31 códigos ASCII son códigos de control.
- Los códigos ASCII del 128 al 143 son los UDGs predefinidos e imprimibles.
- Los códigos ASCII del 144 al 164 son los UDGs programables en modo 48K (del 144 al 162 en modo 128K)
- Los códigos ASCII del 165 al 255 son los códigos de control (tokens) de las instrucciones de BASIC en modo 48K (del 163 al 255 en modo 128K).
Códigos ASCII en el Spectrum desde el 32 al 164
Fuente: Wikipedia
Como hay un total de 96 caracteres de texto imprimibles (desde el 32 al 127), para disponer de un juego de caracteres suficiente con minúsculas, mayúsculas, signos de puntuación y dígitos nos bastaría con una fuente de 96 sprites de 8 bytes cada uno, es decir, un total de 768 bytes.
Podemos agregar “caracteres” adicionales para disponer de códigos de control que nos permitan imprimir vocales con acentos, eñes, cedilla (ç), etc. Al definir los textos de nuestro programa habría que utilizar estos códigos de control en formato numérico (DB) intercalados con el texto ASCII (“España” = DB “Espa”, codigo_enye, “a”).
Si tenemos problemas de espacio en nuestro programa también podemos utilizar un set de caracteres más reducido que acaben en el ASCII 'Z' (ASCII 90), lo que nos dejaría un charset con números, signos de puntuación y letras mayúsculas (sin minúsculas). El espacio ocupado por este spriteset sería de 90-32=58 caracteres, es decir, 464 bytes.
Por otra parte, no es necesario exportar los atributos de la fuente ya que lo normal es utilizar un atributo determinado para todos los caracteres de la misma, aunque nada nos impide dotar de diferente color a cada letra si así lo deseamos y exportar también los datos de atributo. En este capítulo sólo exportaremos los gráficos puesto que utilizaremos un atributo común para todos los elementos de la fuente, o cambios de formato (tinta y papel) manuales allá donde sea necesario.
Sea cual sea el tamaño de nuestro SpriteSet (desde el juego reducido de 58 caracteres hasta el set completo de 256, pasando por el estándar de 96), podemos imprimir caracteres de dicha fuente con las rutinas de impresión de 8×8 del capítulo anterior.
Para los ejemplos de este capítulo utilizaremos una fuente personalizada de texto de 64 caracteres (signos de puntuación, dígitos numéricos y letras mayúsculas, incluídas 5 vocales con acentos) dibujada por Javier Vispe y convertida a código con SevenuP:
Exportando los datos en SevenuP en formato X Char, Char Line, Y Char como Gfx only, obtenemos el siguiente fichero .asm:
; ASM source file created by SevenuP v1.20 ; SevenuP (C) Copyright 2002-2006 by Jaime Tejedor Gomez, aka Metalbrain ;GRAPHIC DATA: ;Pixel Size: ( 8, 512) ;Char Size: ( 1, 64) ;Sort Priorities: Char X, Char line, Y char ;Data Outputted: Gfx ;Interleave: Sprite charset1: DEFB 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 0, 24, 0 DEFB 0,108,108, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 DEFB 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 DEFB 56, 0, 76, 56,110,196,122, 0, 0, 12, 12, 8, 0, 0, 0, 0 DEFB 0, 24, 0, 48, 48, 48, 24, 0, 0, 24, 0, 12, 12, 12, 24, 0 DEFB 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0,126,126, 24, 24, 0 DEFB 0, 0, 0, 0, 0, 12, 12, 8, 0, 0, 0,126,126, 0, 0, 0 DEFB 0, 0, 0, 0, 0, 56, 56, 0, 0, 0, 6, 12, 24, 48, 96, 0 DEFB 124, 0,206,214,230,254,124, 0, 28, 0,124, 28, 28, 28, 28, 0 DEFB 124, 0,198, 28,112,254,254, 0, 124, 0,198, 12,198,254,124, 0 DEFB 12, 0, 60,108,254,254, 12, 0, 254, 0,192,252, 14,254,252, 0 DEFB 60, 0,224,252,198,254,124, 0, 254, 0, 14, 28, 28, 56, 56, 0 DEFB 124, 0,198,124,198,254,124, 0, 124, 0,198,126, 6,126,124, 0 DEFB 0, 0, 24, 24, 0, 24, 24, 0, 118, 6,192,254,254,198,198, 0 DEFB 246, 6,192,252,192,254,254, 0, 12, 12, 48, 56, 56, 56, 56, 0 DEFB 118, 6,192,198,198,254,124, 0, 198, 6,192,198,198,254,124, 0 DEFB 0, 24, 0, 24, 24, 24, 24, 0, 124, 0,198,254,254,198,198, 0 DEFB 252, 0,198,252,198,254,252, 0, 124, 0,198,192,198,254,124, 0 DEFB 252, 0,198,198,198,254,252, 0, 254, 0,192,252,192,254,254, 0 DEFB 254, 0,224,252,224,224,224, 0, 124, 0,192,206,198,254,124, 0 DEFB 198, 0,198,254,254,198,198, 0, 56, 0, 56, 56, 56, 56, 56, 0 DEFB 6, 0, 6, 6,198,254,124, 0, 198, 0,220,248,252,206,198, 0 DEFB 224, 0,224,224,224,254,254, 0, 198, 0,254,254,214,198,198, 0 DEFB 198, 0,246,254,222,206,198, 0, 124, 0,198,198,198,254,124, 0 DEFB 252, 0,198,254,252,192,192, 0, 124, 0,198,198,198,252,122, 0 DEFB 252, 0,198,254,252,206,198, 0, 126, 0,224,124, 6,254,252, 0 DEFB 254, 0, 56, 56, 56, 56, 56, 0, 198, 0,198,198,198,254,124, 0 DEFB 198, 0,198,198,238,124, 56, 0, 198, 0,198,198,214,254,108, 0 DEFB 198, 0,124, 56,124,238,198, 0, 198, 0,238,124, 56, 56, 56, 0 DEFB 254, 0, 28, 56,112,254,254, 0, 60,102,219,133,133,219,102, 60 DEFB 0, 0, 96, 48, 24, 12, 6, 0, 24, 0, 24, 48, 96,102, 60, 0 DEFB 60, 0, 70, 12, 24, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0,126
PrintChar_8x8
La rutina de impresión de caracteres debe de recoger el código ASCII a dibujar y realizar el cálculo para posicionar un puntero “origen” dentro del tileset contra el ASCII correspondiente. También debe calcular la dirección destino en la pantalla en base a las coordenadas en baja resolución. Una vez trazado el carácter, establecerá el atributo del mismo con el valor contenido en FONT_ATTRIB.
;------------------------------------------------------------- ; PrintChar_8x8: ; Imprime un caracter de 8x8 pixeles de un charset. ; ; Entrada (paso por parametros en memoria): ; ----------------------------------------------------- ; FONT_CHARSET = Direccion de memoria del charset. ; FONT_X = Coordenada X en baja resolucion (0-31) ; FONT_Y = Coordenada Y en baja resolucion (0-23) ; FONT_ATTRIB = Atributo a utilizar en la impresion. ; Registro A = ASCII del caracter a dibujar. ;------------------------------------------------------------- PrintChar_8x8: LD BC, (FONT_X) ; B = Y, C = X EX AF, AF' ; Nos guardamos el caracter en A' ;;; Calculamos las coordenadas destino de pantalla en DE: LD A, B AND $18 ADD A, $40 LD D, A LD A, B AND 7 RRCA RRCA RRCA ADD A, C LD E, A ; DE contiene ahora la direccion destino. ;;; Calcular posicion origen (array sprites) en HL como: ;;; direccion = base_sprites + (NUM_SPRITE*8) EX AF, AF' ; Recuperamos el caracter a dibujar de A' LD BC, (FONT_CHARSET) LD H, 0 LD L, A ADD HL, HL ADD HL, HL ADD HL, HL ADD HL, BC ; HL = BC + HL = FONT_CHARSET + (A * 8) EX DE, HL ; Intercambiamos DE y HL (DE=origen, HL=destino) ;;; Dibujar 7 scanlines (DE) -> (HL) y bajar scanline (y DE++) LD B, 7 ; 7 scanlines a dibujar drawchar8_loop: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE ; Incrementamos puntero en caracter INC H ; Incrementamos puntero en pantalla (scanline+=1) DJNZ drawchar8_loop ;;; La octava iteracion (8o scanline) aparte, para evitar los INCs LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria LD A, H ; Recuperamos el valor inicial de HL SUB 7 ; Restando los 7 "INC H"'s realizados ;;; Calcular posicion destino en area de atributos en DE. ; Tenemos A = H RRCA ; Codigo de Get_Attr_Offset_From_Image RRCA RRCA AND 3 OR $58 LD D, A LD E, L ;;; Escribir el atributo en memoria LD A, (FONT_ATTRIB) LD (DE), A ; Escribimos el atributo en memoria RET
La rutina es muy parecida a las que ya vimos en el capítulo anterior para impresión de sprites 8×8, 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”.
La impresión se realiza por transferencia, pero podemos convertirla en impresión por operación lógica cambiando los:
LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria
Por:
LD A, (DE) ; Tomamos el dato del caracter OR (HL) ; Hacemos OR entre dato y pantalla LD (HL), A ; Establecemos el valor en videomemoria
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 crear un sistema de coordenadas de texto X, Y y de atributos que nos permita, como veremos más adelante en el capítulo, gestionar la impresión de texto de una manera más cómoda.
Nótese que nuestro set de caracteres empieza en el ASCII 32 (espacio) el cual se corresponde con el sprite 0 (sprite en blanco). En teoría, la rutina debería restar 32 a cada código ASCII recibido en el registro A para encontrar el identificador de sprite correcto en el tileset.
En lugar de realizar una resta en cada impresión, podemos establecer el valor de FONT_CHARSET a la dirección del array menos 256 (32*8), con lo que cuando se calcule la dirección origen usando el ASCII real estaremos accediendo al sprite correcto.
Así, asignando a FONT_CHARSET el valor de “charset1-256”, cuando solicitemos imprimir el ASCII 32, estaremos accediendo realmente a charset1-256+(32*8) = charset1-256+256 = charset1. De esta forma no necesitamos restar 32 a ningun carácter ASCII para que la rutina imprima el carácter correspondiente real a un valor ASCII.
El código de asignación de variables iniciales y llamada a la función sería pues similar al siguiente:
;;; Establecimiento de valores iniciales LD HL, charset1-256 ; Saltamos los 32 caracteres iniciales LD (FONT_CHARSET), HL ; Establecemos el valor del charset LD A, 6 LD (FONT_ATTRIB), A ; Color amarillo sobre negro ;;; Impresion de un caracter "X" en 15,8 LD A, 15 LD (FONT_X), A LD A, 8 LD (FONT_Y), A LD A, 'X' CALL PrintChar_8x8 ; Imprimimos el caracter
Nótese que esta implementación de PrintChar_8x8 modifica registros y no los preserva, por lo que si tenemos que salvaguardar el valor de algún registro, debemos realizar PUSH antes de llamar a la función y POP al volver de ella.
El siguiente ejemplo (donde se ha omitido el código de las funciones ya vistas hasta ahora) muestra el charset 8×8 de 64 caracteres en pantalla, en un bucle de 4 líneas de 16 caracteres cada una:
; Visualizacion del charset de ejemplo ORG 35000 LD H, 0 LD L, A CALL ClearScreenAttrib ; Borramos la pantalla LD HL, charset1-256 ; Saltamos los 32 caracteres iniciales LD (FONT_CHARSET), HL XOR A LD (FONT_X), A INC A LD (FONT_Y), A ; Empezamos en (0,1) LD A, 6 LD (FONT_ATTRIB), A ; Color amarillo sobre negro LD C, 32 ; Empezamos en caracter 32 ;;; Bucle vertical LD E, 4 bucle_y: ;;; Bucle horizontal LD B, 16 ; Imprimimos 16 caracteres horiz bucle_x: LD A, (FONT_X) INC A LD (FONT_X), A ; X = X + 1 LD A, C PUSH BC PUSH DE ; Preservamos registros CALL PrintChar_8x8 ; Imprimimos el caracter "C" POP DE POP BC INC C ; Siguiente caracter DJNZ bucle_x ; Repetir 16 veces LD A, (FONT_Y) ; Siguiente linea: INC A INC A ; Y = Y + 2 LD (FONT_Y), A XOR A LD (FONT_X), A ; X = 0 DEC E JR NZ, bucle_y ; Repetir 4 veces (16*4=64 caracteres) loop: JR loop RET ;------------------------------------------------------------- FONT_CHARSET DW 0 FONT_ATTRIB DB 56 ; Negro sobre gris FONT_X DB 0 FONT_Y DB 0 ;------------------------------------------------------------- END 35000
PrintString_8x8
Nuestro siguiente objetivo es el de poder agrupar diferentes caracteres en una cadena y diseñar una función que permita imprimir toda la cadena mediante llamadas consecutivas a PrintChar_8x8.
Definiremos las cadenas de texto como ristras de códigos ASCII acabadas en un byte 0 (valor 0, no ASCII '0'):
cadena DB "EJEMPLO DE CADENA", 0
El pseudocódigo de la rutina sería el siguiente:
Pseudocódigo de la rutina: ; Recoger parametros ; Repetir: ; Coger caracter actual de la cadena (apuntado por HL). ; Si el caracter es 0, fin de la cadena (salir) ; Incrementar HL para apuntar al siguiente caracter. ; Imprimir el carácter llamando a PrintChar_8x8 ; Ajustar coordenada X en FONT_X ; Ajustar coordenada Y en FONT_Y
Es extremadamente importante acabar la cadena con un cero para que la rutina pueda ejecutar su condición de salida. Si no se define la cadena correctamente, se continuará imprimiendo todo aquello apuntado por HL hasta encontrar un valor cero en memoria.
Veamos el código de la rutina:
;------------------------------------------------------------- ; PrintString_8x8: ; Imprime una cadena de texto de un charset de fuente 8x8. ; ; Entrada (paso por parametros en memoria): ; ----------------------------------------------------- ; FONT_CHARSET = Direccion de memoria del charset. ; FONT_X = Coordenada X en baja resolucion (0-31) ; FONT_Y = Coordenada Y en baja resolucion (0-23) ; FONT_ATTRIB = Atributo a utilizar en la impresion. ; Registro HL = Puntero a la cadena de texto a imprimir. ; Debe acabar en ;------------------------------------------------------------- PrintString_8x8: ;;; Bucle de impresion de caracter pstring8_loop: LD A, (HL) ; Leemos un caracter de la cadena OR A RET Z ; Si es 0 (fin de cadena) volver INC HL ; Siguiente caracter en la cadena PUSH HL ; Salvaguardamos HL CALL PrintChar_8x8 ; Imprimimos el caracter POP HL ; Recuperamos HL ;;; Ajustamos coordenadas X e Y LD A, (FONT_X) ; Incrementamos la X INC A ; pero comprobamos si borde derecho CP 31 ; X > 31? JR C, pstring8_noedgex ; No, se puede guardar el valor LD A, (FONT_Y) ; Cogemos coordenada Y CP 23 ; Si ya es 23, no incrementar JR NC, pstring8_noedgey ; Si es 23, saltar INC A ; No es 23, cambiar Y LD (FONT_Y), A pstring8_noedgey: LD (FONT_Y), A ; Guardamos la coordenada Y XOR A ; Y ademas hacemos A = X = 0 pstring8_noedgex LD (FONT_X), A ; Almacenamos el valor de X JR pstring8_loop
La anterior rutina sería llamada como en el siguiente ejemplo:
;;; Prueba de impresion de cadenas: LD HL, charset1-256 ; Saltamos los 32 caracteres iniciales LD (FONT_CHARSET), HL LD A, 64+3 LD (FONT_ATTRIB), A LD HL, cadena LD A, 0 LD (FONT_X), A LD A, 15 LD (FONT_Y), A CALL PrintString_8x8 RET cadena DB "PRUEBA DE IMPRESION DE TEXTO DE UNA CADENA LARGA.", 0
Y el resultado en pantalla es:
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.
Si vamos a utilizar la impresión de cadenas en la introducción del juego o programa, los menúes, la descripción de las fases, los créditos, la pausa o los mensajes entre nivel y nivel o el final del juego, probablemente será suficiente con la rutina que acabamos de ver.
Las cadenas de texto que se puedan usar en el bucle principal del programa deberían imprimirse como Sprites, y los valores numéricos como impresión tipo “PrintChar_8x8” de cada uno de sus dígitos, realizando sólo una conversión numérica del número de dígitos realmente necesario.
Impresión de valores numéricos
Hemos visto hasta ahora cómo imprimir cadenas de texto ASCII, pero en muchas ocasiones nos veremos en la necesidad de imprimir el valor numérico contenido por un registro o una variable de memoria.
Para poder realizar esta impresión necesitamos rutinas que conviertan un valor numérico en una representación ASCII, la cual imprimiremos luego con PrintString_8x8. Según la base de conversión, necesitaremos las siguientes rutinas:
- Bin2String : Convierte el valor numérico de un registro o variable en una cadena ASCII con la representación binaria (unos y ceros) de dicho valor (base=2).
- Hex2String : Convierte el valor numérico de un registro o variable en una cadena ASCII con la representación en hexadecimal (2 o 4 dígitos del 0 a la F) de dicho valor (base=16).
- Int2String : Convierte el valor numérico sin signo de un registro o variable en una cadena ASCII con la representación decimal (N dígitos 0-9) de dicho valor (base=10).
El parámetro de entrada a las rutinas será L para valores de 8 bits o HL para valores de 16 bits, y todas las rutinas utilizarán un área temporal de memoria para escribir en ella la cadena resultante de la conversión:
;;; Espacio de almacenamiento de las rutinas de conversion: conv2string DS 18
Las rutinas acabarán el proceso de conversión agregrando un 0 (END OF STRING) tras los ASCIIs obtenidos, con el objetivo de que la cadena pueda ser directamente impresa con las funciones vistas hasta ahora.
De esta forma, para imprimir en pantalla en formato Decimal el valor de 8 bits del registro A, haríamos lo siguiente:
;;; Guardar en L el valor a convertir y llamar a rutina LD L, A CALL Dec2String_8 ;;; Imprimir la cadena resultante de la conversion: LD HL, conv2string CALL PrintString_8x8
Veamos las diferentes rutinas:
Bin2String: Conversión a representación binaria
La conversión de un valor numérico a una representación binaria se basa en testear el estado de cada uno de los bits del registro “parámetro” y almacenar en la cadena destino apuntada por DE un valor ASCII '0' ó '1' según el resultado del testeo.
En lugar de ejecutar 8 ó 16 comparaciones con el comando BIT, utilizaremos la rotación a la derecha del registro parámetro de forma que el bit a comprobar sea desplazado al Carry Flag y podamos testear su valor con un JR NC o JR C.
La rutina de conversión tiene 2 puntos de entrada diferentes según necesitemos convertir un número de 8 bits (valor en registro L) o de 16 bits (valor en registro HL), pero utiliza el mismo core de conversión para ambos casos:
;------------------------------------------------------------- ; Bin2String_8 y Bin2String_16: ; Convierte el valor numerico de L o de HL en una cadena de ; texto con su representacion en binario (acabada en 0). ; ; IN: L = Numero a convertir para la version de 8 bits ; HL = Numero a convertir para la version de 16 bits ; OUT: [conv2string] = Cadena con la conversion a BIN. ; Usa: BC ;------------------------------------------------------------- Bin2String_16: ; Punto de entrada de 16 bits LD DE, conv2string ; DE = puntero cadena destino LD C, H ; C = a convertir (parte alta) CALL Bin2String_convert ; Llamamos a rutina conversora JR Bin2String_8b ; Convertimos la parte baja, ; saltando el LD DE, conv2string Bin2String_8: ; Punto de entrada de 8 bits LD DE, conv2string ; DE = puntero cadena destino Bin2String_8b: LD C, L ; C = a convertir (parte baja) CALL Bin2String_convert ; Llamamos a rutina conversora XOR A LD (DE), A ; Guardar End Of String RET Bin2String_convert: LD B, 8 ; 8 iteraciones b2string_loop: ; Bucle de conversion RL C LD A, '1' ; Valor en A por defecto JR NC, b2string_noC LD (DE), A ; Lo almacenamos en la cadena INC DE DJNZ b2string_loop RET b2string_noC: DEC A ; A = '0' LD (DE), A INC DE ; Lo almacenamos y avanzamos DJNZ b2string_loop RET
En el área de memoria apuntada por conv2string tendremos la representación binaria en ASCII del valor en L o HL, acabado en un carácter 0, lista para imprimir con PrintString_8x8.
Hex2String: Conversión a representación hexadecimal
Veamos la rutina de conversión de un valor numérico a una representación hexadecimal:
;------------------------------------------------------------- ; Hex2String_8 y Hex2String_16: ; Convierte el valor numerico de L o de HL en una cadena de ; texto con su representacion en hexadecimal (acabada en 0). ; Rutina adaptada de http://baze.au.com/misc/z80bits.html . ; ; IN: L = Numero a convertir para la version de 8 bits ; HL = Numero a convertir para la version de 16 bits ; OUT: [conv2string] = Cadena con la conversion a HEX. ;------------------------------------------------------------- Hex2String_16: LD DE, conv2string ; Cadena destino LD A, H CALL B2AHex_Num1 ; Convertir Hex1 de H LD A, H CALL B2AHex_Num2 ; Convertir Hex2 de H JR Hex2String_8b ; Realizar conversion de L Hex2String_8: ; Entrada para la rut de 8 bits LD DE, conv2string Hex2String_8b: LD A, L CALL B2AHex_Num1 ; Convertir Hex1 de L LD A, L CALL B2AHex_Num2 ; Convertir Hex2 de L XOR A LD (DE), A ; Guardar End Of String RET B2AHex_Num1: RRA RRA RRA ; Desplazamos 4 veces >> RRA ; para poder usar el siguiente bloque B2AHex_Num2: OR $F0 ; Enmascaramos 11110000 DAA ; Ajuste BCD ADD A, $A0 ADC A, $40 LD (DE), A ; Guardamos dato INC DE RET
La rutina siempre devolverá una cadena de 2 caracteres + End_Of_String para valores de 8 bits, y de 4 caracteres + End_Of_String para valores de 16 bits.
Int2String: Conversión a representación decimal
Finalmente, veamos la rutina que convierte un valor numérico en su representación en formato decimal natural (representación de número positivo).
;----------------------------------------------------------------- ; Int2String_8 e Int2String_16: ; Convierte un valor de 16 bits a una cadena imprimible. ; ; Entrada: HL = valor numerico a convertir ; Salida: Cadena en int2dec16_result . ; De: Milos Bazelides http://baze.au.com/misc/z80bits.html ;----------------------------------------------------------------- Int2String_16: LD DE, conv2string ; Apuntamos a cadena destino LD BC, -10000 ; Calcular digito decenas de miles CALL Int2Dec_num1 LD BC, -1000 ; Calcular digito miles CALL Int2Dec_num1 JR Int2String_8b ; Continuar en rutina de 8 bits (2) Int2String_8: ; Punto de entrada de rutina 8 bits LD DE, conv2string ; Apuntar a cadena destino LD H, 0 ; Parte alta de HL = 0 Int2String_8b: ; rutina de 8 bits (2) LD BC, -100 ; Calcular digito de centenas CALL Int2Dec_num1 LD C, -10 ; Calcular digito de decenas CALL Int2Dec_num1 LD C, B ; Calcular unidades CALL Int2Dec_num1 XOR A LD (DE), A ; Almacenar un fin de cadena RET Int2Dec_num1: LD A,'0'-1 ; Contador unidades, empieza '0'-1 Int2Dec_num2: INC A ; Incrementamos el digito ('0', ... '9') ADD HL, BC ; Restamos "unidades" hasta sobrepasarlo JR C, Int2Dec_num2 ; Repetir n veces SBC HL, BC ; Deshacemos el último paso LD (DE), A ; Almacenamos el valor INC DE RET
Esta rutina almacena en la cadena todos los valores '0' que obtiene, incluídos los de las unidades superiores al primer dígito del número (leading zeros). Así, la conversión del valor de 8 bits 17 generará una cadena “017” y la conversión del número de 16 bits 1034 generará la cadena “01034”.
Eliminando los “leading zeros”
Si no queremos imprimir los ceros que hay al principio de una cadena apuntada por HL, podemos utilizar la siguiente rutina que incrementa HL mientras encuentre ceros ASCII al principio de la cadena, y sale de la rutina cuando encuentra el fin de cadena o un carácter distinto de '0'.
;----------------------------------------------------------------- ; Incrementar HL para saltar los 0's a principio de cadena ; (utilizar tras llamada a Int2String_8 o Int2String_16). ;----------------------------------------------------------------- INC_HL_Remove_Leading_Zeros: LD A, (HL) ; Leemos caracter de la cadena OR A RET Z ; Fin de cadena -> volver CP '0' RET NZ ; Distinto de '0', volver INC HL ; '0', incrementar HL y repetir JR INC_HL_Remove_Leading_Zeros
La rutina de conversión, en conjunción con la subrutina para eliminar los leading zeros se utilizaría de la siguiente forma:
;;; Imprimir variable de 8 bits (podría ser un registro) LD A, (variable_8bits) LD L, A CALL Int2String_8 LD HL, conv2string CALL INC_HL_Remove_Leading_Zeros CALL PrintString_8x8 ;;; Imprimir variable de 16 bits LD BC, (variable_16bits) PUSH BC POP HL ; HL = BC CALL Int2String_16 LD HL, conv2string CALL INC_HL_Remove_Leading_Zeros CALL PrintString_8x8
Justificando los “leading zeros”
Finalmente, el usuario climacus en los foros de Speccy.org nos ofrece la siguiente variación de INC_HL_Remove_Leading_Zeros para que la rutina imprima espacios en lugar de “leading zeros”, lo que provoca que el texto en pantalla esté justificado a la derecha en ocupando siempre 3 (valores de 8 bits) ó 5 (valores de 16 bits) caracteres. Esto permite que los valores impresos puedan sobreescribir en pantalla valores anteriores aunque estemos imprimiendo un valor “menor” que el que reside en pantalla:
INC_HL_Justify_Leading_Zeros: LD A, (HL) ; Leemos caracter de la cadena OR A RET Z ; Fin de cadena -> volver CP '0' RET NZ ; Distinto de '0', volver INC HL ; '0', incrementar HL y repetir LD A, ' ' CALL Font_Blank ; Imprimimos espacio y avanzamos JR INC_HL_Justify_Leading_Zeros
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.
Int2String_8_2Digits: Valores enteros de 2 dígitos
En el caso de que necesitemos imprimir un valor numérico de 2 digítos (00-99), incluyendo el posible cero inicial (en valores 1-9) o los dos ceros para el valor 00, podemos utilizar la siguiente rutina:
;----------------------------------------------------------------------- ; Int2String_8_2Digits: Convierte el valor del registro A en una ; cadena de texto de max. 2 caracteres (0-99) decimales en DE. ; IN: A = Numero a convertir ; OUT: DE = 2 bytes con los ASCIIs ; Basado en rutina dtoa2d de: ; http://99-bottles-of-beer.net/language-assembler-%28z80%29-813.html ;----------------------------------------------------------------------- Int2String_8_2Digits: LD D, '0' ; Empezar en ASCII '0' DEC D ; Decrementar porque el bucle hace INC LD E, 10 ; Base 10 AND A ; Carry Flag = 0 dtoa2dloop: INC D ; Incrementar numero de decenas SUB E ; Quitar una unidad de decenas de A JR NC, dtoa2dloop ; Si A todavia no es negativo, seguir ADD A, E ; Decrementado demasiado, volver atras ADD A, '0' ; Convertir a ASCII LD E, A ; E contiene las unidades RET
Este formato resulta especialmente útil para la impresión de variables temporales (horas, minutos, segundos), o datos con valores máximos limitados como vidas (0-99) o niveles (0-99).
La forma de imprimir un valor con esta rutina sería el siguiente:
LD A, (vidas) CALL Int2String_8_2Digits ;; Imprimir parte alta (decenas) LD A, 0 LD (FONT_X), A LD A, D CALL PrintChar_8x8 ;;; Imprimir parte baja (unidades) LD A, 1 LD (FONT_X), A LD A, E CALL PrintChar_8x8
En un posterior apartado de este mismo capítulo veremos cómo integrar estas funciones en las rutinas de impresión de cadenas con formato.
Fuente estándar 8x8 de la ROM
En el Spectrum disponemos de un tipo de letra estándar de 8×8 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.
Por defecto, CHARS contiene el valor $3D00 (el tipo de letra 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 juego de caracteres estándar es inmutable al estar en ROM. La variable CHARS permitía, 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:
El juego de caracteres estándar de la ROM
El formato en memoria de la fuente de la ROM es idéntico a un spriteset de 8×8 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:
LD HL, 15616-256 ; Saltamos los 32 caracteres iniciales LD (FONT_CHARSET), HL ; Ya podemos utilizar la tipografia del ; Spectrum con nuestras rutinas.
Esto nos permite ahorrar 768 bytes de memoria en nuestro programa (el de un charset personalizado) y disponer de un recurso para la impresión de texto con un aspecto “estándar” (al que el usuario ya está acostumbrado).
Sistema de gestión de texto
Si estamos escribiendo un programa o juego que requiera la impresión de gran cantidad de texto puede resultar imprescindible disponer de un pequeño sistema para almacenar los datos sobre la posición actual del “cursor” en pantalla, color y estilo de la fuente, etc. Asímismo, también resulta especialmente útil un set de rutinas para modificar todas estas variables fácilmente e imprimir cadenas con códigos de control directamente embebidos dentro de las mismas.
Normalmente no se usará este tipo de rutinas en un juego arcade o videoaventura, pero puede aprovecharse en programas no lúdicos y en juegos basados en texto o con gran cantidad de texto (managers deportivos, aventuras de texto, RPGs, etc).
Ya hemos visto cómo las rutinas PrintChar_8x8 y PrintString_8x8 hacen uso de las variables FONT_X, FONT_Y, FONT_CHARSET y FONT_ATTRIB. En este apartado definiremos más variables, funciones para manipularlas y nuevas funciones de impresión que hagan uso avanzado de ambas.
La sección sobre sistemas de gestión de texto se divide en:
- Descripción de las variables globales que se usarán.
- Rutina de impresión de caracteres con diferentes estilos.
- Descripción de códigos de control que se usarán en las cadenas.
- Rutina de impresión de cadenas avanzada que haga uso de los códigos de control.
- Rutina de impresión de cadenas extendida que soporte códigos de variable.
Cuando trabajamos con texto tenemos que tener en cuenta que no se suelen requerir niveles de optimización de tiempos de ejecución como en el caso de la rutinas de impresión de sprites. En este caso, dado que el tiempo de “lectura” del usuario es significativamente mayor que el tiempo de ejecución, las rutinas deben tratar de ahorrar espacio en memoria para que el programa pueda disponer de la mayor cantidad de texto posible.
Variables de nuestro sistema de gestión
Estas son las variables que utilizaremos en nuestras rutinas:
- 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_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).
También utilizaremos algunas constantes que se modificarán sólo en tiempo de ensamblado:
- FONT_SRCWIDTH y FONT_SRCHEIGHT : Definen el ancho y alto de la pantalla en caracteres. Para fuentes de 8×8, vale 32 y 24 respectivamente.
En código de programa:
FONT_CHARSET DEFW $3D00-256 FONT_ATTRIB DEFB 56 ; Negro sobre gris FONT_STYLE DEFB 0 FONT_X DEFB 0 FONT_Y DEFB 0 FONT_SCRWIDTH EQU 32 FONT_SCRHEIGHT EQU 24
El resto de constantes (como los códigos de control) los veremos más adelante en sus correspondientes apartados.
Subrutinas de gestión de posición y atributos
Una vez definidas las diferentes variables, necesitamos funciones básicas para gestionarlas. Nótese que ninguna de las siguientes funciones provoca impresión de datos en pantalla, sólo altera el estado de las variables que acabamos de ver y que después utilizarán las funciones de impresión:
;------------------------------------------------------------- FONT_CHARSET DW $3D00-256 FONT_ATTRIB DB 56 ; Negro sobre gris FONT_STYLE DB 0 FONT_X DB 0 FONT_Y DB 0 FONT_SCRWIDTH EQU 32 FONT_SCRHEIGHT EQU 24 FONT_NORMAL EQU 0 FONT_BOLD EQU 1 FONT_UNDERSC EQU 2 FONT_ITALIC EQU 3 ;------------------------------------------------------------- ; Establecer el CHARSET en USO ; Entrada : HL = direccion del charset en memoria ;------------------------------------------------------------- Font_Set_Charset: LD (FONT_CHARSET), HL RET ;------------------------------------------------------------- ; Establecer el estilo de texto en uso. ; Entrada : A = estilo ;------------------------------------------------------------- Font_Set_Style: LD (FONT_STYLE), A RET ;------------------------------------------------------------- ; Establecer la coordenada X en pantalla. ; Entrada : A = coordenada X ;------------------------------------------------------------- Font_Set_X: LD (FONT_X), A RET ;------------------------------------------------------------- ; Establecer la coordenada Y en pantalla. ; Entrada : A = coordenada Y ;------------------------------------------------------------- Font_Set_Y: LD (FONT_Y), A RET ;------------------------------------------------------------- ; Establecer la posicion X,Y del curso de fuente en pantalla. ; Entrada : B = Coordenada Y ; C = Coordenada X ;------------------------------------------------------------- Font_Set_XY: LD (FONT_X), BC RET ;------------------------------------------------------------- ; Establecer un valor de tinta para el atributo en curso. ; Entrada : A = Tinta (0-7) ; Modifica: AF ;------------------------------------------------------------- Font_Set_Ink: PUSH BC ; Preservamos registros AND 7 ; Borramos bits 7-3 LD B, A ; Lo guardamos en B LD A, (FONT_ATTRIB) ; Cogemos el atributo actual AND %11111000 ; Borramos el valor de INK OR B ; Insertamos INK en A LD (FONT_ATTRIB), A ; Guardamos el valor de INK POP BC RET ;------------------------------------------------------------- ; Establecer un valor de papel para el atributo en curso. ; Entrada : A = Papel (0-7) ; Modifica: AF ;------------------------------------------------------------- Font_Set_Paper: PUSH BC ; Preservamos registros AND 7 ; Borramos bits 7-3 RLCA ; A = 00000XXX -> 0000XXX0 RLCA ; A = 000XXX00 RLCA ; A = 00XXX000 <-- Valor en paper LD B, A ; Lo guardamos en B LD A, (FONT_ATTRIB) ; Cogemos el atributo actual AND %11000111 ; Borramos los datos de PAPER OR B ; Insertamos PAPER en A LD (FONT_ATTRIB), A ; Guardamos el valor de PAPER POP BC RET ;------------------------------------------------------------- ; Establecer un valor de atributo para la impresion. ; Entrada : A = Tinta ;------------------------------------------------------------- Font_Set_Attrib: LD (FONT_ATTRIB), A RET ;------------------------------------------------------------- ; Establecer un valor de brillo (1/0) en el atributo actual. ; Entrada : A = Brillo (0-7) ; Modifica: AF ;------------------------------------------------------------- Font_Set_Bright: AND 1 ; A = solo bit 0 de A LD A, (FONT_ATTRIB) ; Cargamos en A el atributo JR NZ, fsbright_1 ; Si el bit solicitado era RES 6, A ; Seteamos a 0 el bit de flash LD (FONT_ATTRIB), A ; Escribimos el atributo RET fsbright_1: SET 6, A ; Seteamos a 1 el bit de brillo LD (FONT_ATTRIB), A ; Escribimos el atributo RET ;------------------------------------------------------------- ; Establecer un valor de flash (1/0) en el atributo actual. ; Entrada : A = Flash (1/0) ; Modifica: AF ;------------------------------------------------------------- Font_Set_Flash: AND 1 ; A = solo bit 0 de A LD A, (FONT_ATTRIB) ; Cargamos en A el atributo JR NZ, fsflash_1 ; Si el bit solicitado era RES 7, A ; Seteamos a 0 el bit de flash LD (FONT_ATTRIB), A ; Escribimos el atributo RET fsflash_1: SET 7, A ; Seteamos a 1 el bit de flash LD (FONT_ATTRIB), A ; Escribimos el atributo RET ;------------------------------------------------------------- ; Imprime un espacio, sobreescribiendo la posicion actual del ; cursor e incrementando X en una unidad. ; de la pantalla (actualizando Y en consecuencia). ; Modifica: AF ;------------------------------------------------------------- Font_Blank: LD A, ' ' ; Imprimir caracter espacio PUSH BC PUSH DE PUSH HL CALL PrintChar_8x8 ; Sobreescribir caracter POP HL POP DE POP BC CALL Font_Inc_X ; Incrementamos la coord X RET ;------------------------------------------------------------- ; Incrementa en 1 la coordenada X teniendo en cuenta el borde ; de la pantalla (actualizando Y en consecuencia). ; Modifica: AF ;------------------------------------------------------------- Font_Inc_X: LD A, (FONT_X) ; Incrementamos la X INC A ; pero comprobamos si borde derecho CP FONT_SCRWIDTH-1 ; X > ANCHO-1? JR C, fincx_noedgex ; No, se puede guardar el valor CALL Font_CRLF RET fincx_noedgex: LD (FONT_X), A ; Establecemos el valor de X RET ;------------------------------------------------------------- ; Produce un LineFeed (incrementa Y en 1). Tiene en cuenta ; las variables de altura de la pantalla. ; Modifica: AF ;------------------------------------------------------------- Font_LF: LD A, (FONT_Y) ; Cogemos coordenada Y CP FONT_SCRHEIGHT-1 ; Estamos en la parte inferior JR NC, fontlf_noedge ; de pantalla? -> No avanzar INC A ; No estamos, avanzar LD (FONT_Y), A fontlf_noedge: RET ;------------------------------------------------------------- ; Produce un Retorno de Carro (Carriage Return) -> X=0. ; Modifica: AF ;------------------------------------------------------------- Font_CR: XOR A LD (FONT_X), A RET ;------------------------------------------------------------- ; Provoca un LF y un CR en ese orden. ; Modifica: AF ;------------------------------------------------------------- Font_CRLF: CALL Font_LF CALL Font_CR RET ;------------------------------------------------------------- ; Imprime un tabulador (3 espacios) mediante PrintString. ; Modifica: AF ;------------------------------------------------------------- Font_Tab: PUSH BC PUSH DE PUSH HL LD HL, font_tab_string CALL PrintString_8x8 ; Imprimimos 3 espacios POP HL POP DE POP BC RET font_tab_string DB " ", 0 ;------------------------------------------------------------- ; Decrementa la coordenada X, simultando un backspace. ; No realiza el borrado en si. ; Modifica: AF ;------------------------------------------------------------- Font_Dec_X: LD A, (FONT_X) ; Cargamos la coordenada X OR A RET Z ; Es cero? no se hace nada (salir) DEC A ; No es cero? Decrementar LD (FONT_X), A RET ; Salir ;------------------------------------------------------------- ; Decrementa la coordenada X, simultando un backspace. ; Realiza el borrado imprimiendo un espacio con LD. ; Modifica: AF ;------------------------------------------------------------- Font_Backspace: CALL Font_Dec_X LD A, ' ' ; Imprimir caracter espacio PUSH BC PUSH DE PUSH HL CALL PrintChar_8x8 ; Sobreescribir caracter POP HL POP DE POP BC RET ; Salir
Podemos llamar a estas funciones desde nuestro programa en lugar de incluir una y otra vez el código necesario para efectuar una acción:
LD HL, micharset CALL Font_Set_Charset LD A, 1+(7*8) Call Font_Set_Attrib LD A, FONT_NORMAL CALL Font_Set_Style (...)
Impresión de caracteres con estilos
Aunque ya hemos visto una rutina PrintChar_8x8 para impresión de caracteres, vamos a implementar a continuación una nueva versión de la misma con la posibilidad de utilizar diferente estilos de fuente a partir de la fuente original.
Mediante un único juego de caracteres podemos simular estilos de texto a través de código, manipulando “al vuelo” los datos del charset antes de imprimirlos. Esto nos evita la necesidad de tener múltiples charsets de texto para distintos estilos con la consiguiente ocupación de espacio en memoria.
Los estilos básicos que podemos conseguir al vuelo son normal, negrita, cursiva y subrayado.
Las rutinas de impresión para los 4 estilos esencialmente iguales salvo por el bucle de impresión, por lo que vamos a utilizar una variable global llamada FONT_STYLE para indicar el estilo actual en uso, y modificaremos la rutina PrintChar_8x8 para que haga uso del valor del estilo y modifique el bucle de impresión en consecuencia.
;--- Variables de fuente -------------------- FONT_CHARSET DW $3D00-256 FONT_ATTRIB DB 56 ; Negro sobre gris FONT_STYLE DB 0 FONT_X DB 0 FONT_Y DB 0 ;--- Constantes predefinidas ---------------- FONT_NORMAL EQU 0 FONT_BOLD EQU 1 FONT_UNDERSC EQU 2 FONT_ITALIC EQU 3 ;--- Nueva funcion PrintChar_8x8 ------------ PrintChar_8x8: ;;; Calcular coordenadas destino en Pantalla en DE ;;; Calcular posicion origen (array sprites) en HL ;;; Obtener el valor de FONT_STYLE ;;; Si es == FONT_NORMAL -> Bucle_Impresion_Normal ;;; Si es == FONT_BOLD -> Bucle_Impresion_Negrita ;;; Si es == FONT_UNDERSC -> Bucle_Impresion_Subrayado ;;; Si es == FONT_ITALIC -> Bucle_Impresion_Cursiva ;;; Calcular posicion destino atributo. ;;; Imprimir Atributo.
El esqueleto de la función PrintChar_8x8, a falta de introducir los bucles de impresión, ya lo conocemos:
;------------------------------------------------------------- ; PrintChar_8x8: ; Imprime un caracter de 8x8 pixeles de un charset usando ; el estilo especificado en FONT_STYLE. ;------------------------------------------------------------- PrintChar_8x8: LD BC, (FONT_X) ; B = Y, C = X EX AF, AF' ; Nos guardamos el caracter en A' ;;; Calculamos las coordenadas destino de pantalla en DE: LD A, B AND $18 ADD A, $40 LD D, A LD A, B AND 7 RRCA RRCA RRCA ADD A, C LD E, A ; DE contiene ahora la direccion destino. ;;; Calcular posicion origen (array sprites) en HL como: ;;; direccion = base_sprites + (NUM_SPRITE*8) EX AF, AF' ; Recuperamos el caracter a dibujar de A' LD BC, (FONT_CHARSET) LD H, 0 LD L, A ADD HL, HL ADD HL, HL ADD HL, HL ADD HL, BC ; HL = BC + HL = FONT_CHARSET + (A * 8) EX DE, HL ; Intercambiamos DE y HL (DE=origen, HL=destino) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; INSERTAR AQUI BUCLES DE IMPRESION SEGUN ESTILO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; (...) ;;; Impresion del caracter finalizada ;;; Impresion de atributos LD A, H ; Recuperamos el valor inicial de HL SUB 8 ; Restando los 8 scanlines avanzados ;;; Calcular posicion destino en area de atributos en DE. ; A = H RRCA ; Codigo de Get_Attr_Offset_From_Image RRCA RRCA AND 3 OR $58 LD D, A LD E, L ;;; Escribir el atributo en memoria LD A, (FONT_ATTRIB) LD (DE), A ; Escribimos el atributo en memoria RET
La manera de obtener los diferentes estilos es la siguiente:
Estilo normal:
No se realiza ningún tipo de modificación sobre los datos del carácter: se imprimen tal cual se obtienen del spriteset en un bucle de 8 iteraciones:
;;;;;; Estilo NORMAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LD B, 8 ; 8 scanlines a dibujar drawchar_loop_normal: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_normal JR pchar8_printattr ; Impresion de atributos
Estilo negrita (bold):
Para simular el efecto de la negrita necesitamos aumentar el grosor del carácter. Para eso, leemos cada scanline y realizamos un OR de dicho scanline con una copia del mismo desplazada hacia la derecha o hacia la izquierda.
;;;;;; Estilo NEGRITA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LD B, 8 ; 8 scanlines a dibujar drawchar_loop_bold: LD A, (DE) ; Tomamos el dato del caracter LD C, A ; Creamos copia de A RRCA ; Desplazamos A OR C ; Y agregamos C LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_bold JR pchar8_printattr ; Impresion de atributos
Estilo Subrayado (underscore):
Basta con dibujar los 7 primeros scanlines del carácter correctamente, y trazar como octavo scanline un valor 255 (8 píxeles a 1, una línea horizontal). De esta forma el último scanline se convierte en el subrayado.
;;;;;; Estilo SUBRAYADO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LD B, 7 ; 7 scanlines a dibujar normales drawchar_loop_undersc: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_undersc ;;; El octavo scanline, una linea de subrayado LD A, 255 ; Ultima linea = subrayado LD (HL), A INC H ; Necesario para el SUB A, 8 JR pchar8_printattr ; Impresion de atributos
Estilo Cursiva (italic):
Finalmente, el estilo de letra cursiva implica imprimir los 3 primeros scanlines desplazados hacia la derecha, los 2 centrales sin modificación y los 3 últimos desplazados hacia la izquierda:
;;;;;; Estilo ITALICA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 3 primeros scanlines, a la derecha, LD B, 3 drawchar_loop_italic1: LD A, (DE) ; Tomamos el dato del caracter SRA A ; Desplazamos A a la derecha LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_italic1 ;;; 2 siguientes scanlines, sin tocar LD B, 2 drawchar_loop_italic2: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_italic2 LD B, 3 drawchar_loop_italic3: ;;; 3 ultimos scanlines, a la izquierda, LD A, (DE) ; Tomamos el dato del caracter SLA A ; Desplazamos A LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_italic3 JR pchar8_printattr
El código completo y definitivo de la función de impresión de caracteres con estilo es el siguiente:
;------------------------------------------------------------- ; PrintChar_8x8: ; Imprime un caracter de 8x8 pixeles de un charset usando ; el estilo especificado en FONT_STYLE ; ; Entrada (paso por parametros en memoria): ; ----------------------------------------------------- ; FONT_CHARSET = Direccion de memoria del charset. ; FONT_X = Coordenada X en baja resolucion (0-31) ; FONT_Y = Coordenada Y en baja resolucion (0-23) ; FONT_ATTRIB = Atributo a utilizar en la impresion. ; FONT_STYLE = Estilo a utilizar (0-N). ; Registro A = ASCII del caracter a dibujar. ;------------------------------------------------------------- PrintChar_8x8: LD BC, (FONT_X) ; B = Y, C = X EX AF, AF' ; Nos guardamos el caracter en A' ;;; Calculamos las coordenadas destino de pantalla en DE: LD A, B AND $18 ADD A, $40 LD D, A LD A, B AND 7 RRCA RRCA RRCA ADD A, C LD E, A ; DE contiene ahora la direccion destino. ;;; Calcular posicion origen (array sprites) en HL como: ;;; direccion = base_sprites + (NUM_SPRITE*8) EX AF, AF' ; Recuperamos el caracter a dibujar de A' LD BC, (FONT_CHARSET) LD H, 0 LD L, A ADD HL, HL ADD HL, HL ADD HL, HL ADD HL, BC ; HL = BC + HL = FONT_CHARSET + (A * 8) EX DE, HL ; Intercambiamos DE y HL (DE=origen, HL=destino) ;;; NUEVO: Verificacion del estilo actual LD A, (FONT_STYLE) ; Obtenemos el estilo actual OR A JR NZ, pchar8_estilos_on ; Si es != cero, saltar ;;;;;; Estilo NORMAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LD B, 8 ; 8 scanlines a dibujar drawchar_loop_normal: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_normal JR pchar8_printattr ; Imprimir atributos pchar8_estilos_on: CP FONT_BOLD ; ¿Es estilo NEGRITA? JR NZ, pchar8_nobold ; No, saltar ;;;;;; Estilo NEGRITA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LD B, 8 ; 8 scanlines a dibujar drawchar_loop_bold: LD A, (DE) ; Tomamos el dato del caracter LD C, A ; Creamos copia de A RRCA ; Desplazamos A OR C ; Y agregamos C LD (HL), A ; Establecemos el valor en videomemoria INC DE ; Incrementamos puntero en caracter INC H ; Incrementamos puntero en pantalla (scanline+=1) DJNZ drawchar_loop_bold JR pchar8_printattr pchar8_nobold: CP FONT_UNDERSC ; ¿Es estilo SUBRAYADO? JR NZ, pchar8_noundersc ; No, saltar ;;;;;; Estilo SUBRAYADO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LD B, 7 ; 7 scanlines a dibujar normales drawchar_loop_undersc: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_undersc ;;; El octavo scanline, una linea de subrayado LD A, 255 ; Ultima linea = subrayado LD (HL), A INC H ; Necesario para el SUB A, 8 JR pchar8_printattr pchar8_noundersc: CP FONT_ITALIC ; ¿Es estilo ITALICA? JR NZ, pchar8_UNKNOWN ; No, saltar ;;;;;; Estilo ITALICA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 3 primeros scanlines, a la derecha, LD B, 3 drawchar_loop_italic1: LD A, (DE) ; Tomamos el dato del caracter SRA A ; Desplazamos A a la derecha LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_italic1 ;;; 2 siguientes scanlines, sin tocar LD B, 2 drawchar_loop_italic2: LD A, (DE) ; Tomamos el dato del caracter LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_italic2 LD B, 3 drawchar_loop_italic3: ;;; 3 ultimos scanlines, a la izquierda, LD A, (DE) ; Tomamos el dato del caracter SLA A ; Desplazamos A LD (HL), A ; Establecemos el valor en videomemoria INC DE INC H DJNZ drawchar_loop_italic3 JR pchar8_printattr pchar8_UNKNOWN: ; Estilo desconocido... LD B, 8 ; Lo imprimimos con el normal JR drawchar_loop_normal ; (estilo por defecto) ;;; Impresion de los atributos pchar8_printattr: LD A, H ; Recuperamos el valor inicial de HL SUB 8 ; Restando los 8 scanlines avanzados ;;; Calcular posicion destino en area de atributos en DE. ; A = H RRCA ; Codigo de Get_Attr_Offset_From_Image RRCA RRCA AND 3 OR $58 LD D, A LD E, L ;;; Escribir el atributo en memoria LD A, (FONT_ATTRIB) LD (DE), A ; Escribimos el atributo en memoria RET
Si definimos esta función PrintChar_8x8 en nuestro programa, la función PrintString_8x8 hará uso de ella y podremos imprimir cadenas en diferentes estilos, como en el siguiente ejemplo:
; Ejemplo de estilos de fuente ORG 35000 LD HL, $3D00-256 ; Saltamos los 32 caracteres iniciales LD (FONT_CHARSET), HL LD A, 1+(7*8) LD (FONT_ATTRIB), A ;;; Probamos los diferentes estilos: NORMAL LD A, FONT_NORMAL LD (FONT_STYLE), A LD HL, cadena1 LD A, 4 LD (FONT_Y), A XOR A LD (FONT_X), A CALL PrintString_8x8 ;;; Probamos los diferentes estilos: NEGRITA LD A, FONT_BOLD LD (FONT_STYLE), A LD HL, cadena2 LD A, 6 LD (FONT_Y), A XOR A LD (FONT_X), A CALL PrintString_8x8 ;;; Probamos los diferentes estilos: CURSIVA LD A, FONT_ITALIC LD (FONT_STYLE), A LD HL, cadena3 LD A, 8 LD (FONT_Y), A XOR A LD (FONT_X), A CALL PrintString_8x8 ;;; Probamos los diferentes estilos: SUBRAYADO LD A, FONT_UNDERSC LD (FONT_STYLE), A LD HL, cadena4 LD A, 10 LD (FONT_Y), A XOR A LD (FONT_X), A CALL PrintString_8x8 loop: JR loop RET cadena1 DB "IMPRESION CON ESTILO NORMAL.", 0 cadena2 DB "IMPRESION CON ESTILO NEGRITA.", 0 cadena3 DB "IMPRESION CON ESTILO CURSIVA.", 0 cadena4 DB "IMPRESION CON ESTILO SUBRAYADO.", 0 ;------------------------------------------------------------- FONT_CHARSET DW $3D00-256 FONT_ATTRIB DB 56 ; Negro sobre gris FONT_STYLE DB 0 FONT_X DB 0 FONT_Y DB 0 FONT_NORMAL EQU 0 FONT_BOLD EQU 1 FONT_UNDERSC EQU 2 FONT_ITALIC EQU 3 FONT_SCRWIDTH EQU 32 FONT_SCRHEIGHT EQU 24 END 35000
El anterior ejemplo (que usa el juego de caracteres estándar de la ROM) produce el siguiente resultado en pantalla:
La rutina de impresión PrintChar_8x8 es ahora ligeramente más lenta que la original, pero a cambio nos permite diferentes estilos de texto. Para la impresión de texto con estilo normal, sólo le hemos añadido el siguiente código adicional a ejecutar:
LD A, (FONT_STYLE) OR A JR NZ, pchar8_estilos_on ; Aqui no se produce salto + JR pchar8_printattr ; Este salto si se produce
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.
No obstante, la rutina PrintChar_8x8 puede ser modificada por el lector, para utilizar operaciones OR en la transferencia a pantalla y por tanto respetar el contenido de pantalla al imprimir el carácter.
Impresión de cadenas con códigos de control
Llegados a este punto, tenemos:
- Un sistema de variables que controlan los datos sobre la impresión: posición, estilo, color, fuente de texto, etc.
- Un set de funciones que permite modificar estas variables fácilmente.
- Una función de impresión de caracteres 8×8 que utiliza estas variables para imprimir el carácter indicado en la posición adecuada, con el estilo seleccionado y con el color y fondo elegidos.
El siguiente paso en la escala de la gestión del texto sería la impresión de cadenas con formato para que aproveche nuestras nuevas funciones extendidas. Para esto modificaremos la rutina PrinString_8x8 vista al principio del capítulo de forma que haga uso no sólo de FONT_X y FONT_Y sino también de funciones adicionales que especificaremos en la cadena mediante códigos de control o tokens.
Los códigos de control que vamos a definir y utilizar serán los siguientes:
Código de control | Significado |
---|---|
0 | Indica Fin de cadena |
1 | Cambiar estilo (seguido del byte con el estilo) |
2 | Cambiar posicion x (seguido de la coordenada x) |
3 | Cambiar posicion y (seguido de la coordenada y) |
4 | Cambiar color tinta (seguido del color de tinta) |
5 | Cambiar color de papel (seguido del color de papel) |
6 | Cambiar color de atributo (seguido del byte de atributo) |
7 | Cambiar Brillo ON / OFF (seguido de 1 ó 0) |
8 | Cambiar Flash ON / OFF (seguido de 1 ó 0) |
10 | Provocar LF (LineFeed = avance de linea) (y+=1) |
11 | Provocar avance de linea y retorno de carro (LF y CR) (y+=1 y x=0) |
12 | Avanzar 1 caracter sin imprimir nada (x+=1) |
13 | Provocar CR (retorno de carro o Carriage Return) (x=0) |
14 | Backspace: borrar el caracter de (x-1 si x>0) imprimiendo un espacio y decrementando x. |
15 | Tabulador (impresion de 3 espacios por llamada a PrintString) |
Así pues, declaramos las siguientes constantes predefinidas:
FONT_EOS EQU 0 ; End of String FONT_SET_STYLE EQU 1 FONT_SET_X EQU 2 FONT_SET_Y EQU 3 FONT_SET_INK EQU 4 FONT_SET_PAPER EQU 5 FONT_SET_ATTRIB EQU 6 FONT_SET_BRIGHT EQU 7 FONT_SET_FLASH EQU 8 FONT_XXXXXX EQU 9 ; Libre para ampliaciones FONT_LF EQU 10 FONT_CRLF EQU 11 FONT_BLANK EQU 12 FONT_CR EQU 13 FONT_BACKSPACE EQU 14 FONT_TAB EQU 15 FONT_INC_X EQU 16 ; De la 17 a la 31 libres
Esto nos permitirá definir las cadenas como, por ejemplo:
cadena DB "Cadena de texto ", FONT_SET_INK, 2, "ROJO ", FONT_CRLF DB FONT_SET_INK, 1, "AHORA AZUL" DB FONT_SET_Y, 20, "AHORA EN LA LINEA 20", FONT_EOS
La rutina de impresión de cadenas deberá interpretar cada byte de la misma determinando:
- Si es un código ASCII >= 32 → Imprimir el caracter en FONT_X, FONT_Y (y variar las coordenadas).
- Si es un código de control 0 (EOS) → Fin de la rutina
- Si es un código entre el 1 y el 9 → Recoger parámetro en cadena (siguiente byte) y llamar a la función apropiada.
- Si es un código entre el 10 y el 31 → Llamar a la función apropiada (no hay parámetro).
Esto nos permitirá trabajar con cadenas de texto con múltiples formatos sin tener que realizar el posicionamiento, cambio de color, de papel, gestión de los retornos de carro, etc. en nuestro código, con un gran ahorro en código de manipulación gracias a nuestra nueva rutina genérica de impresión.
Llamaremos a esta rutina de impresión con formato PrintString_8x8_Format, y tendrá el siguiente pseudocódigo:
;;; HL = Cadena que imprimir PrintString_8x8_Format: ;;; bucle: ;;; Coger caracter apuntado por HL. ;;; Incrementar HL ;;; Si HL es mayor que 32 : ;;; Imprimir caracter en FONT_X,FONT_Y ;;; Avanzar el puntero FONT_X ;;; Si HL es menor que 31 : ;;; Si es CERO, salir de la rutina con RET Z. ;;; Si es FONT_SET_SETSTYLE (1): ;;; Coger el siguiente byte de la cadena (el estilo) ;;; Llamar a función Font_Set_Style ;;; Si es FONT_SET_X (2): ;;; Coger el siguiente byte de la cadena (coordenada X) ;;; Llamar a función Font_Set_X ;;; Si es FONT_SET_Y (3): ;;; Coger el siguiente byte de la cadena (coordenada X) ;;; Llamar a función Font_Set_X ;;; (...) ;;; (...) ;;; (...) ;;; Si es FONT_BACKSPACE (14): ;;; Llamar a funcion Font_Backspace ;;; Si es FONT_TAB (15): ;;; Llamar a funcion Font_Tab ;;; Saltar a bucle (se saldrá con el RET Z)
El pseudocódigo que acabamos de ver utiliza gran cantidad de controles de flujo condicionales para decidir a qué rutina debemos de saltar y si tenemos que recoger un parámetro de la cadena (leer valor apuntado por HL e incrementar HL) o no.
En lugar de utilizar un enorme bloque de código con gran cantidad de saltos, vamos a emplear una tabla de saltos. Para ello creamos una tabla en memoria que contenga las direcciones de salto de todos los códigos de control, excepto el cero:
;------------------------------------------------------------- ; Tabla con las direcciones de las 16 rutinas de cambio. ;------------------------------------------------------------- FONT_CALL_JUMP_TABLE: DW 0000, Font_Set_Style, Font_Set_X, Font_Set_Y, Font_Set_Ink DW Font_Set_Paper, Font_Set_Attrib, Font_Set_Bright DW Font_Set_Flash, 0000, Font_LF, Font_CRLF, Font_Blank DW Font_CR, Font_Backspace, Font_Tab, Font_Inc_X
Ahora, suponiendo que tengamos en A el código de control, la rutina en pseudocódigo podría ser así:
PrintString_8x8_Format: bucle: ;;; Coger caracter apuntador por HL. ;;; Incrementar HL ;;; Si HL es mayor que 32 : ;;; Imprimir caracter en FONT_X,FONT_Y ;;; Avanzar el puntero FONT_X ;;; Si HL es menor que 31 : ;;; Si es CERO, salir de la rutina con RET Z. ;;; Calculamos DIR_SALTO = TABLA_SALTOS [ COD_CONTROL ] ;;; Como la tabla es de 2 bytes -> DIR_SALTO = TABLA_SALTOS + COD_CONTROL*2 ;;; Si es menor que 10, requiere recoger parametro ;;; Recoger parametro ;;; Si es mayor que 10, no requiere recoger parametro ;;; Saltar a la dirección DIR_SALTO ;;; Saltar a bucle (se saldrá con el RET Z)
Veamos el código de la rutina definitiva:
;------------------------------------------------------------- ; Tabla con las direcciones de las 16 rutinas de cambio. ; Notese que la 9 queda libre para una posible ampliacion. ;------------------------------------------------------------- FONT_CALL_JUMP_TABLE: DW 0000, Font_Set_Style, Font_Set_X, Font_Set_Y, Font_Set_Ink DW Font_Set_Paper, Font_Set_Attrib, Font_Set_Bright DW Font_Set_Flash, 0000, Font_LF, Font_CRLF, Font_Blank DW Font_CR, Font_Backspace, Font_Tab, Font_Inc_X ;------------------------------------------------------------- ; PrintString_8x8_Format: ; Imprime una cadena de texto de un charset de fuente 8x8. ; ; Entrada (paso por parametros en memoria): ; ----------------------------------------------------- ; FONT_CHARSET = Direccion de memoria del charset. ; FONT_X = Coordenada X en baja resolucion (0-31) ; FONT_Y = Coordenada Y en baja resolucion (0-23) ; FONT_ATTRIB = Atributo a utilizar en la impresion. ; Registro HL = Puntero a la cadena de texto a imprimir. ; Debe acabar en un cero. ; Usa: DE, BC ;------------------------------------------------------------- PrintString_8x8_Format: ;;; Bucle de impresion de caracter pstring8_loop: LD A, (HL) ; Leemos un caracter de la cadena INC HL ; Apuntamos al siguiente caracter CP 32 ; Es menor que 32? JP C, pstring8_ccontrol ; Si, es un codigo de control, saltar PUSH HL ; Salvaguardamos HL CALL PrintChar_8x8 ; Imprimimos el caracter POP HL ; Recuperamos HL ;;; Avanzamos el cursor usando Font_Blank, que incrementa X ;;; y actualiza X e Y si se llega al borde de la pantalla CALL Font_Inc_X ; Avanzar coordenada X JR pstring8_loop ; Continuar impresion hasta CHAR=0 pstring8_ccontrol: OR A ; A es cero? RET Z ; Si es 0 (fin de cadena) volver ;;; Si estamos aqui es porque es un codigo de control distinto > 0 ;;; Ahora debemos calcular la direccion de la rutina que lo atendera. ;;; Calculamos la direccion destino a la que saltar usando ;;; la tabla de saltos y el codigo de control como indice EX DE, HL LD HL, FONT_CALL_JUMP_TABLE RLCA ; A = A * 2 = codigo de control * 2 LD C, A LD B, 0 ; BC = A*2 ADD HL, BC ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) LD C, (HL) ; Leemos la parte baja de la direccion en C... INC HL ; ... para no corromper HL y poder leer ... LD H, (HL) ; ... la parte alta sobre H ... 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>9 y CCONTROL<32 -> saltar a rutina sin recogida CP 18 ; Comprobamos si (CCONTROL-1)*2 < 18 JP NC, pstring8_noparam ; Es decir, si CCONTROL > 9, no hay param ;;; Si CCONTROL < 10 -> recoger parametro: LD A, (DE) ; Cogemos el parametro en cuestion de la cadena INC DE ; Apuntamos al siguiente caracter ;;; Realizamos el salto a la rutina con o sin parametro recogido pstring8_noparam: LD BC, pstring8_retaddr ; Ponemos en BC la dir de retorno PUSH BC ; Hacemos un push de la dir de retorno JP (HL) ; Saltamos a la rutina seleccionada ;;; Este es el punto al que volvemos tras la rutina pstring8_retaddr: EX DE, HL ; Recuperamos en HL el puntero a cadena JR pstring8_loop ; Continuamos en el bucle
El esqueleto de la rutina y la parte de impresión ya la conocemos, porque es idéntica a PrintString_8x8. El principal añadido es la interpretación de los códigos de control, donde la parte más interesante es la construcción y uso de la tabla de saltos:
Una vez ubicadas todas las diferentes direcciones de las rutinas en FONT_CALL_JUMP_TABLE, podemos utilizar el valor del registro A para direccionar la tabla. Para ello debemos multiplicar A por 2 ya que cada dirección consta de 2 bytes. Cargando A*2 en BC podemos calcular la dirección destino en la tabla como HL+BC (BASE+DESPLAZAMIENTO = BASE+COD_CONTROL*2). Leyendo el valor apuntado por HL obtenemos la dirección de la tabla, es decir, la dirección de la rutina que puede interpretar el código de control que hemos recibido.
;;; Calculamos la direccion destino a la que saltar usando ;;; la tabla de saltos y el codigo de control como indice EX DE, HL LD HL, FONT_CALL_JUMP_TABLE RLCA ; A = A * 2 = codigo de control * 2 LD C, A LD B, 0 ; BC = A*2 ADD HL, BC ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) LD C, (HL) ; Leemos la parte baja de la direccion en C... INC HL ; ... para no corromper HL y poder leer ... LD H, (HL) ; ... la parte alta sobre H ... LD L, C ; No hemos usado A porque se usa en el CP ; HL = FONT_CALL_JUMP_TABLE+(CodControl*2) ; (...) ; Codigo de recogida de parametro si procede LD BC, pstring8_retaddr ; Ponemos en BC la dir de retorno PUSH BC ; Hacemos un push de la dir de retorno JP (HL) ; Saltamos a la rutina seleccionada ;;; Este es el punto al que volvemos tras la rutina pstring8_retaddr:
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.
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.
La comprobación de si debemos recoger o no parámetro desde la cadena la realizamos con el siguiente código:
;;; Si CCONTROL>0 y CCONTROL<10 -> recoger parametro y saltar a rutina ;;; Si CCONTROL>9 y CCONTROL<32 -> saltar a rutina sin recogida CP 18 ; Comprobamos si (CCONTROL-1)*2 < 18 JP NC, pstring8_noparam ; Es decir, si CCONTROL > 9, no hay param
En lugar de volver a dividir el código de control entre 2 (recordemos que se multiplicó por 2 para el cálculo de la dirección de salto) y comprobar si es > 9, podemos comprobar directamente si es > 9*2 = 18.
Tras interpretar el código de control, bastará con volver a saltar al principio de la rutina para continuar con el siguiente carácter. Todo el proceso se repetirá hasta recibir en A un código de control 0 (FONT_EOS, de FONT_END_OF_STRING).
Una vez explicada la rutina, veamos un ejemplo de cómo podríamos utilizarla en nuestros programas:
; Ejemplo de gestion de texto ORG 35000 LD HL, $3D00-256 ; Saltamos los 32 caracteres iniciales CALL Font_Set_Charset LD A, 1+(7*8) Call Font_Set_Attrib ;;; Probamos los diferentes estilos: NORMAL LD A, FONT_NORMAL CALL Font_Set_Style LD HL, cadena1 LD B, 4 LD C, 0 CALL Font_Set_XY CALL PrintString_8x8_Format loop: JR loop cadena1 DB "SALTO DE", FONT_LF, "LINEA ", FONT_SET_X, 4, FONT_SET_Y, 9 DB "IR A (4,9) ", FONT_SET_INK, 2, "ROJO " DB FONT_SET_INK, 0, "NEGRO", FONT_CRLF, FONT_LF DB "CRLF+LF ", FONT_SET_STYLE, FONT_UNDERSC, "ESTILO SUBRAYADO" DB FONT_CRLF, FONT_CRLF, FONT_SET_STYLE, FONT_BOLD, "NEGRITA" DB FONT_CRLF, FONT_CRLF, FONT_SET_STYLE, FONT_ITALIC, "CURSIVA" DB FONT_CRLF, FONT_CRLF, FONT_TAB, FONT_SET_PAPER, 0 DB FONT_SET_INK, 6, "TABULADOR + INK 6 PAPER 0" DB FONT_EOS END 35000
La salida en pantalla del anterior ejemplo (añadiendo las funciones correspondientes al código):
Es importante destacar que podríamos ampliar la rutina de impresión con más códigos de control y funciones. Con la configuración que hemos visto, el código de control 9 queda libre para la introducción de una función adicional que requiera parámetro, y del 17 al 31 podemos añadir más funciones de formato que no requieran parámetros (por ejemplo, combinaciones de color y estilos concretos en una función que cambie BRIGHT, FLASH, INK, PAPER y STYLE, o incluso cambios entre diferentes charsets).
Si necesitaremos más “espacio” para rutinas con parámetro, podríamos “reubicar” los códigos de control por encima del 10 (cambiando los EQUs) y modificando el CP de la rutina que determinar si el control-code tiene parámetro o no.
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.
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:
CP 32 ; Es menor que 32? JP C, pstring8_ccontrol ; Si, es un codigo de control, saltar
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.
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.
Donde no hay duda de la gran utilidad de las anteriores rutinas es en cualquier juego basado en texto, donde nos evitamos realizar el formato de los textos en base a programación y llamadas continuadas a las funciones de formato, posicionamiento, etc. Bastará con definir las cadenas en nuestro programa con el formato adecuado. El ahorro en líneas de código será muy considerable.
Impresión avanzada: datos variables
Nuestro siguiente objetivo es extender PringString_8x8_Format para permitir la utilización de códigos de control que representen valores de variables. El objetivo es simular la funcionalidad de la función printf() del lenguaje C, el cual permite impresiones de cadena como la siguiente:
printf( "Jugador %s: Tienes %d vidas.", nombre, vidas );
Para eso vamos a crear una nueva rutina PrintString_8x8_Format_Args que además de los códigos de control de formato, comprenda códigos para la impresión de variables de cadena o numéricas en representación decimal, hexadecimal o binaria.
Los nuevos códigos de control imitarán el formato de C (símbolo de % seguido de un identificador del tipo de variable) y podrán estar así integrados dentro del propio texto:
Código de control | Significado |
---|---|
%d | Imprimir argumento número entero de 8 bits en formato decimal |
%D | Imprimir argumento número entero de 16 bits en formato decimal |
%t | Imprimir argumento número entero 0-99 con 2 dígitos incluyendo ceros |
%x | Imprimir argumento de 8 bits en formato hexadecimal |
%X | Imprimir argumento de 16 bits en formato hexadecimal |
%b | Imprimir argumento de 8 bits en formato binario |
%B | Imprimir argumento de 16 bits en formato binario |
%s | Imprimir argumento de tipo cadena (acabada en 0 / EOS) |
%% | Símbolo del porcentaje (%) |
De esta forma podremos definir cadenas como:
cadena1 DB "Has obtenido %D puntos", FONT_EOS cadena2 DB "El numero %d en binario es %b", FONT_EOS cadena3 DB "Has tenido un %d %% de aciertos", FONT_EOS cadena4 DB "Bienvenido al juego, %s", FONT_EOS cadena5 DB "Hora: %t:%t", FONT_EOS
Nótese que podríamos haber empleado el sistema de códigos de formato con los ASCIIs libres entre el 17 y el 31. El lector puede adaptar fácilmente la rutina a ese sistema si así lo deseara.
Volvamos a PrintString_8x8_Format_Args: Nuestra nueva rutina deberá recibir ahora un parámetro adicional: además de la cadena a imprimir en HL, deberemos apuntar el registro IX a un array con los datos a sustuitir, o apuntando a una única variable de memoria si sólo hay un parámetro.
La rutina es similar a PrintString_8x8_Format, pero añadiendo lo siguiente:
;;; HL = Cadena que imprimir PrintString_8x8_Format_Args: ;;; bucle: ;;; Coger caracter apuntado por HL. ;;; Incrementar HL ;;; Si HL es mayor que 32 : ;;; Si es un caracter '%': ;;; Si el siguiente caracter no es %: ;;; Saltamos a seccion de codigo_gestion_ARGS ;;; Imprimir caracter en FONT_X,FONT_Y ;;; Avanzar el puntero FONT_X ;;; Si HL es menor que 31 : ;;; Si es CERO, salir de la rutina con RET Z. (...) codigo_gestion_ARGS: ;;; Llegamos aqui con el codigo en A ;;; Si el codigo es 'd' -> Saltar a gestion de tipo int8 ;;; Si el codigo es 'D' -> Saltar a gestion de tipo int16 ;;; Si el codigo es 't' -> Saltar a gestion de tipo int8_2digits ;;; Si el codigo es 'x' -> Saltar a gestion de tipo hex8 ;;; Si el codigo es 'X' -> Saltar a gestion de tipo hex16 ;;; Si el codigo es 'b' -> Saltar a gestion de tipo bin8 ;;; Si el codigo es 'B' -> Saltar a gestion de tipo bin16 ;;; Si el codigo es 's' -> Saltar a gestion de tipo string
En código:
loop: LD A, (HL) ; Leemos un caracter de la cadena ;;; (...) CP '%' ; Es un caracter %? JR NZ, pstring8_novar ; Comprobamos si es variable LD A, (HL) ; Cogemos en A el siguiente char INC HL CP '%' ; Es otro caracter %? (leido %%?) JR NZ, pstring8v_var ; No, es una variable -> Saltar ; Si, era %, seguir para imprimirlo (...) ;;; Aqui se gestionan los codigos de control con % (tipo = A) pstring8v_var: ;;; comprobamos los tipos y saltamos a sus rutinas de gestion CP 'd' JR Z, pstring8v_int8 CP 't' JR Z, pstring8v_int8_2d CP 'D' JR Z, pstring8v_int16 CP 's' JR Z, pstring8v_string CP 'x' JR Z, pstring8v_hex8 CP 'X' JR Z, pstring8v_hex16 CP 'b' JP Z, pstring8v_bin8 CP 'B' JP Z, pstring8v_bin16 JP pstring8_novar ; Otro: imprimir caracter tal cual
Las diferentes porciones de código a las que saltaremos según el tipo de dato a imprimir harán uso de las funciones de conversión de valor numérico a cadena que ya vimos en un anterior apartado de este capítulo. Por ejemplo:
CP 'd' JR Z, pstring8v_int8 (...) pstring8v_int8: PUSH HL LD L, (IX+0) INC IX CALL Int2String_8 LD HL, conv2string CALL INC_HL_Remove_Leading_Zeros CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal
El código completo de la rutina es el siguiente:
;------------------------------------------------------------- ; PrintString_8x8_Format_Args: ; Imprime una cadena de texto de un charset de fuente 8x8. ; Soporta codigos de control y argumentos. ; ; Entrada (paso por parametros en memoria): ; ----------------------------------------------------- ; FONT_CHARSET = Direccion de memoria del charset. ; FONT_X = Coordenada X en baja resolucion (0-31) ; FONT_Y = Coordenada Y en baja resolucion (0-23) ; FONT_ATTRIB = Atributo a utilizar en la impresion. ; Registro HL = Puntero a la cadena de texto a imprimir. ; Debe acabar en cero (FONT_EOS). ; Registro IX = Puntero al listado de argumentos (si hay). ; Usa: DE, BC ;------------------------------------------------------------- PrintString_8x8_Format_Args: ;;; Bucle de impresion de caracter pstring8v_loop: LD A, (HL) ; Leemos un caracter de la cadena INC HL ; Apuntamos al siguiente caracter CP 32 ; Es menor que 32? JP C, pstring8v_ccontrol ; Si, es un codigo de control, saltar CP '%' ; Es un caracter %? JR NZ, pstring8_novar ; Comprobamos si es variable LD A, (HL) ; Cogemos en A el siguiente char INC HL CP '%' ; Es otro caracter %? (leido %%?) JR NZ, pstring8v_var ; No, es una variable -> Saltar ; Si, era %, seguir para imprimirlo pstring8_novar: PUSH HL ; Salvaguardamos HL CALL PrintChar_8x8 ; Imprimimos el caracter POP HL ; Recuperamos HL ;;; Avanzamos el cursor usando Font_Blank, que incrementa X ;;; y actualiza X e Y si se llega al borde de la pantalla CALL Font_Inc_X ; Avanzar coordenada X JR pstring8v_loop ; Continuar impresion hasta CHAR=0 pstring8v_ccontrol: OR A ; A es cero? RET Z ; Si es 0 (fin de cadena) volver ;;; Si estamos aqui es porque es un codigo de control distinto > 0 ;;; Ahora debemos calcular la direccion de la rutina que lo atendera. ;;; Calculamos la direccion destino a la que saltar usando ;;; la tabla de saltos y el codigo de control como indice EX DE, HL LD HL, FONT_CALL_JUMP_TABLE DEC A ; Decrementamos A (puntero en tabla) RLCA ; A = A * 2 = codigo de control * 2 LD C, A LD B, 0 ; BC = A*2 ADD HL, BC ; HL = DIR FONT_CALL_JUMP_TABLE+(CodControl*2) LD C, (HL) INC HL LD H, (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>9 y CCONTROL<32 -> saltar a rutina sin recogida CP 18 ; Comprobamos si (CCONTROL-1)*2 < 18 JP NC, pstring8v_noparam ; Es decir, si CCONTROL > 9, no hay param ;;; Si CCONTROL < 10 -> recoger parametro: LD A, (DE) ; Cogemos el parametro en cuestion de la cadena INC DE ; Apuntamos al siguiente caracter ;;; Realizamos el salto a la rutina con o sin parametro recogido pstring8v_noparam: LD BC, pstring8v_retaddr ; Ponemos en BC la dir de retorno PUSH BC ; Hacemos un push de la dir de retorno JP (HL) ; Saltamos a la rutina seleccionada ;;; Este es el punto al que volvemos tras la rutina pstring8v_retaddr: EX DE, HL ; Recuperamos en HL el puntero a cadena JR pstring8v_loop ; Continuamos en el bucle ;;; Aqui se gestionan los codigos de control con % (tipo = A) pstring8v_var: ;;; comprobamos los tipos y saltamos a sus rutinas de gestion CP 'd' JR Z, pstring8v_int8 CP 't' JR Z, pstring8v_int8_2d CP 'D' JR Z, pstring8v_int16 CP 's' JR Z, pstring8v_string CP 'x' JR Z, pstring8v_hex8 CP 'X' JP Z, pstring8v_hex16 CP 'b' JP Z, pstring8v_bin8 CP 'B' JP Z, pstring8v_bin16 JP pstring8_novar ; Otro: imprimir caracter tal cual ;---------------------------------------------------------- pstring8v_int8: PUSH HL LD L, (IX+0) INC IX CALL Int2String_8 LD HL, conv2string CALL INC_HL_Remove_Leading_Zeros CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_int8_2d: PUSH HL LD A, (IX+0) INC IX CALL Int2String_8_2Digits LD A, D ; Resultado conversion en DE PUSH DE CALL PrintChar_8x8 ; Imprimir parte alta (decenas) CALL Font_Inc_X POP DE LD A, E CALL PrintChar_8x8 ; Imprimir parte alta (decenas) CALL Font_Inc_X POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_int16: PUSH HL LD L, (IX+0) INC IX LD H, (IX+0) INC IX CALL Int2String_16 LD HL, conv2string CALL INC_HL_Remove_Leading_Zeros CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_string: PUSH HL PUSH IX ; HL = IX POP HL call PrintString_8x8 ; Imprimimos cadena POP HL pstring8v_strloop: ; Incrementamos IX hasta el fin LD A, (IX+0) ; de la cadena, recorriendola INC IX ; hasta (IX) = 0 OR A JR NZ, pstring8v_strloop ; De esta forma IX ya apunta al siguiente argumento JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_hex8: PUSH HL LD L, (IX+0) INC IX LD L, 40 CALL Hex2String_8 LD HL, conv2string CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_hex16: PUSH HL LD L, (IX+0) INC IX LD H, (IX+0) INC IX CALL Hex2String_16 LD HL, conv2string CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_bin8: PUSH HL LD L, (IX+0) INC IX CALL Bin2String_8 LD HL, conv2string CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_bin16: PUSH HL LD L, (IX+0) INC IX LD H, (IX+0) INC IX CALL Bin2String_16 LD HL, conv2string CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal
La llamada a la rutina de impresión con parámetros se realiza apuntando HL a la cadena con formato e IX al listado de parámetros:
; Ejemplo de impresion de texto con argumentos ORG 35000 LD HL, $3D00-256 CALL Font_Set_Charset LD BC, $0400 CALL Font_Set_XY LD HL, cadena1 LD IX, args1 CALL PrintString_8x8_Format_Args LD HL, cadena2 LD IX, args2 CALL PrintString_8x8_Format_Args loop: JR loop RET cadena1 DB "VALOR 8 bits: 40", FONT_CRLF, FONT_CRLF DB "Decimal: %d" , FONT_CRLF DB "Hexadecimal: $%x" , FONT_CRLF DB "Binario: %%%b" , FONT_CRLF DB FONT_CRLF, FONT_CRLF DB "VALOR 16 bits: 1205", FONT_CRLF, FONT_CRLF DB "Decimal: %D" , FONT_CRLF DB "Hexadecimal: $%X" , FONT_CRLF DB "Binario: %%%B" , FONT_CRLF, FONT_CRLF, FONT_CRLF DB FONT_EOS args1 DB 40, 40, 040 DW 1205, 1205, 1205 cadena2 DB "2 CADENAS:", FONT_CRLF, FONT_CRLF DB "Cadenas: %t: %s y %s" DB FONT_EOS args2 DB 2, "cad 1", FONT_EOS, "cad 2", FONT_EOS END 35000
No es necesario que el vector de parámetros contenga más de un elemento. Podemos utilizar la rutina directamente con una variable de datos para imprimir su valor:
LD HL, cadvidas ; Cadena LD IX, vidas ; Variable de argumentos CALL PrintString_8x8_Format_Args ; Imprimir (...) cadvidas DB "Tienes %d vidas", FONT_EOS vidas DB 10
Sí que hay que ser especialmente cuidadoso a la hora de definir los parámetros en la variable que apuntamos con IX: es importante que cada parámetro tenga su tamaño adecuado (DB, DW), y que no le falten los End Of String (0) a las cadenas.
Nótese que los parámetros que se imprimen pueden ser modificados por el programa, por lo que esta rutina es muy útil en juegos o programas que trabajen con muchos datos a mostrar.
Añadiendo más códigos de control
El sistema que acabamos de ver permite su ampliación con nuevos tipos de datos o métodos de impresión específicos. Supongamos por ejemplo que queremos añadir 2 nuevos tipos de impresión de valores enteros, uno en el que se añadan los ceros al inicio de las cadenas resultantes de la conversión, y otro que permita la impresión justificada.
Para ello creamos los nuevos “códigos de control”:
Código de control | Significado |
---|---|
%z | Imprimir argumento número entero de 8 bits en formato decimal con sus leading zeros |
%Z | Imprimir argumento número entero de 16 bits en formato decimal con sus leading zeros |
%j | Imprimir argumento número entero de 8 bits en formato decimal justificado a derecha (3 caracteres) |
%J | Imprimir argumento número entero de 16 bits en formato decimal justificado a derecha (5 caracteres) |
A continuación realizamos las modificaciones adecuadas a la rutina PrintString_8x8_Format_Args:
PrintString_8x8_Format_Args: ;;; (...) ;;; Aqui se gestionan los codigos de control con % (tipo = A) pstring8v_var: ;;; comprobamos los tipos y saltamos a sus rutinas de gestion (...) CP 'z' JR Z, pstring8v_int8_zeros CP 'Z' JR Z, pstring8v_int16_zeros CP 'j' JR Z, pstring8v_int8_justify CP 'J' JR Z, pstring8v_int16_justify JP pstring8_novar ;---------------------------------------------------------- pstring8v_int8_zeros: PUSH HL LD L, (IX+0) INC IX CALL Int2String_8 LD HL, conv2string CALL PrintString_8x8 ; No llamamos a Remove_Leading_Zeros POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_int16_zeros: PUSH HL LD L, (IX+0) INC IX LD H, (IX+0) INC IX CALL Int2String_16 LD HL, conv2string CALL PrintString_8x8 ; No llamamos a Remove_Leading_Zeros POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_int8_justify: PUSH HL LD L, (IX+0) INC IX CALL Int2String_8 LD HL, conv2string ; Llamamos a funcion Justify CALL INC_HL_Justify_Leading_Zeros CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal ;---------------------------------------------------------- pstring8v_int16_justify: PUSH HL LD L, (IX+0) INC IX LD H, (IX+0) INC IX CALL Int2String_16 LD HL, conv2string ; Llamamos a funcion Justify CALL INC_HL_Justify_Leading_Zeros CALL PrintString_8x8 POP HL JP pstring8v_loop ; Volvemos al bucle principal (...)
Lo normal a la hora de utilizar PrintString_Format_Args en nuestro programa es que eliminemos todos aquellos códigos de control (y sus rutinas de chequeo y de gestión) de los cuales no vayamos a hacer uso, con el consiguiente ahorro de memoria (desaparecen las instrucciones de las subrutinas de gestión).
Lectura de texto desde teclado
La posibilidad de leer una cadena tecleada por el usuario puede resultar fundamental en programas basados en texto. En algunos juegos podríamos aprovecharla para introducción de claves de acceso, pero en aventuras de texto o programas puede resultar imprescindible.
Una rutina de lectura de teclado recibirá como parámetro un puntero a un área vacía en memoria con suficiente espacio libre para la cadena, así como el tamaño máximo de cadena que queremos leer (un límite que asegure que no escribimos contenido fuera del área reservada y apuntada por HL).
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 necesitaremos una rutina más “avanzada”, que permita detectar el uso de CAPS SHIFT y DELETE (CAPS SHIFT + '0') y que distinga por tanto entre mayúsculas y minúsculas. Para eso, utilizaremos la rutina de escaneo de teclado y conversión a ASCII de la ROM del Spectrum (KEY_SCAN), 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).
El desarrollo de la rutina será el siguiente:
;;; Utilizar HL como puntero a una cadena vacía o con contenido. ;;; Utilizar un contador de tamaño de la cadena con valor inicial = longitud maxima - 1 ;;; Imprimir cursor. ;;; En un bucle: ; Bucle lectura teclado: ; Hacer LAST_K = 0 ; Leer el estado del teclado con KEY_SCAN. ; Repetir hasta que LAST_K sea distinto de 0. ; Si se ha pulsado la tecla de ENTER (LAST_K==13): ; Borrar el cursor en pantalla. ; Insertar un cero en la cadena (End Of String) y salir. ; Si se ha pulsado la tecla de DELETE o CAPS+'0' (LAST_K==12): ; Si no estamos en el primer caracter de la cadena: ; Borrar el cursor en pantalla. ; Realizar un FONT_BACKSPACE. ; Incrementar contador de longitud (cabe un caracter más). ; Si se ha pulsado una tecla de ASCII >= 32: ; Si el contador de longitud es mayor que 0: ; Insertar el ASCII en (HL) e incrementar HL. ; Imprimirla en pantalla e incrementar FONT_X. ; Decrementar contador de longitud. ; Reimprimir cursor.
Veamos el código de la rutina InputString_8x8:
LAST_K EQU 23560 KEY_SCAN EQU $028E ;------------------------------------------------------------- ; InputString_8x8: ; Obtiene una cadena de texto desde teclado. ; ; Entrada: ; Registro HL = Puntero a la cadena de texto a obtener. ; Registro A = Longitud maxima de la cadena a obtener ; Usa: ;------------------------------------------------------------- InputString_8x8: PUSH HL ; Guardamos el puntero a la cadena PUSH DE PUSH BC ; Modificados por KEY_SCAN LD (inputs_counter), A ; Contador de caracteres a usar LD (inputs_limit), A ; Guardamos la longitud maxima inputs_start: LD A, '_' ; Imprimir nuevo cursor CALL Font_SafePrintChar_8x8 XOR A LD (LAST_K), A ; Limpiar ultima tecla pulsada inputs_loop: PUSH HL ; KEY_SCAN modifica HL -> preservar CALL KEY_SCAN ; Escanear el teclado POP HL LD A, (LAST_K) ; Obtener el valor decodificado CP 13 JR Z, inputs_end ; Es enter? -> fin de rutina CP 12 JR Z, inputs_delete ; Es DELETE? -> borrar caracter CP 32 JR C, inputs_loop ; Es < 32? -> repetir bucle escaneo ;;; Si estamos aqui, ASCII >= 32 -> Es caracter valido -> Guardiar EX AF, AF' ; Nos guardamos el valor ASCII en A' ;;; Comprobacion de longitud maxima de cadena LD A, (inputs_counter) ; A = caracteres disponibles OR A ; Comprobar si es 0 JR Z, inputs_loop ; Si es cero, no insertar caracter DEC A LD (inputs_counter), A ; Decrementar espacio disponible EX AF, AF' ; Recuperamos ASCII de A' LD (HL), A ; Guardamos el caracter leido INC HL ; Avanzamos al siguiente caracter e imprimir CALL Font_SafePrintChar_8x8 CALL Font_Inc_X JR inputs_start ; Repetir continuamente hasta ENTER ;;; Codigo a ejecutar cuando se pulsa enter inputs_end: ; ENTER pulsado -> Fin de la rutina LD A, ' ' ; Borramos de la pantalla el cursor CALL Font_SafePrintChar_8x8 XOR A LD (HL), A ; Almacenamos un FIN DE CADENA en HL POP BC POP DE ; Recuperamos valores de registros POP HL ; Recuperamos el inicio de la cadena RET ;;; Codigo a ejecutar cuando se pulsa DELETE inputs_delete: ; DELETE pulsado -> Borrar caracter LD A, (inputs_limit) LD B, A LD , (inputs_counter) CP B ; Si char_disponibles-limite == 0 ... JR Z, inputs_loop ; ... no podemos borrar (inicio de cadena) INC A ; Si no, si que podemos borrar: LD (inputs_counter), A ; incrementar espacio disponible DEC HL ; Decrementar puntero en la cadena LD A, ' ' ; Borrar cursor y caracter anterior CALL Font_SafePrintChar_8x8 CALL Font_Dec_X JR inputs_start ; Bucle principal inputs_counter DB 0 inputs_limit DB 0
InputString_8x8 utiliza una nueva subrutina llamada Font_SafePrintChar8x8 que no es más que una encapsulación del PrintChar_8x8 original en la que se preservan y restauran los valores de los registros que modifica internamente PrintChar:
;------------------------------------------------------------- ; Ejecuta PrintChar_8x8 preservando registros ;------------------------------------------------------------- Font_SafePrintChar_8x8 PUSH BC PUSH DE PUSH HL ; Preservar registros CALL PrintChar_8x8 ; Imprimir caracter POP HL ; Recuperar registros POP DE POP BC RET
Veamos un ejemplo de uso de nuestra nueva función de INPUT:
; Ejemplo de input de texto ORG 35000 LD HL, $3D00-256 CALL Font_Set_Charset ;;; Imprimir cadena "Introduce un texto:" LD HL, cadena1 LD B, 4 LD C, 0 CALL Font_Set_XY CALL PrintString_8x8_Format ;;; Obtener el input del usuario LD HL, input1 LD A, 20 CALL InputString_8x8 ;;; Imprimir "Tu cadena es:" + la cadena resultante LD HL, cadena2 CALL PrintString_8x8_Format LD HL, input1 CALL PrintString_8x8_Format RET cadena1 DB "Introduce un texto:", FONT_CRLF, FONT_CRLF DB FONT_SET_INK, 2, FONT_SET_STYLE, FONT_BOLD DB "> ", FONT_EOS cadena2 DB FONT_CRLF, FONT_CRLF, FONT_SET_STYLE, FONT_NORMAL DB FONT_SET_INK, 0, "Tu cadena es: ", FONT_CRLF, FONT_CRLF DB FONT_SET_INK, 2, FONT_SET_STYLE, FONT_BOLD, FONT_EOS input1 DS 35 DB 0 END 35000
Si nuestro programa o juego va a requerir un posibilidades de introducción o edición de textos avanzadas, sería aconsejable ampliar la rutina anterior con nuevas opciones o mejoras como las siguientes:
- Permitir edición multilínea. La rutina actual no permite trabajar (al menos en cuanto al borrado) con entrada de texto de múltiples líneas. Se podría editar la rutina para permitir editar más de una línea de texto, realizando una versión especial de Font_Dec_X que decremente el valor de FONT_Y y ponga FONT_X=0 cuando tratemos de borrar desde el margen izquierdo de la pantalla.
- Habilitar el uso de las teclas de cursor para moverse entre los caracteres de la cadena y así permitir edición avanzada. La rutina debería basarse entonces en un FONT_X y FONT_Y propios y ya no se podría utilizar FONT_BACKSPACE para el borrado. Además, al insertar un carácter en el interior de la cadena habría que mover todos los caracteres en memoria una posición a la derecha y redibujar la cadena completa en pantalla. El cursor podría simularse entonces con FLASH o subrayando la letra actual (por lo que no serviría para editar texto subrayado).
- Permitir llamar a la función con una cadena ya en la zona apuntada por HL. En conjunción con la mejora anterior permitiría editar texto anteriormente introducido.
En cualquier caso, la rutina que acabamos de ver es más que suficiente para recoger cadenas simples en nuestro programa.
Fuentes de 4x8 píxeles (64 caracteres en pantalla)
La resolución de texto del Spectrum es bastante reducida, con sus 32 caracteres en pantalla por línea. Esto provoca limitaciones en programas o juegos de texto que requieren mostrar muchas cadenas de caracteres por pantalla.
Para solucionar esto podemos utilizar una fuente de tamaño 4×8 que nos permita ubicar 2 letras en un mismo bloque de pantalla, proporcionándonos una resolución de 64×24 caracteres.
Dibujar letras distinguibles en 4×8 píxeles no es sencillo, pero existe una fuente de texto ya creada y código para su impresión, creados por Andrew Owen (http://chuntey.wordpress.com) y Tony Samuels (Your Spectrum #13, Abril de 1985).
La fuente de texto en 4×8 tiene el siguiente aspecto:
Para utilizar este set de caracteres sólo tendremos que realizar una nueva rutina de impresión llamada PrintChar_4x8 y modificar la variable que define la anchura de la pantalla, FONT_SWIDTH (que pasa de valer 32 a 64).
La definición de la fuente de 4×8 píxeles en formato DB es la siguiente:
; half width 4x8 font - 384 bytes charset_4x8: DB $00,$02,$02,$02,$02,$00,$02,$00,$00,$52,$57,$02,$02,$07,$02,$00 DB $00,$25,$71,$62,$32,$74,$25,$00,$00,$22,$42,$30,$50,$50,$30,$00 DB $00,$14,$22,$41,$41,$41,$22,$14,$00,$20,$70,$22,$57,$02,$00,$00 DB $00,$00,$00,$00,$07,$00,$20,$20,$00,$01,$01,$02,$02,$04,$14,$00 DB $00,$22,$56,$52,$52,$52,$27,$00,$00,$27,$51,$12,$21,$45,$72,$00 DB $00,$57,$54,$56,$71,$15,$12,$00,$00,$17,$21,$61,$52,$52,$22,$00 DB $00,$22,$55,$25,$53,$52,$24,$00,$00,$00,$00,$22,$00,$00,$22,$02 DB $00,$00,$10,$27,$40,$27,$10,$00,$00,$02,$45,$21,$12,$20,$42,$00 DB $00,$23,$55,$75,$77,$45,$35,$00,$00,$63,$54,$64,$54,$54,$63,$00 DB $00,$67,$54,$56,$54,$54,$67,$00,$00,$73,$44,$64,$45,$45,$43,$00 DB $00,$57,$52,$72,$52,$52,$57,$00,$00,$35,$15,$16,$55,$55,$25,$00 DB $00,$45,$47,$45,$45,$45,$75,$00,$00,$62,$55,$55,$55,$55,$52,$00 DB $00,$62,$55,$55,$65,$45,$43,$00,$00,$63,$54,$52,$61,$55,$52,$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,$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,$10,$10,$32,$55,$56,$33,$00,$00,$10,$20,$73,$25,$25,$43,$06 DB $00,$42,$40,$66,$52,$52,$57,$00,$00,$14,$04,$35,$16,$15,$55,$20 DB $00,$60,$20,$25,$27,$25,$75,$00,$00,$00,$00,$62,$55,$55,$52,$00 DB $00,$00,$00,$63,$55,$55,$63,$41,$00,$00,$00,$53,$66,$43,$46,$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,$24,$22,$22,$21,$22,$22,$04,$00,$56,$A9,$06,$04,$06,$09,$06
Dado que cada caracter es de 4×8 bytes, podemos almacenar en un mismo byte bien 2 scanlines de un mismo ASCII o bien 2 scanlines de 2 ASCIIs consecutivos.
En nuestro caso, cada byte de la fuente contiene los datos de 2 caracteres, por lo que 8 bytes del array tienen los 8 scanlines de 2 ASCIIs consecutivos. El nibble superior (4 bits superiores) de cada byte tiene los datos de un carácter ASCII y el nibble inferior los del siguiente. Así, el primer byte del array tiene el scanline superior (0) de los ASCIIs 32 (nibble alto) y 33 (nibble bajo).
Esta disposición de 2 scanlines por byte permite un ahorro de memoria tal que la fuente completa de texto con 96 caracteres ocupe 768/2 = 384 bytes.
Para posicionarnos en esta fuente desde su base con el objetivo de localizar un carácter en A, deberemos dividir el valor del carácter entre 2 ya que cada byte referencia a 2 caracteres. El resto de la división entre 2 (par o impar) nos indica si el carácter que buscamos está en el nibble superior o el inferior de los 8 bytes consecutivos a leer.
Por otra parte, la pantalla tiene “físicamente” 32 bloques, pero nosotros vamos a imprimir 64 caracteres, por lo que cada bloque puede contener 2 caracteres. Cuando especificamos una coordenada X para imprimir, la rutina necesita dividirla por 2 para saber en qué carácter de pantalla irá impresa la letra. Una vez calculado este carácter, la letra puede ir en la parte “izquierda” del bloque de pantalla (4 bits superiores) o en la parte derecha (4 bits inferiores del bloque). El resto de la división entre 2 de la coordenada X nos indica en cuál de las 2 partes se debe imprimir el carácter.
La rutina de impresión de caracteres de 4×8 es bastante parecida a la rutina estándar de 8×8 salvo por las divisiones entre 2 del carácter ASCII y de la posición X en pantalla para el cálculo del origen en la fuente y del destino en vram.
La impresión del carácter en sí mismo también cambia, ya que existen 4 posibilidades de impresión que requieren 4 porciones de código diferentes:
Como en cada byte de la fuente se definen 2 caracteres (izquierdo y derecho) y a su vez a la hora imprimir en pantalla hay 2 posibilidades de impresión en el mismo bloque (parte izquierda y parte derecha del bloque), necesitamos 4 rutinas que cubran esas cuatro posibilidades.
- Imprimir un carácter de la “parte izquierda” (nibble alto en datos de caracter) de la fuente en la “parte izquierda” de un bloque de pantalla (nibble alto del byte en videoram).
- Imprimir un carácter de la “parte derecha” (nibble bajo en datos de caracter) de la fuente en la “parte izquierda” de un bloque de pantalla (nibble alto del byte en videoram).
- Imprimir un carácter de la “parte izquierda” (nibble alto en datos de caracter) de la fuente en la “parte derecha” de un bloque de pantalla (nibble bajo del byte en videoram).
- Imprimir un carácter de la “parte derecha” (nibble bajo en datos de caracter) de la fuente en la “parte derecha” de un bloque de pantalla (nibble bajo del byte en videoram).
Al trazar el carácter en pantalla tenemos que hacerlo con OR para respetar otro posible carácter de 4×8 que pueda haber en el mismo bloque, ya lo estemos imprimiendo en la parte izquierda de un bloque (respetar el nibble de la derecha) o en la derecha (respetar el nibble de la izquierda).
Veamos la rutina de impresión PrintChar_4x8 seguida de la 4 subrutinas de volcado de carácter que son llamados una vez calculados HL y DE como origen y destino.
;------------------------------------------------------------- ; PrintChar_4x8: ; Imprime un caracter de 4x8 pixeles de un charset. ; ; Entrada (paso por parametros en memoria): ; ----------------------------------------------------- ; FONT_CHARSET = Direccion de memoria del charset. ; FONT_X = Coordenada X en baja resolucion (0-31) ; FONT_Y = Coordenada Y en baja resolucion (0-23) ; FONT_ATTRIB = Atributo a utilizar en la impresion. ; Registro A = ASCII del caracter a dibujar. ;------------------------------------------------------------- PrintChar_4x8: RRA ; Dividimos A por 2 (resto en CF) PUSH AF ; Guardamos caracter y CF en A' ;;; Calcular posicion origen (array fuente) en HL como: ;;; direccion = base_charset + ((CARACTER/2)*8) LD BC, (FONT_CHARSET) LD H, 0 LD L, A ADD HL, HL ADD HL, HL ADD HL, HL ADD HL, BC ; HL = Direccion origen de A en fuente ;;; Calculamos las coordenadas destino de pantalla en DE: LD BC, (FONT_X) ; B = Y, C = X RR C LD A, B AND $18 ADD A, $40 LD D, A LD A, B AND 7 RRCA RRCA RRCA ADD A, C LD E, A ; DE contiene ahora la direccion destino. ;;; Calculamos posición en pantalla. Tenemos que dividirla por 2 porque ;;; 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. LD A, (FONT_X) ; Volvemos a leer coordenada X RRA ; Dividimos por 2 (posicion X en pantalla) ; Ademas el carry tiene el resto (par/impar) JR NC, pchar4_x_odd ; Saltar si es columna impar (por el CF) ;;; Ahora tenemos que imprimir el caracter en pantalla. Hemos saltado ;;; a pchar4_x_even o pchar4_x_odd segun si la posicion en pantalla es ;;; par o impar, pero cada una de estas 2 opciones nos da la posibilidad ;;; de usar una rutina u otra segun si el caracter ASCII es par o impar ;;; ya que tenemos que cogerlo de la fuente de una forma u otra ;;; Posicion de columna en pantalla par: pchar4_x_even : POP AF ; Restaura A=char y CF=si es char par/impar JR C, pchar4_l_on_l JR pchar4_r_on_l pchar4_x_odd: POP AF ; Restaura A=char y CF=si es char par/impar JR NC, pchar4_r_on_r JR pchar4_l_on_r pchar4_continue: ;;; Impresion de los atributos pchar4_printattr: LD A, D ; Recuperamos el valor inicial de DE SUB 8 ; Restando los 8 scanlines avanzados ;;; Calcular posicion destino en area de atributos en HL. RRCA ; A ya es = D, listo para rotar RRCA ; Codigo de Get_Attr_Offset_From_Image RRCA AND 3 OR $58 LD H, A LD L, E ;;; Escribir el atributo en memoria LD A, (FONT_ATTRIB) LD (HL), A ; Escribimos el atributo en memoria RET ;;;------------------------------------------------------------------ ;;; "Subrutinas" de impresion de caracter de 4x8 ;;; Entrada: HL = posicion del caracter en la fuente 4x8 ;;; DE = posicion en pantalla del primer scanline ;;;------------------------------------------------------------------ ;;;---------------------------------------------------- pchar4_l_on_l: LD B, 8 ; 8 scanlines / iteraciones pchar4_ll_lp: LD A, (DE) ; Leer byte de la pantalla AND %11110000 LD C, A ; Nos lo guardamos en C LD A, (HL) ; Cogemos el byte de la fuente AND %00001111 OR C ; Lo combinamos con el fondo LD (DE), A ; Y lo escribimos en pantalla INC D ; Siguiente scanline INC HL ; Siguiente dato del "sprite" DJNZ pchar4_ll_lp JR pchar4_continue ; Volver tras impresion ;;;---------------------------------------------------- pchar4_r_on_r: LD B, 8 ; 8 scanlines / iteraciones pchar4_rr_lp: LD A, (DE) ; Leer byte de la pantalla AND %00001111 LD C, A ; Nos lo guardamos en C LD A, (HL) ; Cogemos el byte de la fuente AND %11110000 OR C ; Lo combinamos con el fondo LD (DE), A ; Y lo escribimos en pantalla INC D ; Siguiente scanline INC HL ; Siguiente dato del "sprite" DJNZ pchar4_rr_lp JR pchar4_continue ; Volver tras impresion ;;;---------------------------------------------------- pchar4_l_on_r: LD B, 8 ; 8 scanlines / iteraciones pchar4_lr_lp: LD A, (DE) ; Leer byte de la pantalla AND %00001111 LD C, A ; Nos lo guardamos en C LD A, (HL) ; Cogemos el byte de la fuente RRCA ; Lo desplazamos 4 veces >> dejando RRCA ; lo bits 4 al 7 vacios RRCA RRCA AND %11110000 OR C ; Lo combinamos con el fondo LD (DE), A ; Y lo escribimos en pantalla INC D ; Siguiente scanline INC HL ; Siguiente dato del "sprite" DJNZ pchar4_lr_lp JR pchar4_continue ; Volver tras impresion ;;;---------------------------------------------------- pchar4_r_on_l: LD B, 8 ; 8 scanlines / iteraciones pchar4_rl_lp: LD A, (DE) ; Leer byte de la pantalla AND %11110000 LD C, A ; Nos lo guardamos en C LD A, (HL) ; Cogemos el byte de la fuente RLCA ; Lo desplazamos 4 veces << dejando RLCA ; los bits 0 al 3 vacios RLCA RLCA AND %00001111 OR C ; Lo combinamos con el fondo LD (DE), A ; Y lo escribimos en pantalla INC D ; Siguiente scanline INC HL ; Siguiente dato del "sprite" DJNZ pchar4_rl_lp JR pchar4_continue ; Volver tras impresion
Para poder utilizar estas rutinas con nuestro sistema de impresión habría que cambiar la constante que define el tamaño de anchura de la pantalla en caracteres:
FONT_SCRWIDTH EQU 64
También habría que crear un PrintString_4x8 idéntico a PrintString_8x8 pero que llame a PrintChar_4x8, y modificar aquellas rutinas que hagan referencia a una de estas 2 funciones, como por ejemplo:
Font_Backspace: CALL Font_Dec_X LD A, ' ' ; Imprimir caracter espacio PUSH BC PUSH DE PUSH HL CALL PrintChar_4x8 ; Sobreescribir caracter POP HL POP DE POP BC RET ; Salir
Una vez realizados estos cambios, podemos utilizar la fuente de 4×8 con nuestro sistema de gestión de texto. Veamos un sencillo ejemplo:
; Ejemplo de fuente de 4x8 pixeles (64 caracteres por linea) ORG 35000 LD HL, charset_4x8-128 ; Inicio charset - (256/2) CALL Font_Set_Charset LD HL, cadena1 LD BC, $0400 ; X=00, Y=04 CALL Font_Set_XY CALL PrintString_4x8_Format loop: JR loop RET cadena1 DB "Fuente de 4x8", FONT_CRLF, FONT_CRLF DB "Esto es un texto impreso a 64 columnas con fuente " DB "de 4x8 pixeles. La letra tiene la mitad de anchura " DB "que la estandar pero todavia se lee con facilidad." DB FONT_CRLF, FONT_CRLF DB "Con esta fuente se pueden realizar juegos basados en " DB "texto pero hay que tener en cuenta que los atributos " DB FONT_SET_INK, 2, "afectan a 2 caracteres ", FONT_SET_INK, 0 DB "a la vez, por lo que es mejor no cambiar el paper y " DB "modificarlos solo antes o tras un espacio." DB FONT_EOS END 35000
Nótese cómo hemos inicializado FONT_CHARSET a la dirección de la fuente menos 128 en lugar de restarle 256. Esto se debe a que la fuente tiene 2 caracteres definidos en cada byte y vamos a dividir el ASCII entre 2 en nuestra rutina, por lo que el carácter en que empieza nuestra fuente, el 32, está en charset4x8 - (256/2) = charset4x8 - 128.
Otro detalle importante es el tema de los atributos: como cada bloque de pantalla contiene 2 caracteres, no podemos establecer atributos diferentes para 2 caracteres del mismo byte. Por esto, hay que ser cauto a la hora de establecer atributos. La solución más sencilla es cambiar las tintas en posiciones donde haya espacios, ya que en ese caso el cambio será efectivo en la letra deseada si ésta es la primera del byte, o en el espacio seguido de la letra deseada si está en la parte derecha. Los cambios de PAPER, BRIGHT o FLASH supondrán problemas si no se realizan siempre en posiciones de pantalla pares.
Finalmente, debido al reducido tamaño de la fuente no se han definido funciones de estilo, ya que es muy difícil realizar estilos de negrita o cursiva con una definición de 4×8. La única opción viable es la creación de un estilo de subrayado creando 4 funciones de impresión 4×8 adicionales (para las 4 combinaciones de par/impar en cuanto a ASCII/pantalla) donde se tracen 7 scanlines y el último se trace como %11110000 ó %00001111.
Ficheros
Enlaces
- Web de SevenuP (por metalbrain).
- Manual del Spectrum 48K: el juego de caracteres.
- Tiempos de ejecución y tamaños de las instrucciones del Z80.