- logo_espiral.gif (7.54 KiB) Visto 6156 veces
EL PROGRAMA
Este programa es un pequeño intérprete de lenguaje LOGO, preparado para ser ejecutado en la versión básica del ZX-81.
Controlamos una tortuga que se mueve por la pantalla según los comandos que le indicamos.
Los comandos se pueden introducir de uno en uno, o varios a la vez. Tanto los comandos como los valores numéricos deben ocupar dos caracteres, y deben estar separados por un espacio. No hacerlo así provocará un error que detendrá el programa.
Para reiniciar el intérprete y borrar el contenido de la pantalla se debe pulsar ENTER con la línea de comandos vacía.
Esta versión de LOGO reconoce los siguientes comandos:
SUbir
Sube la tortuga y no dibuja nada mientras se mueve.
BAjar
Baja la tortuga y dibuja mientras se mueve. Activado por defecto.
DErecha grados
Gira la tortuga a la derecha el número de grados indicados.
IZquierda grados
Gira la tortuga a la izquierda el número de grados indicados.
AVanza pasos
La tortuga avanza el número de pasos indicado.
>> pasos
Incrementa el último número de pasos realizados en la cantidad indicada.
REpite veces
Repite las siguientes instrucciones el número de veces indicado.
Solo puede haber una repetición por línea de comandos.
Ejemplos:
Dibujar un cuadrado en pantalla:
RE 04 AV 10 DE 90
Dibujar una espiral:
AV 01 RE 20 IZ 90 >> 01
Dibujar un círculo:
RE 36 AV 02 DE 10
Comentarios y recomendaciones:
- Los valores numéricos deben tener dos cifras, o una cifra y un espacio.
- Para valores numéricos superiores a 99 se deberán añadir dos comandos que sumen el valor deseado.
- Los comandos deben tener dos caracteres aunque solo se tiene en cuenta el primero.
- El contenido de la pantalla se conserva durante la ejecución de los distintos comandos.
- Realizar dibujos complejos en un ZX-81 con 1K puede ocasionar un error 4 de falta de memoria.
Descargar el juego en formato ".P":
BLOQUES
He dividido el listado en 3 bloques:
- Inicializar variables principales.
- Procesar la línea de comandos.
- Ejecutar el comando LOGO.
COMO FUNCIONA
A continuación detallo, línea por línea, el funcionamiento del programa.
Se utilizan las siguientes variables:
U – Variable que contiene el valor “1”.
X – Posición horizontal de la tortuga.
Y – Posición vertical de la tortuga.
D – Posición de la tortuga (0 – Arriba, 1 – Abajo).
M – Dirección de la tortuga.
C – Valor del comando REpite.
E – Posición de retorno del comando REpite.
P – Posición en la línea de comandos.
N – Valor del valor numérico de un comando.
F – Control de bucles y otros.
A – Posición X durante el PLOT. También se usa como variable auxiliar para calcular el giro de la tortuga.
B – Posición Y durante el PLOT. Al finalizar guarda el número de pasos realizados.
A$ - Variable donde se guarda la línea que se está procesando.
El programa ocupa un total de 40 líneas:
2 – Guardamos el valor 1 en la variable “U”. Se usará a lo largo del programa y permite ahorrar memoria.
4 – Guardamos la posición X de la tortuga en la variable “X”.
5 – Guardamos la posición Y de la tortuga en la variable “Y”.
6 – Guardamos el estado de la tortuga en la variable “D”. Se le asigna un 1.
7 – Guardamos la dirección de la tortuga en la variable “M”. Se le asigna un 0.
8 – Guardamos el valor de la repetición en la varibale “C”. Se le asigna un 0.
9 – Borramos la pantalla.
10 – Introducimos una línea de comandos en A$.
12 – Inicio del bucle que irá leyendo los distintos caracteres de la variable A$.
14 – Inicio del bucle que intenta reconocer el comando a ejecutar.
16 – Comprueba la primera línea del comando, y si lo localiza salta a la línea 20. En “F” se guarda su ID.
18 – Final de bucle que reconoce los comandos.
20 – Si el ID del comando es inferior a 3 salta a la línea 26.
22 – Se incrementa el valor del bucle para saltar el siguiente comando ya que es un valor numérico.
24 – Guardamos en “N” el valor asociado al comando a ejecutar.
26 – Saltamos a una línea múltiplo de 50, en función del ID del comando.
28 – Final del bucle que lee la línea de comandos.
30 – Se decrementa la variable “C”, usada para controlar las repeticiones de comandos.
32 – Si el valor de “C” es inferior a 1 es que ha finalizado la repetición, o simplemente es que no había, y salta a 10.
34 – Asignamos a la variable “P”, usada por el bucle que revisa la línea de comandos, el punto donde debe volver.
36 – Saltamos a la línea 14 para continuar con el bucle de la línea 12.
100 – Guardamos en “D” el estado de la tortuga. Si “F=1” baja y si “F=2” sube.
102 – Volvemos de la subrutina.
200 – Guardamos en “A” el giro a realizar.
202 – Si “F=3” (Girar a la derecha) se cambia el signo de “A”.
204 – Sumamos a “M” el giro a realizar, dando como resultado un valor de 360 grados.
206 – Volvemos de la subrutina.
250 – Sumamos al número de pasos, el último número realizado.
300 – Inicio del bucle que dibuja el desplazamiento de la tortuga.
302 – Guardar en “A” la posición horizontal.
304 – Guardar en “B” la posición vertical.
306 – Si la tortuga está bajada (D=1) se pone un punto en la posición de la pantalla.
308 – Final del bucle que dibuja el desplazamiento de la tortuga.
310 – Guardamos en “X” la última posición horizontal.
312 – Guardamos en “Y” la última posición vertical.
314 – Guardamos en “B” el número de pasos realizados. Se usará posteriormente por el comando “REpetir”.
316 – Volvemos de la subrutina.
350 – Guardamos en “C” el valor de la repetición a realizar, cargado en “N”.
352 – Guardamos en “E” la posición de la línea de comandos a la que volver, saltando el último valor numérico leído.
354 – Volvemos de la subrutina.
EL PROGRAMA
- listado.gif (10.29 KiB) Visto 6156 veces
APUNTES FINALES
En marzo de 1983 me compré el número 13 de la revista “El Ordenador Personal”, dos meses antes de comprarme mi primer ordenador, un Sinclair ZX-81. Me llamó la atención un artículo que venía con un listado en BASIC, que permitía hacer dibujos en la pantalla mediante una serie de sencillos comandos. Era una versión muy “lite” del lenguaje LOGO.
Unos meses más tarde conseguí una ampliación de memoria de 16 KB, y recuerdo que una de las primeras cosas que hice con ella fue teclear este programa, y como no, usarlo. Era curioso y entretenido.
- logo_OP13.jpg (134.57 KiB) Visto 6156 veces
Casi 32 años más tarde, y con las experiencia adquirida al realizar las versiones de 1K de intérpretes de FORTH, LEARN y un sencillo ensamblador, me he decidido a hacer una versión de LOGO en 1K.
En la cabecera del artículo del OP pone: “Para que su ZX aproveche todas sus capacidades gráficas, bastan este programa y 16 Ko de memoria”. Pues no, con 1K también se puede hacer.
Así que lo primero que hice fue ver como este programa controlaba la tortuga, ya que yo era de los que cateaban las mates.
Rápidamente localice el trozo de código que se encargaba de controlar el giro y movimiento de la tortuga, mediante senos y cosenos y algún Pi…
Metiendo un LOGO en 472 bytes
El ZX-81 básico dispone de 1024 bytes, de los que descontando los 125 bytes de la zona de variables del sistema y un mínimo de 25 bytes de la memoria de vídeo dejan 874 bytes libres.
El programa necesita 12 variables numéricas que ocupan 84 bytes más, y una alfanumérica que ocupará en función de lo que se escriba en la línea de comandos.
El calculador y el tratamiento de cadenas necesitan memoria para funcionar y lo normal es que en la pantalla acabe apareciendo algún dibujo un poco complejo, así que el programa no debería ocupar más de 500 bytes.
¿Y como se hace?
Lo primero ha sido introducir una línea con la que controlo la memoria que ocupa el programa en BASIC:
9999 PRINT (PEEK VAL"16396"+VAL"256"*PEEK VAL"16397")-VAL"16552"
Esta línea ocupa 43 bytes, que ganaré al borrarla al finalizar el desarrollo del programa.
Como siempre, he usado los trucos habituales del ZX-81 para ahorrar memoria en el uso de valores numéricos. Así, "NOT PI" es 0, uso de CODE y VAL, y como el valor 1 se usa varias veces, he asignado ese valor a la variable "U" mediante "SGN PI".
Comienza la pesadilla
Realmente este intérprete me ha dado muchos quebraderos de cabeza ya que solo la parte que pone los puntos en pantalla y controla el giro de la tortuga ocupaba más de 150 bytes, y quería que reconociera todos los comandos que he acabado incorporando.
Así que la duda era como hacer la entrada de comandos y como procesarlos.
Tenía dos opciones:
1. Comando a comando como el intérprete de LEARN y guardarlos codificados en el buffer de la impresora.
2. Introducir una línea y procesarla como en el intérprete de FORTH, que no los codifica y dificulta el procesamiento.
Pues ni el 1 ni el 2, he creado el…
3. Se introduce la línea como en el FORTH pero se codifica como el LEARN, sin guardarlos en el buffer. Un remix.
Como en este puedo hacer que todos los comandos y valores numéricos tengan el mismo tamaño, dos caracteres, me ha puesto las cosas más fáciles. A pesar que estuve haciendo pruebas con los distintos métodos y consumían demasiada memoria.
Perdido un día, aproveché un par de viajes en tren para redactar el programa en un PC con el Notepad++, haciendo cambios y más cambios hasta que el código aparentemente debería funcionar.
Posteriormente tecleé el programa en el emulador de Windows “EightyOne” y la verdad es que funcionó todo perfectamente a la primera, excepto el comando “REpite”, que tuvo un pequeño bug fácilmente localizado y corregido.
Moviendo la tortuga
El programa está basado en la versión aparecida en la revista “El Ordenador Personal” e incluso los programas son compatibles, aunque aquí por evidentes problemas de memoria no puedes definir palabras, y las instrucciones y valores numéricos se limitan a 2 caracteres, y van separados por un espacio. He prescindido de su comando “>>” y he convertido su comando “>” en mi comando “>>” (por los dos caracteres), con lo que dispongo de un comando menos. Pequeña perdida.
Por otro lado, no recuerdo la orientación inicial de la tortuga en la versión del OP, pero en mi caso apunta hacia la derecha.
En equipos con más de 1K se podría centrar la tortuga para tener más espacio, ya que si hacemos algo muy complejo nos quedaremos sin memoria y aparecerá el fatídico error 4.
Destacar que revisando el programa original he visto que su programación deja muchísimo que desear, y que con poco más código del que yo he usado se podría hacer lo mismo. Quizás algún día…
Con todo, mi intérprete es fácil de usar y tiene una velocidad más que aceptable. Así que... Prueba superada ¡!!
Os invito a probarlo.
- logo_circulo.gif (6.56 KiB) Visto 6156 veces
- logo_rombo.gif (6.66 KiB) Visto 6156 veces
- logo_triangulo.gif (6.39 KiB) Visto 6156 veces
- logo_espiral.gif (7.54 KiB) Visto 6156 veces
