; Ejemplo de impresion de texto con argumentos ORG 35000 ld hl, $3d00-256 ; Saltamos los 32 caracteres iniciales 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 ;------------------------------------------------------------- FONT_CHARSET DW $3d00-256 FONT_ATTRIB DB 56 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 FONT_EOS EQU 0 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 ;------------------------------------------------------------- ; 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 ;----------------------------------------------------------------- ; 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 ;------------------------------------------------------------- ; Espacio de almacenamiento de las rutinas de conversion: ;------------------------------------------------------------- conv2string DS 18 ;----------------------------------------------------------------- ; 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 ld bc, -10000 call Int2Dec_num1 ld bc, -1000 call Int2Dec_num1 jr Int2String_8b Int2String_8: ld de, conv2string ld h, 0 Int2String_8b: ld bc, -100 call Int2Dec_num1 ld c, -10 call Int2Dec_num1 ld c, b call Int2Dec_num1 xor a ld (de), a ret Int2Dec_num1: ld a,'0'-1 Int2Dec_num2: inc a add hl, bc jr c, Int2Dec_num2 sbc hl, bc ld (de), a inc de ret ;----------------------------------------------------------------------- ; 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 ;------------------------------------------------------------- ; 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 rra ; Desplazamos 4 veces >> B2AHex_Num2: or $f0 ; Enmascaramos 11110000 daa ; Ajuste BCD add a, $a0 adc a, $40 ld (de), a ; Guardamos dato inc de ret ;------------------------------------------------------------- ; 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 ;------------------------------------------------------------- ; 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 pstring8nf_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, pstring8nf_noedgex ; No, se puede guardar el valor ld a, (FONT_Y) ; Cogemos coordenada Y cp 23 ; Si ya es 23, no incrementar jr nc, pstring8nf_noedgey ; Si es 23, saltar inc a ; No es 23, cambiar Y ld (FONT_Y), a pstring8nf_noedgey: ld (FONT_Y), a ; Guardamos la coordenada Y xor a ; Y ademas hacemos A = X = 0 pstring8nf_noedgex ld (FONT_X), a ; almacenamos el valor de X jr pstring8nf_loop ret ;------------------------------------------------------------- ; 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 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 ;------------------------------------------------------------- ; Tabla con las direcciones de las 16 rutinas de cambio. Notese ; que la numero 9 queda libre para una posible ampliacion. ;------------------------------------------------------------- FONT_CALL_JUMP_TABLE: DW 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 ;------------------------------------------------------------- ; 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. No ; realiza el borrado en si. ; 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 END 35000