Tutorial de BASIC: "Crea tu propia aventura"
Este tutorial sencillo te presenta generalidades del lenguaje de programacion BASIC para realizar un microprograma HISTORIA.BAS. Con ello podras realizar un juego de aventura de texto sencillo. Utilizaras uno de nuestros interpretes de BASIC.
Introduccion
¿Alguna vez has leido uno de esos libros de cuentos de "Sigue tu propia aventura"? En ellos leias algunos parrafos y luego debias tomar una decision por el personaje principal. Luego pasas a otra pagina del libro y continuabas la historia. Podias interactuar asi con las aventuras predeterminadas que podia Seguir el personaje. Este tipo de libros son divertidos, y lo que es aun mas divertido aun es escribir tu propio relato y tu propio programa de BASIC capaz de "darle vida".
Propuesta
El microprograma historia.bas que abordaremos en este tutorial presentan una pantalla el relato, y te solicitara que tomes la decision. Tu decision hara que aparezca una segunda pantalla con la continuacion de relato de la historia. En el camino, aprenderemos algunas ordenes y declaraciones de BASIC; veras como se toman las decisiones en un programa de computadora y como la ejecucion saltar dentro de un programa.
¡A programar!
Para iniciar, abre el interprete en tu terminal. Podras utilizar bwbasic. Introduce el comando:
bwbasic
Para comenzar podrias tipear estas primeras veintiocho lineas del codigo BASIC exactamente como estan escritas en tu interprete de BASIC (por ejemplo, BwBASIC)... ¡pero esto es engorroso! Simplemente copia y pega. Asegurese de presionar Intro despues de cada linea.
Si deseas teclear el codigo BASIC, te doy una ayuda para ahorrar tiempo: luego de escribir la linea 70 y presionar Intro, puedes mover el cursor hacia atras hasta el numero de linea, cambiarlo a 80 y presionar Intro nuevamente. Esto ahorra mucho escribir. Ingresa el comando LIST con frecuencia para verificar tu progreso.
Primera parte del codigo fuente en BASIC
10 REM *************************************************************
20 REM * HISTORIA *
30 REM * "Crea tu propio destino" - Una historia arbolada *
40 REM *************************************************************
50 CLS
60 PRINT "**********************************************************"
70 PRINT "* *"
80 PRINT "* *"
90 PRINT "* *"
100 PRINT "* Esta es la primer pantalla de tu historia *"
110 PRINT "* *"
120 PRINT "* *"
130 PRINT "* *"
140 PRINT "* *"
150 PRINT "* *"
160 PRINT "* *"
170 PRINT "* *"
180 PRINT "* Elije: *"
190 PRINT "* *"
200 PRINT "* 1 - Quiero seguir un destino *"
210 PRINT "* 2 - Quiero buscar otro destino *"
220 PRINT "* *"
230 PRINT "* *"
240 PRINT "* *"
250 PRINT "* *"
260 PRINT "**********************************************************"
270 INPUT OPCION%
280 IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
Comentarios
Observa las lineas 10 a 40. REM
es una declaracion de
BASIC que no hace nada, significa "comentario". El proposito de
REM
es agregarle comentarios al programa. Estos comentarios
ayudan al programador a comprender como funciona el programa. Las
palabras a continuacion de REM
no se imprimen en pantalla
durante la ejecucion. Solo son visibles listando el codigo fuente.
Los comentarios son importantes. Cuando termines de escribir tu programa, probablemente comprendas todo de el. Sin embargo, transcurridos unas semanas te resultara irreconocible Los comentarios ayudan. A diferencia de la era del BASIC de Darthmouth, hoy la memoria es practicamente gratuita! Por lo tanto ¡Usa
REM
generosamente!
El pequeno rectangulo hecho de asteriscos se llamaba caja de flores. Se acostumbraba colocar el nombre del programa, en este caso, HISTORIA, junto con una breve descripcion del cometido del programa. Generealmente la caja de flores solia tener 40 caracteres de ancho. De hecho, algunos programas contenian mas comentarios que describen el programa que lineas de instrucciones de BASIC a interpretar. Los asteriscos no tienen relevancia alguna en este caso. Podras utilizar cualquier caracter. El proposito es unicamente proporcionar un atractivo cartelon informativo.
Variables
La linea 270 es una instruccion INPUT.
INPUT
detiene el programa y espera la entrada del teclado.
Lo ingresado con el teclado, en la linea 270, se almacenara en una
variable denominada OPCION%
. Dado que las
variables juegan rol importante en la programacion, debemos examinarlas
en detalle.
Nombres de Variables
Los nombres de variables deben crearse de acuerdo con ciertas reglas
en BASIC. Por ejemplo, los nombres de variables deben comenzar con una
letra del alfabeto y no puede tener mas de cuarenta caracteres. El
nombre puede incluir numeros. Estas son las reglas de BASIC, y no son
muy estrictas. ¡Pero es igual de importante inventar nombres de
variables que sean significativos para los seres humanos! Despues de
todo, BASIC funciona igual de bien con una variable llamada
TKBRYIOPESFG%
que con una llamada OPCION%
.
Pero, ¿cual crees que seria mas facil de entender?
La eleccion de los nombres de las variables es importante ya que un
programa puede tener muchas de ellas. Si usas nombres son confusos,
podrias confundir accidentalmente una variable con otra. Por demas,
resiste la tentacion de inventar nombres de variables lindos e
ingeniosos. Nombres como RENGO$
y PORDIOSERA$
son divertidos de imaginar pero dificiles para seguir. Un buen programa
debe ser facil de entender, por lo cual emplea nombres de variables
obvios. NOMBRE$
no puede sonar muy epico, pero al menos es
evidente que datos incorpora.
Ciertas palabras no se pueden utilizar como nombres de variables.
Estas se llaman PALABRAS RESERVADAS e incluyen todos los comandos de
BASIC. Por ejemplo, sabemos que PRINT
y CLS
son instrucciones de BASIC. Por lo tanto, no podras utilizarlos tambien
como nombres de variables ya que confundirian al interprete
computarizado. La lista de palabras reservadas es bastante larga. Entre
estas palabras se incluyen palabras como NAME
y
PRINT
. Si bien no es posible duplicar exactamente estas
palabras como nombres de variables, puede usar nombres que incluyan la
palabra reservada, por ejemplo NAMES
o
PRINTER
, que podrian utilizarse perfectamente.
Aunque BASIC consta de una larga lista de palabras reservadas para el
idioma ingles, es probable casi ninguna sea molesta en castellano. La
mayoria son declaraciones bastante extranas que no serian muy utiles
como nombres de variables. Cuando utilices una palabra reservada como
nombre de variable, BASIC emitira su inefable error de sintaxis
"SYNTAX ERROR". A menudo, este tipo de errores son
desconcertantes. La linea de BASIC podria parecer correcta en todos los
sentidos. BASIC ni siquiera insinua que has utilizado una palabra
reservada. BASIC solo entiende que tu programa ha estipulado un comando
BASIC incorrectamente. Prueba un programa con la declaracion
INPUT DATE$
para comprender como se ve este error.
Aqui hay una lista de las reglas para tu nombre de variable:
- No uses mas de 40 caracteres.
- El nombre de variable debe comenzar con una letra.
- El nombre de variable puede contener letras y numeros.
- Un nombre de variable no puede contener espacios.
- El nombre no puede ser un comando de BASIC.
Tipos de Variable
Compara la declaracion INPUT
en la linea 270 con la
declaracion INPUT
del capitulo uno. Observe los nombres de
las variables utilizadas en cada programa. En el primer programa usamos
el nombre QUIEN$. En la linea 270 tenemos OPCION%
. Ambos
nombres son variables. Sin embargo, son diferentes. QUIEN$
y OPCION%
son ejemplos de dos tipos diferentes de
variables utilizadas en BASIC.
Anteriormente definimos un nombre de variable como un casilla de
correo. Disponiamos de varios tipos de buzones. Dos numeros de espera.
El otro tiene caracteres y numeros. Por lo tanto, cuando se define una
variable, debes decidir que tipo de buzon sera. El tipo de variable esta
determinado por el ultimo caracter del nombre de la variable. Esto
explica la diferencia entre QUIEN$
y
OPCION%
.
Un nombre de variable terminado con signo de porcentaje
(%
) se denomina variable entera. Este tipo
de variable solo puede contener numeros enteros. Esto significa que
OPCION%
solo puede contener numeros tales como 2, 45, 611 o
10451. No puede contener numeros fraccionales como 2,5 o 25,75. Por lo
tanto, al programar con la instruccion INPUT OPCION%
, el
usuario solo podra ingresar un numero entero. Si ingresase letras, BASIC
emitiria el mensaje:
?Redo from start
...y el programa no continuaria sino hasta que ingresase numeros
enteros. Por otro lado, si el usuario ingresa un numero que no es
entero, BASIC lo redondeara al entero mas cercano. Por ejemplo, si se
ingresa 23.6
al pedido de OPCION%
, BASIC
asignara 24
a dicha variable, sin emitir mensaje de error
alguno. Las variables enteras no pueden contener numeros no mayores de
32.767
ni menores de -32.768
.
Para explorar como BASIC maneja las variables enteras, intente ingresarle a la variable varios numeros, tanto enteros como fraccionales, asi como con letras. a este sencillo programa:
10 PRINT "Ingresa algo:"
20 INPUT OPCION%
30 PRINT OPCION%
Un segundo tipo de variable se denomina Variable de
Precision, y van terminadas en un signo de exclamacion (!).
Estas puede contener numeros fraccionarios como 35,9
o
3,14159
, asi como numeros enteros. Podra contener casi
cualquier valor que necesitemos en nuestros programas. Dado que la
variable de precision puede contener numeros enteros al igual que las
variables enteras, cabria preguntarse para que usariamos las variables
enteras... nomas para molestar. Pero existen dos razones. En primer
lugar, los programas escritos con variables enteras se interpretaban mas
velozmente que aquellos que utilizaban variables de precision simple. En
segundo lugar, es mas facil escribir un programa que utilice unicamente
numeros enteros. Esto se hara evidente a medida que aprendamos mas sobre
la programacion.
Sigue esta regla: usa variables enteras toda vez que puedas. Usa variables de precision solo cuando debas.
El ultimo tipo de variable que exploraremos es la Variable de
Cadena (STRING). El nombre de una variable de cadena termina
con un signo peso ($
). QUIEN$
es una variable
de cadena. Estas variables de cadena contienen caracteres en lugar de
numeros. Una sola variable de cadena puede contener hasta 255
caracteres. Estos caracteres pueden ser cualquiera de caracteres
alfanumericos, incluidos espacios y numeros (sin incluir letras
acentuadas ni enes).
He aqui una pequena posibilidad de confusion que debes atender.
Los caracteres pueden ser cifras, no numericas. Considera la
diferencia entre numerales y numeros. El numeral romano V
,
la palabra cinco
y el numero 5
representan el
mismo numero. Solo se diferencian en la manara de escribirlo. Cada vez
que almacenas un numero como una variable de cadena,
sera solo un NOMBRE para dicho numero. Esto sera
importante al hacer aritmetica con variables. Podrias tomar dos
variables enteras, por ejemplo, y sumarlas. Si intentases esto con
variables de cadena, BASIC emitira un mensaje de error. BASIC esta
imposibilitado de hacer aritmetica con variables de cadena incluso si
estas variables contienen nombres de numeros.
Suena mas complicado de lo que es en realidad.
Recuerda: si necesita una variable que contenga caracteres, use una variable de cadena. Si, en cambio, necesita realizar un calculo, usa un numero entero o una sola variable de precision.
IF - THEN - ELSE
En la linea 280 llegamos finalmente al verdadero poder de la
programacion: la capacidad de tomar decisiones. BASIC usa la declaracion
IF
-THEN
-ELSE
para tomar
decisiones e incluso cambiar la forma en que se ejecuta el programa
dependiendo de ciertas condiciones. Como el resultado depende de las
condiciones, la instruccion IF
se denomina instruccion
condicional. Observa la linea 280 y comparala con las lineas que se
enumeradas anteriormente. En todos los casos, BASIC ejecutara lo
ordenado por la instruccion. Pero al dar con la linea 280, BASIC
evaluara la variable entera OPCION%
para determinar si
contiene el numero dos. Si la tiene, ocurrira un resultado. Si no es
asi, realizara otra accion.
La declaracion IF
consta de tres partes:
IF condicion THEN alternativa1 ELSE alteranativa2
Las tres partes son la condicion, la alternativa1 y
la alternativa2. La condicion es una relacion que BASIC evalua
para determinar su validez. En la linea 280, la evaluacion condicional
delimita si OPCION%
es igual a 2
. La
alternativa1 y la alternativa2 son las dos opciones
que BASIC puede correr. Si la condicion es verdadera, entonces ejecutara
la alternativa1. Si la condicion no es verdadera, entonces se
ejecuta la alternativa2. En otras palabras, si el usuario de
nuestro programa HISTORIA ingresa 2
como respuesta a la
linea 270, entonces la condicion sera verdadera y se ejecuta
GOTO 600
para ir a la linea 600. Si la persona ingresa algo
que no sea un 2
, se ejecutara GOTO 300.
Ambas alternativas enumeradas dentro de la declaracion
IF
podrian ser cualquier comando BASIC ordinario. En este
caso, ambas son instrucciones GOTO
. Podrian ser facilmente
comandos PRINT
o CLS
. Por ejemplo:
280 IF OPCION% = 2 THEN CLS ELSE PRINT "Ok! Perfecto!"
En nuestro ejemplo, OPCION%
es una variable entera.
Tambien es posible utilizar los otros tipos de variables. ¡Podriamos
cambiar OPCION%
a OPCION
! y todavia ver si es
igual a 2
. Tambien podriamos probar las variables de
cadena.
280 IF QUIEN$ = "Laura" THEN PRINT "Hola" ELSE PRINT "Quien eres tu?"
Observa que la cadena de caracteres Laura
esta entre
comillas. Las comillas instruyen a BASIC que use los caracteres
exactamente tal como los has escrito. Si Laura
no estuviera
entre comillas, BASIC intentaria usarla como un nombre de
variable. Al ejecutar el programa, la persona en el teclado no debe
que ingresar comillas.
las computadoras solo cumplen exactamente lo que les instruye que hagan.
Si corres la linea anterior de BASIC e ingresas laura
o
LAURA
en lugar de Laura
¡el programa no sabria
quien eres e indicaria:
Quien eres tu?
Para el interprete de BASIC, LAURA
no es lo mismo que
Laura
. Una variable de cadena entrecomilladas indica que
debe cumplirse exactamente tal cual el contenido proporcionado de
la variable: deben ser iguales todas las letras, las mayusculas, y la
cantidad de eventuales espacios en caso que los hubiese. Esto puede ser
desafiante para los programadores.
La ultima parte de la instruccion
IF
-THEN
-ELSE
no siempre es
necesaria. El ELSE
puede omitirse junto con la segunda
alternativa. Esto nos dejaria con un tren de instrucciones mucho mas
sencillo: IF
-THEN
. Podrias escribir la linea
280 como:
280 IF OPCION% = 2 THEN GOTO 600
Si OPCION%
no es igual a 2
, entonces no se
ejecutaria alternativa1. En cambio, BASIC continuaria con la
siguiente linea despues de la 280. Si esa linea fuese la linea 300, ¡las
dos declaraciones IF
producirian el mismo resultado! Por lo
tanto, cada declaracion IF
tiene un ELSE
incluso si ELSE
forma parte de la instruccion.
En todos nuestros ejemplos hasta ahora, hemos probado para ver si una variable es igual a algun valor. Podras utilizar otras comprobaciones. Usar todas las comparaciones aritmeticas ordinarias, incluyendo mayor que, menor que o no igual. Estos operadores se escriben de la siguiente manera:
= Igual a
< Menor que
> Mayor que
<= Igual o menor que
=> Igual o Mayor que
<> No igual a
Con la excepcion del ultimo, todos los operadores deberias estar
familiarizado con estos operadores. Al utilizar operadores en BASIC los
operadores que constan de mas de un (como=>
) deben
escribirse sin espacio entre los dos caracteres. He aqui algunos
ejemplos de declaraciones IF
-THEN
. Revise cada
una para verificar su comprension.
280 IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
290 IF OPCION% <> 2 THEN GOTO 300 ELSE GOTO 600
300 IF ADIVINADO% = NUMERO% THEN GOTO 140
310 IF ADIVINADO% > NUMERO% THEN PRINT "Muy alto"
320 IF ADIVINADO% < NUMERO% THEN PRINT "Muy bajo"
330 IF SUB! <= 0 THEN GOTO 500
340 IF SUB! => 4 THEN GOTO 500
350 IF RESPUESTA$ = "s" THEN RESPUESTA$ = "S"
360 IF CANTIDAD% - SUB% < 1 THEN GOTO 600
370 IF X% = 2 THEN DOS% = DOS% + 1
Estas instrucciones no constituyen un programa real. No te molestes en ingresarlos en el interprete de BASIC. Solo son ejemplos. Hablemos de algunos. La linea 290 anterior es una forma distinta de escribir la linea 280 del programa HISTORIA. Ten en cuenta que producira exactamente el mismo efecto. Compara ambas.
¡En la linea 300, comparamos dos variables! Ademas, ten en cuenta que
la linea 300 no usa una instruccion ELSE
. La linea 300 y el
resto de los ejemplos resultan ser declaraciones simples de
IF
-THEN
. La linea 310 preguntara si el numero
contenido en ADIVINA%
es mayor que el numero contenido en
NUMERO%
. La linea 320 prueba si ADIVINA%
es
menor que NUMERO%
.
Las lineas 330 y 340 usan menor o igual que y mayor o igual que.
La linea 350 es interesante. Esto verifica lo que se contiene dentro
de la variable de cadena RESPUESTA$
. Si es una
"s
" minuscula, el programa la cambia a una "S
"
mayuscula dentro de la variable. Recuerde que primero se prueba la
condicion y luego, solo si es verdadera, se ejecutara la
alternativa1. Esta es la razon por la cual el mismo nombre de
variable, RESPUESTA$
, puede usarse en la prueba condicional
y luego cambiarse en la alternativa.
la Linea 360 es un ejemplo avanzado. BASIC resta SUB% de CANTIDAD% y
luego verifica si este numero es menor a 1
. Solo considere
este ejemplo como uno de los usos mas poderosos de la instruccion
IF
-THEN
.
GOTO
Cuando observamos por primera vez la sentencia
IF
-THEN
-ELSE
en la linea 280 de
nuestro programa HISTORIA, vimos que tanto la alternativa1 como
la alternativa2 usaban sentencias GOTO.
Afortunadamente, GOTO
es mucho mas simple que
IF
-THEN
-ELSE
. Cuando se ejecuta
un programa, el interprete BASIC generalmente ejecuta declaraciones en
orden de numero de linea recibido. Sin embargo, cuando se descubre un
GOTO
, la ejecucion se desplazara a cualquier numero de
linea que este escrito como predicado de la instruccion
GOTO
. La linea 280 contiene dos comandos
GOTO
.
280 IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
Si OPCION%
es 2
, la siguiente linea a
ejecutar sera la linea 600. Si OPCION%
no es
2
, la siguiente linea a ejecutar sera la linea 300.
El comando GOTO
cobra gran utilidad dentro de una
instruccion IF
-THEN
. Tambien se puede usar un
solo GOTO
. Para comprender como funciona esta declaracion,
experimenta con el siguiente programa:
10 PRINT "Esta es la linea 10"
20 GOTO 50
30 PRINT "Esta es la linea 30"
40 GOTO 70
50 PRINT "Esta es la linea 50"
60 GOTO 30
70 END
GOTO te da la posibilidad de trampolinear dentro del programa.
Cuando el programita corra, se ejecutara siguiendo este orden:
10 PRINT "Esta es la linea 10"
20 GOTO 50
50 PRINT "Esta es la linea 50"
60 GOTO 30
30 PRINT "Esta es la linea 30"
40 GOTO 70
70 END
Si has cometido un error al ingresar este programa, es posible que haya dado con algo llamado bucle ("loop"). Se produce un bucle cuando el programa no termina nunca. Examina este programa:
10 PRINT "Hola Humanoide!"
20 GOTO 10
La linea 10 se ejecutara una y otra vez. De hecho, debe presionar las teclas CTRL-c para interrumpir la interpretacion y ejecucion del programa. En este ejemplo, el motivo del bucle es evidente. La linea 20 le pide a BASIC que ejecute la linea 10. Luego, BASIC ejecuta la linea 20 nuevamente. BASIC no sabe que ya ejecuto la linea 20. Recuerda: "El ordenador cumplira las ordenes que le han dado". ¡Asegurate de correr tu propio codigo!. Usa software libre.
Desafortunadamente, la causa de los bucles no siempre es tan evidente
como en este ultimo ejemplo. Es comun usar muchas secuencias
GOTO
en programas largos, y esto puede hacer dificil ver el
sentido del bucle. Por este motivo, trate de evitar el uso de
GOTO
. Piensa detenidamente en tu programa y planificalo de
manera que se use un GOTO
solo cuando es absolutamente
necesario.
Los programas que utilizaban muchas instrucciones
GOTO
recibian el apodo de CODIGO ESPAGUETI. ¡Dilucidar codigo espagueti era como seguir un fideo en un plato!
Logica del Programa
Con las declaraciones IF
-THEN
y
GOTO
, introdujimos la capacidad de tomar decisiones y
saltar a distintos sectores del programa BASIC. ¡Son capacidades
poderosas!. Aunque el ordenador ejecute una linea tras otra, sabemos
entonces que es muy posible las estas declaraciones no necesariamente se
ejecuten en el orden estipulado por numero de linea. Por tal motivo
debes esforzarte en pensar en la logica de los programas. Esta es
la parte donde se requiere un pensamiento preclaro.
Considere la linea 280 una vez mas:
280 IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
En las instrucciones PRINT
de las lineas 200 y 210, le
pedimos al usuario de HISTORIA que ingrese un 1 o un 2. Pero en la linea
280 solo verificamos si ingresaron un 2. ¿Por que sucede esto?
La razon es simple ¡Rebeldia humana! El hecho de que hayas pedido un
1 o un 2 no significa que alguien vayan a ingresar necesariamente un
1
o un 2
. ¿Que sucederia si ingresa un cero o
un tres? ¿O un insulto enjundioso? Sin embargo, estamos protegidos
porque construimos nuestro programa para manejar cualquier respuesta. En
este caso, la respuesta 1 es la opcion predeterminada. Si simplemente
presionan la tecla Intro, o ingresan cualquier numero
que no sea 2, se desplazara a la linea 300. El valor predeterminado es
lo que sucede cuando el usuario no toma una decision.
Cuando escribas tus declaraciones IF
-THEN
y
GOTO
, siempre planifica para recibir cualquier entrada.
Imagina lo peor y desconfia de los humanos. Si pide un 1
,
2
o 3
, puedes estar seguro de que alguien
probara introducir un 4
. Si no desea planificar una opcion
predeterminada, podrias escribir una declaracion
IF
-THEN
que intercepte las respuestas
indeseadas a OPCION%
y simplemente vuelva a interrogar
nuevamente. Podriamos, por ejemplo, escribir:
280 IF OPCION% = 2 THEN GOTO 600
281 IF OPCION% = 1 THEN GOTO 300
282 IF OPCION% < 1 THEN GOTO 50
283 IF OPCION% >> 2 THEN GOTO 50
No hay nada de malo en usar estas lineas adicionales en el programa HISTORIA. Es cuestion de gustos. La linea original 280 gestiona todas las respuestas posibles usando una unica linea de codigo BASIC. La solucion anterior usa cuatro lineas su proposito no resulta tan claro como el original. Sin embargo, puedes hacer tu voluntad.
Ten en cuenta las reglas de diseno Unix. Escribir programas comprensibles.
Al planificar tus programas, no solo debe tener cuidado con los
humanos, sino que tambien debe pensar como una computadora. Tal como has
visto, tu ordenador hara lo que le digan que haga. ¡Creeme! Normalmente
no sera esto lo que quieres que haga! Como humano, es facil entender que
"Leonardo
" es practicamente lo mismo que
"leonardo
". Pero la computadora no es practica.
Considere este ejemplo:
280 IF OPCION% < 1 THEN GOTO 500
290 IF OPCION% > 1 THEN GOTO 700
Podriamos creer que estamos comprobando si alguien esta haciendo
trampa en una instruccion INPUT
. Pero, ¿que sucederia si
alguien ingresa un 1
? ¿La computadora esta haciendo lo que
le pedimos? Ciertamente. ¿Esta haciendo lo que deseamos? Ahora no es tan
clara la respuesta... ¡Depende!.
Cada vez que tu programa se comporte mal, podria ser util revisar cuidadosamente cada declaracion siguiendo su orden de ejecucion.
Se utilizaba tabular los nombres de las variables en un bloc de notas y realizar un seguimiento de lo que debian contener mientras ejecuta el programa paso a paso. A esto se llamaba "ejecucion in mente".
El resto del programa
Este tutorial comenzo con la promesa de un programa que contaria una historia y te permitiria crear tu propio final. Ahora que has explorado estos comandos BASIC utilizados en las primeras veintiocho lineas, es hora de ingresar al resto del programa.
Al ingresarlo, intente escribir una historia simplona. Observe que muchas lineas son identicas o muy parecidas. Por ejemplo, las lineas 60, 260, 320 y 520 son iguales. Despues de presionar Intro para ingresar en linea 60, simplemente movias el cursor hacia arriba, cambiabas el numero de linea y presionabas Intro de nuevo. Se utiliza el comando LIST para comprobar el listado.
300 REM ***** PANTALLA 1A *****
310 CLS
320 PRINT "**********************************************************"
330 PRINT "* *"
340 PRINT "* *"
350 PRINT "* *"
360 PRINT "* Esta es la pantalla 1A de tu historia *"
370 PRINT "* *"
380 PRINT "* *"
390 PRINT "* *"
400 PRINT "* *"
410 PRINT "* *"
420 PRINT "* *"
430 PRINT "* *"
440 PRINT "* Elije otro: *"
450 PRINT "* *"
460 PRINT "* 1 - Quiero seguir un destino *"
470 PRINT "* 2 - Quiero buscar otro destino *"
480 PRINT "* *"
490 PRINT "* *"
500 PRINT "* *"
510 PRINT "* *"
520 PRINT "**********************************************************"
530 INPUT OPCION%
540 IF OPCION% = 2 THEN GOTO 900 ELSE GOTO 1200
600 REM ***** PANTALLA 1B *****
610 CLS
620 PRINT "**********************************************************"
630 PRINT "* *"
640 PRINT "* *"
650 PRINT "* *"
660 PRINT "* Esta es la pantalla 1B de tu historia *"
670 PRINT "* *"
680 PRINT "* *"
690 PRINT "* *"
700 PRINT "* *"
710 PRINT "* *"
720 PRINT "* *"
730 PRINT "* *"
740 PRINT "* Elije otro mas: *"
750 PRINT "* *"
760 PRINT "* 1 - Quiero seguir un destino *"
770 PRINT "* 2 - Quiero buscar otro destino *"
780 PRINT "* *"
790 PRINT "* *"
800 PRINT "* *"
810 PRINT "* *"
820 PRINT "**********************************************************"
830 INPUT OPCION%
840 IF OPCION% = 2 THEN GOTO 1500 ELSE GOTO 1800
900 END
1200 END
1500 END
1800 END
Por fin, podemos ver a donde nos llevaran las declaraciones GOTO 300
y GOTO 600. Marca cada IF
-THEN
y
GOTO
para asegurarse de que comprendes como funciona el
programa. Podria ser util Un diagrama arbolado. Ten en cuenta que las
ultimas cuatro lineas del programa introducen una nueva instruccion
BASIC. Se trata de END. Su proposito es obvio, dar por
finalizado el programa. Cada vez que BASIC llega a una instruccion
END
, deja de correrlo. Esto sucede incluso si encuentra
END
en medio de un programa.
Este programa muestra una pantalla que inicia la historia y tiene otras dos como opciones. De estas otras dos se podria ramificar a otras cuatro. Sin embargo, en lugar de enumerar un programa con muchas casillas vacias, podras terminarlo por tu cuenta. Crea cuadros de historias adicionales que comiencen en las lineas 900, 1200, 1500 y 1800. Inventa tantos como necesites. Sientete libre de completar una historia real en los recuadros. Simplemente realiza un listado de cada caja de flores (introduciendo el comando LIST 320-520, por ejemplo) y completalo con tu historia. Recuerda presionar la tecla Intro despues de cada linea.
Finalmente, dado que este programa representa mucho trabajo duro, asegurese de gauardarlo en un archivo de disco antes de ingresar al SISTEMA.
Conclusion
En este tutorial aprendimos sobre las variables y las instrucciones
BASIC REM, IF
-THEN
-ELSE
,
GOTO
y END
. Con estos comandos, descubrimos
como hacer elecciones en los programas y como desplazar el puntero de
ejecucion dentro del programa. Tambien comimos algunos fideos (de
codigo).
¡Comparte tu
historia.bas
con el resto de la comunidad!