A estas alturas del siglo XXI casi todos los ordenadores personales utilizan modernos entornos gráficos como son Windows o los también conocidos KDE y GNOME en Linux. Estos sistemas pueden representar cualquier imagen a partir de pequeños puntos que pueden ser de uno de los millones de colores soportados. Para aplicaciones más sencillas, como es el caso del entorno de QBasic, se utiliza lo que se denomina Interfaz de texto, que es mucho más fácil de controlar por el ordenador y más que suficiente para determinadas aplicaciones.
En todos los ejemplos que hemos hecho hasta ahora hemos podido comprobar como los resultados se iban presentando en la pantalla de forma secuencial, es decir, unos debajo de otro conforme se iban generando. Cuando se alcanzaba la parte baja de la pantalla todo el contenido subía automáticamente para dejar una nueva línea vacía abajo. Algunas operaciones más "sofisticadas" que hemos llegado a hacer han sido borrar todo usando la instrucción CLS o encolumnar la presentación de algunos listados ajustando los argumentos que le pasamos a la instrucción PRINT. De todas formas los resultados siempre se han visto de color gris sobre fondo negro. Muy triste.
En este tema vamos a ver cómo se puede conseguir escribir exactamente en la posición de la pantalla que queramos, así como en distintos colores de letra y de fondo. También usaremos unos caracteres especiales conocidos como "Semigráficos" para dibujar líneas y recuadros que den más consistencia a nuestras presentaciones.
El cursor es un objeto que se puede mover por la pantalla y su posición indica el sitio exacto dónde se escribirá lo siguiente. En los procesadores de textos o en el propio editor de QBasic, es la "barrita" intermitente por donde van apareciendo las letras que vamos escribiendo en el teclado. En cualquier programa en modo texto el cursor siempre va a existir y va a indicar el lugar dónde se va a escribir lo siguiente que haya que escribir, ya sea porque lo haga el usuario con el teclado o bien el propio programa atendiendo a sus instrucciones de salida.
En los programas de QBasic sólo es visible cuando se pide al usuario que escriba algo usando la instrucción INPUT. El resto del tiempo está ahí en su sitio, pero no lo vemos.
Cuando usamos cualquier instrucción PRINT sin punto y coma al final se escribe lo que sea y el cursor invisible pasa al principio de la siguiente línea a la espera de la siguiente instrucción de escritura. De esta forma todos los resultados se van mostrando uno debajo de otro línea por línea.
La pantalla normal en modo texto que usamos aquí está compuesta por 25 líneas de 80 caracteres de ancho.
La primera línea, la de más arriba es la número 1 y la de abajo es la 25. La columna de más a la izquierda es la 1 y la de más a la derecha, la última, es la 80. Para llevar el cursor a cualquiera de estas posiciones y escribir en la parte de la pantalla que queramos no hay más que usar la siguiente instrucción:
LOCATE linea, columna
De esta forma tan sencilla, usando una instrucción LOCATE delante de cada PRINT o INPUT ya podemos controlar exactamente donde va a salir cada cosa. Vamos con un ejemplo:
CLS LOCATE 22, 30 PRINT "Esto va a salir abajo" LOCATE 3, 35 PRINT "Y esto arriba" LOCATE 12, 1 PRINT "A la izquierda" LOCATE 14, 67 PRINT "A la derecha" LOCATE 13, 37 PRINT "Centro" SLEEP
Y este sería el resultado. El recuadro representa al borde de la pantalla.
Cómo se puede ver, las frases ya no aparecen escritas de arriba a abajo en el mismo orden en que están escritas en el listado del programa. Cada una aparece en el sitio donde la anterior instrucción LOCATE ha llevado el cursor de texto. Para ajustar estas posiciones no hay más que variar los números de fila y columna de las instrucciones LOCATE. La instrucción SLEEP que aparece al final es para que el rótulo "Presione cualquier tecla y continúe." no aparezca hasta que no pulsemos una tecla. Esto será muy común para que no se nos estropeen los diseños de pantalla.
Otra cosa que nos va a estropear los diseños de pantalla va a ser el desplazamiento vertical que hace automáticamente el interfaz en modo texto para que conforme vamos escribiendo lo anterior se desplaza hacia arriba, como ha venido pasando en los programas que hemos hecho hasta ahora.
Esto hace que si escribimos algo en la línea 24, las líneas 1 a 24 suban una posición, desapareciendo lo que haya en la primera línea. Y si escribimos algo en la línea 25, las líneas 1 a 24 subirán 2 posiciones, desapareciendo lo que hubiera escrito en las dos primeras líneas.
La solución más cutre para salvar este problema sería no escribir nunca en las líneas 24 y 25, pero hay otra mejor. Poner un punto y coma al final de todas las instrucciones PRINT o a continuación de la palabra INPUT en las instrucciones de entrada, siempre que estén situadas en una de estas dos últimas líneas. De esta forma evitaremos que al terminar la instrucción el cursor baje y se produzca el desplazamiento vertical automático.
Ahora ya podemos realmente escribir en cualquier parte de la pantalla usando la instrucción LOCATE.
Vamos con un ejemplo que aclare esto del desplazamiento automático.
CLS LOCATE 1, 20: PRINT "Principio" LOCATE 25, 20: PRINT "Final" SLEEP
Si ejecutas este fragmento de código observarás que la palabra PRINCIPIO no aparece en la pantalla, ya que tras escribir en la línea 25 se produce este desplazamiento automático. Para solucionar el problema añadimos un punto y coma al final de la instrucción PRINT conflictiva:
CLS LOCATE 1, 20: PRINT "Principio" LOCATE 25, 20: PRINT "Final"; SLEEP
Y podrás observar como aparecen ambas palabras escritas en la pantalla, una arriba y otra abajo, justamente en las posiciones que hemos especificado. Problema solucionado.
Un último comentario. En los dos fragmentos anteriores has podido observar que las instrucciones LOCATE y PRINT van en la misma línea separadas por el carácter "Dos puntos" (:). Esto es común hacerlo para acortar el listado, ya que estas dos instrucciones casi siempre van a ir por parejas.
Hasta ahora todos nuestros programas han dado los resultados en la pantalla usando letras de color gris claro sobre fondo negro. Para llorar, pero esto va a cambiar ahora mismo. El interfaz en modo texto nos ofrece la posibilidad de usar dieciséis colores de letra y ocho de fondo. No es que sea una maravilla tecnológica comparada con los millones de colores que usan los entornos gráficos actuales, pero para cumplir nuestros objetivos son más que suficientes.
Vamos a ver la paleta de colores predeterminada del modo de pantalla VGA:
Como se puede ver, cada color lleva un asociado un númerito. Este número se conoce como "Atributo de color" y nos va a servir para especificar los colores mediante la siguiente instrucción:
COLOR primerPlano, fondo
Por ejemplo, si queremos escribir con letras amarillas sobre fondo azul (muy típico), no tenemos más que usar una instrucción
COLOR 14, 1
antes de las correspondientes instrucciones PRINT o INPUT.
Al usar una instrucción COLOR, se cambian los colores de la pantalla para sucesivas instrucciones de escritura en pantalla hasta que se vuelva a cambiar usando otra instrucción COLOR. No hace falta poner una instrucción COLOR delante de cada PRINT o INPUT si no vamos a cambiar el color.
Como color de primer plano podemos usar cualquiera de los 16 atributos de color disponibles. Como color de fondo solo los 8 primeros. Si no especificamos color de fondo, se conservará el que hubiera.
El color de fondo en principio sólo afecta al trozo de pantalla que hay por detrás de los caracteres que escribimos. Si queremos colorear toda la pantalla de un determinado color, una forma muy rápida de hacerlo es especificar una instrucción COLOR justo antes de una CLS, por ejemplo:
COLOR 15, 4 CLS
Hará que toda la pantalla se coloree de rojo oscuro. En sucesivas instrucciones PRINT se escribirá lo que sea en color blanco fuerte sobre este rojo mientras no usemos otra instrucción COLOR. Hay que tener cuidado de no usar el mismo color para primer plano y para fondo. Si lo hacemos no pasa nada, nuestro programa va a seguir funcionando perfectamente, pero sería como escribir con lápiz blanco en un papel, no se vería nada de nada.
También podemos conseguir que los caracteres aparezcan en la pantalla parpadeando. Para hacerlo no hay más que sumar 16 al color de primer plano que queramos, por ejemplo:
COLOR 30, 2
Hará que el texto escrito posteriormente aparezca de amarillo parpadeando sobre fondo verde. (14 del amarillo más 16 son 30). No se puede hacer que el fondo parpadee.
Una cosa importante a tener en cuenta con el parpadeo es que NO VA A FUNCIONAR si estamos ejecutando QBasic desde Windows en una ventana. Para que funcione habrá que pasar a pantalla completa pulsando ALT+ENTER o el botón correspondiente de la barra de botones de la ventana, y aún así a la primera tampoco funciona algunas veces, lo que se hace es afectar al color de fondo.
No es conveniente abusar del parpadeo, puede resultar molesto para la vista. Se debe de utilizar sólo para resaltar pequeños mensajes o símbolitos en la pantalla.
Como ejemplo veamos como podría quedar una portada sencilla en colores para un programa de agenda que integre todo lo que vimos en el tema de ficheros.
Para conseguir esto no habría mas que insertar las instrucciones COLOR correspondientes en los lugares adecuados, como se ve aquí:
CLS PRINT COLOR 4 PRINT , , "* * * * * * * * * * * *" PRINT , , "* "; COLOR 10: PRINT "AGENDA SUPER BARATA "; COLOR 4: PRINT "*" PRINT , , "* *" PRINT , , "*"; COLOR 2: PRINT " J.M.G.B. Ronda 2003 "; COLOR 4: PRINT "*" PRINT , , "* * * * * * * * * * * *" PRINT PRINT COLOR 13 PRINT , "A ... Añadir nueva persona" PRINT , "B ... Borrar persona" PRINT , "M ... Modificar persona" PRINT COLOR 5 PRINT , "N ... Buscar persona por nombre" PRINT , "D ... Buscar persona por dirección" PRINT , "T ... Buscar persona por teléfono" PRINT , "E ... Buscar persona por edad" PRINT COLOR 1 PRINT , "L ... Ver listado de personas" PRINT COLOR 9 PRINT , "C ... Compactar base de datos" PRINT COLOR 11 PRINT , "S ... Salir"
Estas son las instrucciones sólo para dibujar la pantalla. El resto para que funcione el menú habría que progrmarlo por ejemplo con la función INKEY$ y un SELECT CASE que según la tecla pulsada llame a cada uno de los módulos del programa.
En el apartado anterior hemos visto cómo conseguir que nuestros programas escriban en la pantalla usando distintos colores. Esto, junto con los semigráficos que veremos en el apartado siguiente, es más que suficiente para hacer que nuestros programas tengan una interfaz en modo texto bastante conseguida.
Observando la paleta VGA de 16 colores se puede comprobar que los colores están un poco "descoloridos". No es que al monitor le pase nada cuando entramos a MS-DOS, es que son los que hay y están definidos así. También nos puede pasar que queramos usar determinados colores, por ejemplo para construir un logotipo, y no nos venga bien ninguno de los que tenemos.
Esto se puede arreglar un poco. El modo de pantalla de texto nos permite usar 16 colores SIMULTÁNEAMENTE, pero estos no tienen porqué ser siempre los mismos. Los podemos cambiar fácilmente por cualquier otro de esta paleta más amplia de 64 colores.
Podemos intercambiar cualquiera de los 16 atributos de color que tenemos disponibles por uno de estos 64 colores usando la siguiente instrucción:
PALETTE original, nuevo
Vamos a ver lo que significa esto. Puede dar lugar a confusiones:
Supongamos que queremos cambiar el atributo 3 (Que originalmente es un azul grisaceo muy feo) por un celeste más bonito que aparece en nuestra paleta con el índice 43. No habría más que hacer:
PALETTE 3, 43
Y a partir de ahora cada vez que usemos la instrucción
COLOR 3
se escribirá con nuestro celeste. El 3 ya no es el azul grisaceo feo.
Podemos intercambiar los colores todas las veces que queramos e incluso asignar valores repetidos a distintos atributos. Lo que hay que tener en cuenta es que sólo vamos a ver en la pantalla 16 colores a la vez, pero estos podrán ser cualquiera de los 64.
Otra cosa que hay que tener en cuenta es que los cambios hechos con la instrucción PALETTE también afectan a todo lo que ya haya escrito en la pantalla del color que hemos cambiado. Imagina que hay escrito algo en color 10 original (Verde fuerte), y ahora asignamos al atributo 10 el color de paleta 51 para seguir escribiendo en verde más suave. Automáticamente todo lo escrito en verde fuerte pasa a ser verde suave. Para poder ver los dos verdes a la vez habría que usar otro atributo y dejar el 10 como estaba. Con un poco de práctica haciendo esto se puede conseguir que determinados textos se enciendan o se apaguen poco a poco (Cambiando los colores por otros cada vez más oscuros o más claros dentro de un bucle), algunos efectos interesantes como ocultar el rótulo "Presione cualquier tecla y continúe".
La instrucción PALETTE no tiene ningún interés para aprender a programar, pero nos puede servir para dar a nuestros programas un toque personal o extraño al utilizar combinaciones de colores que se salen de los 16 tan típicos de la amplia mayoría de programas de MS-DOS. Hay que recordar que como fondo sólo podemos usar los ocho atributos primeros (0 a 7), pero ya podemos conseguir cosas como escribir sobre fondo amarillo o blanco. Pero con cuidado!, que no haya que usar gafas de sol delante del ordenador.
Ya sabemos escribir en colores. Con un poco de idea ya podemos dibujar recuadros aplicando distintos colores de fondo a distintas zonas de la pantalla, pero todavía podemos llegar un poco más allá. Podemos dibujar recuadros con bordes y líneas horizontales, verticales y esquinas usando unos caracteres especiales que nos permiten "ensamblar" las líneas en la pantalla como si se tratara de un puzzle: Los caracteres SEMIGRÁFICOS, casi gráficos.
Estos caracteres no los tenemos en el teclado, y por lo tanto para conseguirlos habrá que recurrir a sus códigos ASCII, que son los siguientes:
Recordemos que para introducir un código ASCII hay que pulsar simultáneamente la tecla alternativa (ALT) y el código correspondiente en el bloque numérico situado a la derecha del teclado.
Para demostrar la utilidad de los caracteres semigráficos vamos a crear una nueva portada para nuestro programa de agenda. Va a ser esta, que usa también colores personalizados.
Como se puede ver, bastante conseguida. Ya no tiene casi nada que envidiarle a la interfaz de un programa comercial de MS-DOS. Lo que hace falta es que todo lo demás también funcione perfectamente y sea útil.
Ahora vamos con el listado del programa necesario para dibujar esto:
PALETTE 0, 32 PALETTE 3, 11 PALETTE 4, 8 PALETTE 5, 17 PALETTE 7, 63 PALETTE 10, 4 PALETTE 11, 52 PALETTE 12, 36 PALETTE 13, 38 PALETTE 14, 54 COLOR 15, 3 CLS COLOR 15, 4 LOCATE 2, 11: PRINT ""; STRING$(57, 205); "" LOCATE 3, 11: PRINT "|"; SPACE$(57); "|" LOCATE 4, 11: PRINT ""; STRING$(57, 205); "" COLOR 14, 4: LOCATE 3, 14 PRINT "A G E N D A S U P E R B A R A T A" COLOR 1, 7 LOCATE 7, 20: PRINT "---------------------------------------" LOCATE 8, 20: PRINT "| A ... |" LOCATE 9, 20: PRINT "| B ... |" LOCATE 10, 20: PRINT "| M ... |" LOCATE 11, 20: PRINT "---------------------------------------" LOCATE 12, 20: PRINT "| N ... |" LOCATE 13, 20: PRINT "| D ... |" LOCATE 14, 20: PRINT "| T ... |" LOCATE 15, 20: PRINT "| E ... |" LOCATE 16, 20: PRINT "---------------------------------------" LOCATE 17, 20: PRINT "| L ... |" LOCATE 18, 20: PRINT "---------------------------------------" LOCATE 19, 20: PRINT "| C ... |" LOCATE 20, 20: PRINT "---------------------------------------" LOCATE 21, 20: PRINT "| S ... |" LOCATE 22, 20: PRINT "---------------------------------------" COLOR 0, 7 LOCATE 8, 29: PRINT "Añadir nueva persona" LOCATE 9, 29: PRINT "Borrar persona" LOCATE 10, 29: PRINT "Modificar persona" COLOR 10 LOCATE 12, 29: PRINT "Buscar persona por nombre" LOCATE 13, 29: PRINT "Buscar persona por dirección" LOCATE 14, 29: PRINT "Buscar persona por teléfono" LOCATE 15, 29: PRINT "Buscar persona por edad" COLOR 12: LOCATE 17, 29: PRINT "Ver listado de personas" COLOR 11: LOCATE 19, 29: PRINT "Compactar base de datos" COLOR 13: LOCATE 21, 29: PRINT "Salir" COLOR 14, 5: LOCATE 25, 1: PRINT SPACE$(80); LOCATE 25, 10: PRINT "Curso de Programaci¢n"; COLOR 13: LOCATE 25, 46: PRINT "J.M.G.B. HECHO EN RONDA"; SLEEP
¿A que asusta? Como se puede ver, ya es un listado bastante largo.
Antes de seguir hay que aclarar un pequeño problema que tiene: En Windows no podemos representar los caracteres semigráficos y los he sustituido por guiones, tuberías y escuadras para tener una idea de dónde va cada cosa. Al copiar este listado a QBasic tendrás que sustituirlos por los correspondientes semigráficos usando la tabla de códigos ASCII. Los del recuadro superior son de línea doble y los de abajo sencillos.
Para empezar a desliar este listado de código tan largo hay que tener en cuenta que es un esquema secuencial. No hay bucles ni operaciones complejas. Así ya se ve bastante más sencillo. Si te lías con los colores redefinidos quita las instrucciones PALETTE y usa solo los colores normales. Así de paso te vas aprendiendo sus 16 códigos, también te servirán para algunos otros lenguajes de programación. Cuando esté terminado redefine los colores que quieras.
Además de los caracteres semigráficos sencillos y dobles que hemos visto aquí, existen otros conocidos como "mixtos" que se pueden usar en las esquinas y en las uniones de líneas horizontales y verticales para ensamblar líneas sencillas y dobles, es lo que se ve en las esquinas y uniones de las líneas que forman este dibujo.
Esto podría resultar interesante, lo que ocurre es que estos caracteres semigráficos mixtos no son muy comunes y no aparecen en todas las tablas de caracteres ASCII. En el caso de que el usuario de nuestro programa esté utilizando una de estas tablas de caracteres extraña, no podrá ver los caracteres estos y nuestro diseño de pantalla quedará roto. Normalmente las esquinas de los recuadros se cambiarán por vocales acentuadas y otros símbolos extraños, algo así como esto:
Como no nos merece la pena correr el riesgo de que nuestros diseños de pantalla queden así de estropeados, lo mejor es evitar el uso de los semigráficos mixtos. Aunque los veamos en nuestra tabla de caracteres ASCII, puede que el usuario del programa no los tenga y no pueda verlo correctamente. Lo mismo ocurre al imprimir si la impresora utiliza una tabla de caracteres ASCII distinta. Recordar que estamos en MS-DOS y no hay fuentes True Type ni nada parecido. Con un poco de imaginación se pueden construir diseños de pantallas más que aceptables usando sólo los semigráficos simples y dobles que ya hemos visto junto con los caracteres de relleno que veremos en el apartado siguiente.
Para terminar con los semigráficos vamos a ver un pequeño algoritmo que usado como un procedimiento nos sirva para dibujar un recuadro en las posiciones de pantalla que nos interesen, algo muy útil.
Lo que hace es sencillo. Dibuja un cuadro con el borde de línea doble con la esquina superior derecha en la posición v,h y la anchura y la altura la obtiene de las variables largo y alto. La primera línea dibuja la parte superior, el bucle FOR dibuja la zona intermedia rellenando lo de dentro con espacios, y la última línea dibuja el borde inferior. Ponemos un punto y coma al final de cada línea para que si dibujamos el recuadro en la parte baja de la pantalla no se produzca el desplazamiento automático y se nos estropee todo el diseño de pantalla.
Este ejemplo se podría ampliar especificando los colores en la llamada a la función o escribiendo algún tipo de barra de título como si fuera una ventana de las del editor de QBasic.
Además de los semigráficos también existen otros caracteres que nos van a ser muy útiles para de diseñar las pantallas de nuestros programas en modo texto. Son los caracteres de relleno, aquí están sus códigos ASCII, porque tampoco los tenemos en el teclado:
Estos caracteres nos van a permitir rellenar zonas enteras de la pantalla para evitar que se vean todo del mismo color. Los más utilizados son los tres primeros que nos ofrecen distinta densidad de puntos. El cuarto rellena todo con el color de primer plano, y los dos últimos se usan sólo para cosas como dar efectos de sombras a recuadros y poco más.
Para usar estos caracteres se suele recurrir a un bucle FOR que recorre la pantalla por filas y dentro dibuja series del carácter correspondiente usando la función STRING$.
Vamos con un ejemplo que va a rellenar con el carácter 177 la mitad izquierda de la pantalla.
FOR v = 1 TO 25 LOCATE v,1: PRINT STRING(40,177); NEXT
Una cosa que aparece al usar grandes cantidades de estos caracteres es el llamado "efecto Moiré" (Muaré), consistente en una serie de lineas curvas que aparecen dibujadas en la pantalla. Se produce por una interferencia entre los puntos que forman estos caracteres de relleno y los píxeles físicos del monitor. Si nuestro monitor nos da ese problema, no se puede evitar, pero sí atenuar usando colores de primer plano y de fondo que no sean demasiado distintos.
Ahora vamos con otro diseño más elaborado que nos ofrece un diseño de fondo de este tipo:
FOR v = 1 TO 25 FOR h = 1 TO 79 STEP 2 LOCATE v, h: PRINT STRING$(2, INT(RND * 3) + 176); NEXT NEXT
Aquí se elige aleatoriamente uno de los tres caracteres disponibles en el momento de dibujarlo. Se han agrupado los caracteres de dos en dos para que salgan cuadros más o menos cuadrados. El siguiente ejemplo es parecido, pero esta vez los cuadros aparecerán ordenados ya que se usa un contador en vez de los números aleatorios.
c = 0 FOR v = 1 TO 25 FOR h = 1 TO 79 STEP 2 c = c + 1 IF c = 3 THEN c = 0 LOCATE v, h: PRINT STRING$(2, 176 + c); NEXT NEXT
El uso de estos caracteres de relleno junto con los recuadros de colores hechos a base de semigráficos es una buena forma de dar a nuestros programas en modo texto una apariencia bastante aceptable.
Si se observa la tabla de códigos ASCII se puede ver que los caracteres que van desde el 0 hasta el 31(El 32 es el espacio en blanco) son símbolos extraños y además no se pueden escribir usando la tecla ALT.
Estos caracteres están asociados a teclas del teclado como Enter, escape, tabulador o retroceso entre otras y a ordenes especiales para el ordenador y la impresora como son saltos de página y de línea, fin de fichero, toque de timbre, etc.
Estos caracteres no están pensados para ser dibujados en la pantalla ni para ser impresos. Tienen asociados esos símbolos porque alguno tenían que tener, pero ya que los tenemos ahí puede ser que en algunos casos queramos escribirlos en la pantalla. Vamos con sus códigos ASCII...
Y ahora vamos a ver como escribirlos. (Solo en QBasic y en los programas de MS-DOS. En Windows no se puede)
Hay dos formas. La primera sería usar la función CHR$, por ejemplo para dibujar un corazón bastaría con poner PRINT CHR$(4). La segunda, más cómoda es pulsar la combinación de teclas CONTROL + P y después, a continuación ALTERNATIVA + el código en el teclado numérico, por ejemplo para dibujar el corazón habría que pulsar CTRL+P y ALT+4 con lo que este símbolo quedaría directamente dibujado en la pantalla.
Esto de CTRL+P nos vale para dibujar estos caracteres especiales en la mayoría de programas de MS-DOS así como en el propio intérprete de comandos (Símbolo C:\>).
Hasta aquí muy bien. Ya podemos dibujar caras, flechas y otros símbolos en nuestras pantallas, pero no podemos olvidar que estos caracteres son especiales y hay que tener unas ciertas precauciones. La primera es que si un símbolo nos da algun problema como que se nos descoloquen los demás, pues directamente evitar usarlo y nada más. Otras precaucione son no usar los símbolos que no llevan asociado ningún carácter como son el de código ASCII 0 y tener en cuenta que cada vez que nuestro programa dibuje un ASCII 7 se oirá un pitido en el altavoz interno o bien sonará el sonido predeterminado de Windows.
Estos caracteres los usaremos exclusivamente en instrucciones PRINT y no deberemos almacenarlos en ficheros, especialmente en ficheros secuenciales . Si los intentaremos imprimir van a provocar fallos en la impresora. De hecho si intentas imprimir tal cual está la tabla de caracteres ASCII que viene en la ayuda de QBasic y que incluyes estos símbolos observarás cosas como alguna línea se rompe o incluso que se hace un salto de página y un trozo de la tabla se imprime en la siguiente hoja. Esto se debe a que se han encontrado caracteres de saltos de línea y de página que la impresora ha interpretado como lo que son.
También hay que tener precaución si estos caracteres aparecen de forma literal en las instrucciones del código fuente del programa. Si imprimes dicho código puedes encontrarte con problemas similares cada vez que salga uno de estos caracteres. Por lo tanto si piensas imprimir el código fuente del programa utiliza funciones CHR$ en lugar de los caracteres literales. También hay que saber que estos caracteres no se pueden ver en Windows, por lo que si abres el fichero BAS del código de tu programa en un editor de Windows como por ejemplo el bloc de notas, directamente no los verás o los verás marcados como un cuadro negro.
Para enriquecer un poco más las pantallas de nuestros programas en modo texto podemos usar la forma que tienen los propios caracteres para hacer pequeños dibujos.
Lo más sencillo de esto es lo que se conoce como esmáilis (Correctamente se escribe smiley) y que estamos acostumbrados a utilizar en los foros y chats de Internet. Algunos de los más comunes y de significado conocido son los siguientes:
:-) :-( :-D :-o X-D
Se pueden encontrar listados muy extensos llenos de estos símbolitos junto con su significado, pero de todas formas puede que estos esmáilis sean muy poca cosa para decorar nuestros programas. Por eso podemos recurrir a diseños más complicados conocidos como ASCII-ART. Vamos con unos ejemplos...
__
/ /\
/ / \
/ / /\ \
/ / /\ \ \
/ /_/__\ \ \
/________\ \ \
\___________\/
1111111111111111111111111111 1110000001111111111000000111 1100000000011111100000000011 1100000000001111000000000011 1100000000000110000000000011 1100000000000000000000000011 1110000000000000000000000111 1111000000000000000000001111 1111100000000000000000011111 1111111000000000000001111111 1111111110000000000111111111 1111111111000000001111111111 1111111111100000011111111111 1111111111110000111111111111 1111111111111001111111111111 1111111111111111111111111111
./ | _________________
/ / / __________ //\_
/' / | (__________) ||.' `-.________________________
/ / | __________ ||`._.-'~~~~~~~~~~~~~~~~~~~~~~~~`
/ \ \__(__________)__\\/
| `\
| | ___________________
| |___________________...-------'''- - - =- - = - = `.
/| | \- = = - -= - = - =- = - =|
( | | |= -= - = - = - = - =--= = - = =|
\| |___________________/- = - -= =_- =_-=_- -=_=-=_=_= -|
| | ```-------...___________________.'
|________|
\ / _
| | ,,,,,,, /=\
,-' `-, /\___________ (\\\\\\\||=|
| | \/~~~~~~~~~~~` ^^^^^^^ \=/
`--------' `
Podemos encontrar montones de ellos o atrevernos nosotros mismos a dibujar los nuestros (Por ejemplo un logotipo).
Desde el punto de vista de la programación lo único que hay que tener en cuenta es que hay que dibujarlos línea por línea usando una instrucción PRINT para cada una, y que en muchos casos no podemos olvidar incluir espacios a la izquierda de determinadas líneas para que el dibujo no se estropee. Por ejemplo, para dibujar la primera de las anteriores figuras habría que hacer...
PRINT " __" PRINT " / /\" PRINT " / / \" PRINT " / / /\ \" PRINT " / / /\ \ \" PRINT " / /_/__\ \ \" PRINT "/________\ \ \" PRINT "\___________\/"
Estos dibujos fueron concebidos inicialmente para ser impresos en impresoras antiguas que no soportaban la impresión de gráficos, por lo que en principio es suficiente con que sean en blanco y negro, pero también nos podemos molestar en ponerlos de varios colores dibujándolos con distintas instrucciones PRINT.
También podemos construir grandes letras para dibujar los títulos y rótulos de nuestros programas, por ejemplo...
_ ___ ___ ___ ___ ___ ___ _ _ ___ _ _ ___ __ __ _ _ /\/| ___ /_\ | _ )/ __| \| __| __/ __| || |_ _| | | |/ / | | \/ | \| ||/\/ / _ \ / _ \| _ \ (__| |) | _|| _| (_ | __ || | || | ' <| |__| |\/| | .` | \| | (_) | /_/ \_\___/\___|___/|___|_| \___|_||_|___\__/|_|\_\____|_| |_|_|\_|_|\_|\___/ ___ ___ ___ ___ _____ _ ___ ____ ____ ____ ______ | _ \/ _ \| _ \/ __|_ _| | | \ \ / /\ \ / /\ \/ /\ \ / /_ / | _/ (_) | /\__ \ | | | |_| |\ V / \ \/\/ / > < \ V / / / |_| \__\_\_|_\|___/ |_| \___/ \_/ \_/\_/ /_/\_\ |_| /___|
Estas letras están construidas usando principalmente barras y símbolos de subrayado. También es común construirlas usando los caracteres semigráficos o el símbolo # repetido (Esto último es lo que hace la instrucción banner de Linux).
Para dibujar un rótulo con las letras anteriores podemos hacerlo de forma literal con cuatro instrucciones PRINT (Una por cada línea) y los trozos de letras entre comillas...
PRINT " _ _ ___ ___ _ _ ___ ___ _ _ ___ ___ _ _ ___ _" PRINT "| || || __|/ __|| || |/ _ \ | __|| \| | | _ \/ _ \| \| || \ /_\" PRINT "| __ || _|| (__|| __ | (_) | | _||| .` | | / (_) | .` || |) |/ _ \" PRINT "|_||_||___|\___||_||_|\___/ |___||_|\_| \_|_\\___/|_|\_||___//_/ \_\"
Pero ya que estamos programando, lo más cómodo sería tener un procedimiento que nos dibujara el rótulo que queramos en la posición que le digamos solo con hacer una llamada del tipo...
DibujaRotulo "Hecho en Ronda", 5, 10
Habría que construir un programa con muchas instrucciones Mid$ que vaya construyendo las letras línea por línea. Se puede encontrar en la sección de programas terminados de esta web.
