Compare commits
3 Commits
main
...
acentos_en
| Author | SHA1 | Date |
|---|---|---|
 jota
|
4e223c0411 | |
|
jota
|
e15b55c477 | |
|
jota
|
b3bcb6b4e2 |
|
|
@ -21,7 +21,7 @@ comencemos con el siguiente programa como plantilla. incluye los datos para un s
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
|
@ -167,7 +167,7 @@ lo siguiente muestra nuestro programa en contexto, llenando completamente la pri
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
|
|
|||
|
|
@ -12,9 +12,9 @@ o primero que nada... ¿qué es uxn?
|
|||
|
||||
=> https://100r.co/site/uxn.html 100R - uxn
|
||||
|
||||
te invito a leer "why create a smol virtual computer" en ese sitio de 100R, también.
|
||||
te invito a leer "why create a smol virtual computer" ("porqué crear una pequeña computadora virtual") del sitio de 100R, para que conozcas más sobre la historia del proyecto.
|
||||
|
||||
uxn es el núcleo de la computadora virtual (¿por el momento?) varvara. es lo suficientemente simple como para ser emulada por diversas plataformas de computación viejas y nuevas y ser seguida a mano.
|
||||
uxn es el núcleo de la computadora virtual varvara. es lo suficientemente simple como para ser emulada por diversas plataformas de computación viejas y nuevas y ser seguida a mano.
|
||||
|
||||
personalmente, veo en ella las siguientes virtudes:
|
||||
|
||||
|
|
@ -25,7 +25,7 @@ personalmente, veo en ella las siguientes virtudes:
|
|||
* ámbito de práctica y experimentación de computación dentro de límites
|
||||
* ya portada a plataformas de computación actuales y de varios años de antigüedad
|
||||
|
||||
¡todos estos conceotos suenan genial para mí, y espero que para tí también!
|
||||
¡todos estos conceptos suenan genial para mí, y espero que para tí también!
|
||||
|
||||
sin embargo, noto algunos aspectos que pueden hacerla parecer no tan asequible:
|
||||
|
||||
|
|
@ -192,7 +192,7 @@ $ cd uxn
|
|||
$ ./build.sh
|
||||
```
|
||||
|
||||
si todo fué bién, verás varios mensajes en la terminal y una pequeña ventana con el título uxn, y una aplicación demo: uxnemu está ahora corriendo una "rom" correspondiendo a esa aplicación.
|
||||
si todo fue bién, verás varios mensajes en la terminal y una pequeña ventana con el título uxn, y una aplicación demo: uxnemu está ahora corriendo una "rom" correspondiendo a esa aplicación.
|
||||
|
||||
## controles uxnemu
|
||||
|
||||
|
|
@ -237,9 +237,9 @@ uxntal es el lenguaje ensamblador para la máquina uxn.
|
|||
|
||||
estuvimos hablando antes sobre el cpu uxn y las 32 instrucciones que sabe cómo ejecutar, cada una de ellas codificada como una sola palabra de 8 bits (byte).
|
||||
|
||||
ese lenguaje ensamblador uxntal implica que hay una relación uno a uno mapeando de una instrucción escrita en el lenguaje a una palabra de 8 bit correspondiente que el cpu puede interpretar.
|
||||
que uxntal sea un lenguaje "ensamblado" implica que hay una relación uno a uno mapeando de una instrucción escrita en el lenguaje a una palabra de 8 bit correspondiente que el cpu puede interpretar.
|
||||
|
||||
por ejemplo, la instrucción ADD (suma) en uxntal es codificada como un byte con el valor 18 en hexadecimal, y corresponde al siguiente conjunto de de acciones: toma los dos elementos superiores de la pila, los suma, y empuja el resultado a la pila.
|
||||
por ejemplo, la instrucción ADD (suma) en uxntal es codificada como un byte con el valor 18 en hexadecimal, y corresponde al siguiente conjunto de acciones: toma los dos elementos superiores de la pila, los suma, y empuja el resultado a la pila.
|
||||
|
||||
en sistemas de tipo forth podemos ver el siguiente tipo de notación para expresar los operandos que una instrucción toma de la pila, y el(los) resultado(s) que empuja devuelta a la pila:
|
||||
|
||||
|
|
@ -272,7 +272,7 @@ ensamblémoslo y corrámoslo:
|
|||
$ ./bin/uxnasm hola.tal bin/hola.rom && ./bin/uxnemu bin/hola.rom
|
||||
```
|
||||
|
||||
veremos una salida con el siguiente aspecto:
|
||||
se abrirá una ventana negra, y en la consola veremos una salida parecida a la siguiente:
|
||||
|
||||
```
|
||||
Assembled bin/hola.rom(5 bytes), 0 labels, 0 macros.
|
||||
|
|
@ -315,7 +315,7 @@ en la segunda linea ocurren varias cosas:
|
|||
|
||||
* |0100 : puede que recuerdes este número de antes - este es el valor inicial del contador de programa; la dirección del primer byte que el cpu lee. usamos esta notación para indicar que lo que esté escrito después será escrito en memoria después de esta dirección.
|
||||
* LIT : esta aparece dos veces, y es una instrucción uxn con las siguientes acciones: empuja el siguiente valor en memoria a la pila, y hace que el contador de programa saltee ese byte.
|
||||
* 68 : un número hexadecimal, que corresponde al código ascii del caracter 'h'
|
||||
* 68 : un número hexadecimal, que corresponde al código ascii del carácter 'h'
|
||||
* 18 : un número hexadecimal, que corresponde a una dirección de entrada/salida: dispositivo 1 (consola), dirección 8.
|
||||
* DEO : otra instrucción uxn, que podemos definir como lo siguiente: escribir el byte dado en la dirección de dispositivo dada, ambos tomados de la pila ( byte dirección -- )
|
||||
|
||||
|
|
@ -329,17 +329,17 @@ leyendo el programa de izquierda a derecha, podemos ver el siguiente comportamie
|
|||
|
||||
¿y qué es el dispositivo de entrada/salida con la dirección 18?
|
||||
|
||||
mirando en la tabla de dispositivos de la referencia varvara, podemos ver que el dispositivo con la dirección 1 en el nibble superior es la consola (entrada y salida estandard), y que la columna con la dirección 8 corresponde a "escritura".
|
||||
mirando en la tabla de dispositivos de la referencia varvara, podemos ver que el dispositivo con la dirección 1 en el nibble superior es la consola (entrada y salida estandard), y que la columna con la dirección 8 corresponde al puerto "escritura".
|
||||
|
||||
=> https://wiki.xxiivv.com/site/varvara.html varvara
|
||||
|
||||
asique, el dispositivo 18 corresponde a "escribir en consola", o salida estándar.
|
||||
así que, el dispositivo 18 corresponde a "escribir en consola", o salida estándar.
|
||||
|
||||
¡nuestro programa está enviando el valor hexadecimal 68 (caracter 'h') a la salida estandard!
|
||||
¡nuestro programa está enviando el valor hexadecimal 68 (carácter 'h') a la salida estandard!
|
||||
|
||||
puedes ver los valores hexadecimales de los caracteres ascii en la siguiente tabla:
|
||||
puedes ver los valores hexadecimales de los carácteres ascii en la siguiente tabla:
|
||||
|
||||
=> https://wiki.xxiivv.com/site/ascii.html ascii table
|
||||
=> https://wiki.xxiivv.com/site/ascii.html tabla ascii
|
||||
|
||||
### números literales
|
||||
|
||||
|
|
@ -355,7 +355,14 @@ podemos ver que el ensamblador reporta que nuestro programa es de 5 bytes de tam
|
|||
Assembled bin/hola.rom(5 bytes), 0 labels, 0 macros.
|
||||
```
|
||||
|
||||
para el curioso (¡como tú!), podemos usar una herramienta como hexdump para ver sus contenidos:
|
||||
podemos confirmarlo usando el programa wc (word count):
|
||||
|
||||
```
|
||||
$ wc --bytes hola.rom
|
||||
5 hola.rom
|
||||
```
|
||||
|
||||
para le curiose (¡como tú!), podemos usar una herramienta como hexdump para ver sus contenidos:
|
||||
|
||||
```
|
||||
$ hexdump -C bin/hola.rom
|
||||
|
|
@ -365,7 +372,7 @@ $ hexdump -C bin/hola.rom
|
|||
|
||||
80 es el "opcode" correspondiente a LIT, y 17 es el opcode correspondiente a DEO. ¡y ahí están nuestros 68 y 18!
|
||||
|
||||
¡osea, efectivamente, nuestro programa ensamblado presenta una correspondencia uno a uno con las instrucciones que acabamos de escribir!
|
||||
¡o sea, efectivamente, nuestro programa ensamblado presenta una correspondencia uno a uno con las instrucciones que acabamos de escribir!
|
||||
|
||||
de hecho, podríamos haber escrito nuestro programa con estos números hexadecimales (el código máquina), y hubiera funcionado igual:
|
||||
|
||||
|
|
@ -382,7 +389,7 @@ puedes encontrar los opcodes de todas las 32 instrucciones en la referencia uxnt
|
|||
|
||||
## programa hola
|
||||
|
||||
podemos expandir nuestro programa para imprimir más caracteres:
|
||||
podemos expandir nuestro programa para imprimir más carácteres:
|
||||
|
||||
```
|
||||
( hola.tal )
|
||||
|
|
@ -401,13 +408,13 @@ veremos algunas características de uxntal que hacen escribir y leer su código
|
|||
|
||||
# runas, etiquetas, macros
|
||||
|
||||
las runas son caracteres especiales que indican a uxnasm algún pre procesamiento a hacer al ensamblar nuestro programa.
|
||||
las runas son carácteres especiales que indican a uxnasm algún pre procesamiento a hacer al ensamblar nuestro programa.
|
||||
|
||||
## runa de pad absoluto
|
||||
|
||||
ya vimos la primera de ellas: | define un pad absoluto: la dirección donde el siguiente elemento escrito será ubicado en memoria.
|
||||
ya vimos la primera de ellas: | define un pad absoluto, o sea, la dirección donde el siguiente elemento escrito será ubicado en memoria.
|
||||
|
||||
si la dirección es de 1 byte de longitud, es asumido que es una dirección de el espacio de entrada/salida o de la página cero.
|
||||
si la dirección es de 1 byte de longitud, es asumido que es una dirección del espacio de entrada/salida o de la página cero.
|
||||
|
||||
si la dirección es de 2 bytes de longitud, es asumido que es una dirección de la memoria principal.
|
||||
|
||||
|
|
@ -415,7 +422,7 @@ si la dirección es de 2 bytes de longitud, es asumido que es una dirección de
|
|||
|
||||
hablemos de otra runa: #
|
||||
|
||||
éste caracter define un "hex literal": es básicamente un atajo para la instrucción LIT.
|
||||
éste carácter define un "hex literal": es básicamente un atajo para la instrucción LIT.
|
||||
|
||||
usando esta runa, podemos reescribir nuestro primer programa como:
|
||||
|
||||
|
|
@ -424,7 +431,7 @@ usando esta runa, podemos reescribir nuestro primer programa como:
|
|||
|0100 #68 #18 DEO
|
||||
```
|
||||
|
||||
el siguiente tendría el mismo comportamiento que el programa de arriba, pero usando un byte menos (en la siguiente sección/día veremos por qué)
|
||||
el siguiente tendría el mismo comportamiento que el programa de arriba, pero usando un byte menos (en el siguiente día veremos por qué):
|
||||
|
||||
```
|
||||
( hola.tal )
|
||||
|
|
@ -437,13 +444,13 @@ importante: recuerda que esta runa (y las otras con la palabra "literal" en su n
|
|||
|
||||
si sólo queremos tener un número específico en la memoria principal, sin empujarlo a la pila, simplemente escribiríamos el número tal cual, "crudo". esta es la forma en que lo hicimos en nuestros primeros programas de arriba.
|
||||
|
||||
## runa de caracter "crudo" o "raw"
|
||||
## runa de carácter crudo o "raw"
|
||||
|
||||
ésta es la runa de caracter raw: '
|
||||
ésta es la runa de carácter crudo: '
|
||||
|
||||
nos permite que uxnasm decodifique el valor numérico de un caracter ascii.
|
||||
nos permite que uxnasm decodifique el valor numérico de un carácter ascii.
|
||||
|
||||
nuestro "programa hola" luciría de la siguiente manera, usando las nuevas runas que acabamos de aprender:
|
||||
nuestro programa "hola" luciría de la siguiente manera, usando las nuevas runas que acabamos de aprender:
|
||||
|
||||
```
|
||||
( hola.tal )
|
||||
|
|
@ -454,13 +461,13 @@ nuestro "programa hola" luciría de la siguiente manera, usando las nuevas runas
|
|||
#0a #18 DEO ( nuevalínea )
|
||||
```
|
||||
|
||||
el "raw" en el nombre de esta runa indica que no es literal, por ejemplo que no agrega una instrucción LIT.
|
||||
el "crudo" en el nombre de esta runa indica que no es literal, por ejemplo que no agrega una instrucción LIT.
|
||||
|
||||
por eso debemos incluir una instrucción LIT.
|
||||
|
||||
## runas para etiquetas
|
||||
|
||||
incluso ahora que sabemos que #18 corresponde a empujar la dirección de dispositivo escribir en consola en la pila, por legibilidad y para asegurar nuestro código a futuro es una buena práctica asignar una serie de etiquetas que corresponderán a ese dispositivo y sus sub direcciones.
|
||||
incluso ahora que sabemos que #18 corresponde a empujar la dirección de dispositivo escribir en consola en la pila, por legibilidad y para asegurar nuestro código a futuro, es una buena práctica asignar una serie de etiquetas que corresponderán a ese dispositivo y sus sub direcciones.
|
||||
|
||||
la runa @ nos permite definir etiquetas, y la runa & nos permite definir sub etiquetas.
|
||||
|
||||
|
|
@ -490,7 +497,7 @@ luego tenemos varias sub etiquetas, indicadas por la runa &, y pads relativos, i
|
|||
|
||||
nada de esto sería traducido a código máquina, pero nos asiste al escribir código uxntal.
|
||||
|
||||
la runa para referirse a una dirección literal en la página cero o el espacio de direcciones de entrada/salida, es . (punto), y una / (barra) nos permite referirnos a una de sus sub etiquetas.
|
||||
la runa para referirse a una dirección literal en la página cero o el espacio de direcciones de entrada/salida es . (punto), y una / (barra) nos permite referirnos a una de sus sub etiquetas.
|
||||
|
||||
recuerda: al ser una runa de "dirección literal" va a agregar una instrucción LIT antes de la correspondiente dirección :)
|
||||
|
||||
|
|
@ -524,19 +531,19 @@ por ejemplo, podemos ver que el siguiente fragmento de código es repetido varia
|
|||
.Consola/escribe DEO ( equivalente a #18 DEO, o a LIT 18 DEO )
|
||||
```
|
||||
|
||||
podemos definir un macro llamado EMIT que tomará de la pila un byte correspondiente a un caracter, y lo imprimirá en la salida estandard. para esto, necesitamos la runa %, y llaves para la definición.
|
||||
podemos definir un macro llamado EMIT que tomará de la pila un byte correspondiente a un carácter, y lo imprimirá en la salida estandard. para esto, necesitamos la runa %, y llaves para la definición.
|
||||
|
||||
¡no olvides los espacios!
|
||||
|
||||
```
|
||||
( escribe un caracter a la salida estandard )
|
||||
%EMIT { .Consola/escribe DEO } ( caracter -- )
|
||||
( escribe un carácter a la salida estandard )
|
||||
%EMIT { .Consola/escribe DEO } ( carácter -- )
|
||||
```
|
||||
|
||||
para llamar a un macro, sólo escribimos su nombre:
|
||||
|
||||
```
|
||||
( imprime caracter h )
|
||||
( imprime carácter h )
|
||||
LIT 'h EMIT
|
||||
```
|
||||
|
||||
|
|
@ -557,8 +564,8 @@ usando todos estos macros y runas, nuestro programa puede terminar luciendo como
|
|||
|10 @Consola [ &vector $2 &lee $1 &pad $5 &escribe $1 &error $1 ]
|
||||
|
||||
( macros )
|
||||
( imprime un caracter en la salida estandard )
|
||||
%EMIT { .Consola/escribe DEO } ( caracter -- )
|
||||
( imprime un carácter en la salida estandard )
|
||||
%EMIT { .Consola/escribe DEO } ( carácter -- )
|
||||
( imprime una nueva línea )
|
||||
%NL { #0a EMIT } ( -- )
|
||||
|
||||
|
|
@ -572,15 +579,15 @@ usando todos estos macros y runas, nuestro programa puede terminar luciendo como
|
|||
|
||||
termina siendo ensamblado en los mismos 25 bytes que los ejemplos de arriba, pero con suerte más legible y mantenible.
|
||||
|
||||
podemos "mejorar" este programa haciendo que un loop imprima los caracteres, pero estudiaremos eso más tarde :
|
||||
podemos "mejorar" este programa haciendo que un loop imprima los carácteres, pero estudiaremos eso más tarde :)
|
||||
|
||||
# ejercicios
|
||||
|
||||
## reubicando EMIT
|
||||
|
||||
en nuestro programa previo, el macro EMIT es llamado justo después de empujar un caracter a la pila.
|
||||
en nuestro programa previo, el macro EMIT es llamado justo después de empujar un carácter a la pila.
|
||||
|
||||
¿cómo reescribirías el programa para que primero empuje todos los caracteres y luego los emita (o haga "EMIT") todos con una secuencia como esta?
|
||||
¿cómo reescribirías el programa para que primero empuje todos los carácteres y luego los emita (o haga "EMIT") todos con una secuencia como esta?
|
||||
|
||||
```
|
||||
EMIT EMIT EMIT EMIT EMIT
|
||||
|
|
@ -590,16 +597,16 @@ EMIT EMIT EMIT EMIT EMIT
|
|||
|
||||
si miras en la tabla ascii, verás que el código hexadecimal 30 corresponde al dígito 0, 31 al dígito 1, siguiendo hasta el 39 que corresponde al dígito 9.
|
||||
|
||||
define un macro IMPRIMIR-DIGITO que toma un número (del 0 al 9) de la pila, e imprime el correspondiente dígito en la salida estandard.
|
||||
define un macro IMPRIMIR-DÍGITO que toma un número (del 0 al 9) de la pila, e imprime el correspondiente dígito en la salida estandard.
|
||||
|
||||
```
|
||||
%IMPRIMIR-DIGITO { } ( número -- )
|
||||
%IMPRIMIR-DÍGITO { } ( número -- )
|
||||
```
|
||||
|
||||
recordemos que el número tendría que ser escrito como un byte completo para que sea uxntal válido. si quisieras probar esta macro con, por ejemplo, el número 2, tendrías que escribirlo como 02:
|
||||
|
||||
```
|
||||
#02 IMPRIMIR-DIGITO
|
||||
#02 IMPRIMIR-DÍGITO
|
||||
```
|
||||
|
||||
# instrucciones del día 1
|
||||
|
|
@ -617,7 +624,7 @@ recordemos que el número tendría que ser escrito como un byte completo para qu
|
|||
|
||||
en el {tutorial de uxn día 2} empezamos a explorar los aspectos visuales de la computadora varvara: ¡hablamos sobre los aspectos fundamentales del dispositivo de pantalla para que podamos empezar a dibujar en el!
|
||||
|
||||
¡sin embargo, te invito a tomar un pequeño descanzo antes de continuar! :)
|
||||
sin embargo, ¡te invito a tomar un pequeño descanzo antes de continuar! :)
|
||||
|
||||
# apoyo
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ también discutiremos el trabajo con el modo corto o "short" (2 bytes) junto a l
|
|||
|
||||
si todavía no lo has hecho te recomiendo que leas las sección anterior en el {tutorial de uxn día 1}
|
||||
|
||||
# donde están tus cortos?
|
||||
# ¿donde están tus cortos?
|
||||
|
||||
antes de pasar a dibujar en la pantalla, tenemos que hablar de bytes y cortos :)
|
||||
|
||||
|
|
@ -214,7 +214,7 @@ como recapitulación: mencionamos que el dispositivo de pantalla sólo puede mos
|
|||
en los programas uxntal para el ordenador varvara puedes encontrar las etiquetas correspondientes a este dispositivo de la siguiente manera:
|
||||
|
||||
```
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
```
|
||||
|
||||
las entradas que podemos leer de este dispositivo son:
|
||||
|
|
@ -243,7 +243,7 @@ al principio, la capa del primer plano es completamente transparente: un proceso
|
|||
|
||||
la primera y más sencilla forma de dibujar en la pantalla es dibujando un solo píxel.
|
||||
|
||||
para hacer esto necesitamos establecer un par de coordenadas x,y donde queremos que se dibuje el pixel, y necesitamos establecer el byte 'pixel' a un valor específico para realizar realmente el dibujo.
|
||||
para hacer esto necesitamos establecer un par de coordenadas x,y donde queremos que se dibuje el píxel, y necesitamos establecer el byte 'píxel' a un valor específico para realizar realmente el dibujo.
|
||||
|
||||
## estableciendo las coordenadas
|
||||
|
||||
|
|
@ -269,7 +269,7 @@ una pregunta para ti: si quisiéramos establecer las coordenadas como ( x: 4, y:
|
|||
|
||||
## estableciendo el color
|
||||
|
||||
el envío de un único byte a .Pantalla/pixel realizará el dibujo en la pantalla.
|
||||
el envío de un único byte a .Pantalla/píxel realizará el dibujo en la pantalla.
|
||||
|
||||
el nibble alto de ese byte, es decir, el dígito hexadecimal de la izquierda, determinará la capa en la que dibujaremos:
|
||||
|
||||
|
|
@ -278,7 +278,7 @@ el nibble alto de ese byte, es decir, el dígito hexadecimal de la izquierda, de
|
|||
|
||||
el nibble inferior del byte, es decir, el dígito hexadecimal de la derecha, determinará su color.
|
||||
|
||||
las 8 posibles combinaciones del byte 'pixel' que tenemos para dibujar un pixel son:
|
||||
las 8 posibles combinaciones del byte 'píxel' que tenemos para dibujar un píxel son:
|
||||
|
||||
+ <table>
|
||||
+ <tr><th>byte de píxel</th><th>capa</th><th>color</th></tr>
|
||||
|
|
@ -291,7 +291,6 @@ las 8 posibles combinaciones del byte 'pixel' que tenemos para dibujar un pixel
|
|||
+ <tr><td>42</td><td>primer plano</td><td>2</td></tr>
|
||||
+ <tr><td>43</td><td>primer plano</td><td>3</td></tr>
|
||||
+ </table>
|
||||
|
||||
& * 00: dibujar el píxel con el color 0 en la capa del fondo
|
||||
& * 01: dibujar un píxel con el color 1 en la capa del fondo
|
||||
& * 02: dibujar el píxel con el color 2 en la capa del fondo
|
||||
|
|
@ -308,17 +307,17 @@ las 8 posibles combinaciones del byte 'pixel' que tenemos para dibujar un pixel
|
|||
```
|
||||
#0008 .Pantalla/x DEO2
|
||||
#0008 .Pantalla/y DEO2
|
||||
#41 .Pantalla/pixel DEO
|
||||
#41 .Pantalla/píxel DEO
|
||||
```
|
||||
|
||||
el programa completo se vería de la siguiente manera:
|
||||
|
||||
```
|
||||
( hola-pixel.tal )
|
||||
( hola-píxel.tal )
|
||||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
|
|
@ -327,10 +326,10 @@ el programa completo se vería de la siguiente manera:
|
|||
#01c0 .Sistema/g DEO2
|
||||
#2ce5 .Sistema/b DEO2
|
||||
|
||||
( dibujar un pixel en la pantalla )
|
||||
( dibujar un píxel en la pantalla )
|
||||
#0008 .Pantalla/x DEO2
|
||||
#0008 .Pantalla/y DEO2
|
||||
#41 .Pantalla/pixel DEO ( capa de primer plano, color 1 )
|
||||
#41 .Pantalla/píxel DEO ( capa de primer plano, color 1 )
|
||||
```
|
||||
|
||||
¡wuju!
|
||||
|
|
@ -349,22 +348,22 @@ Por ejemplo, podemos dibujar múltiples píxeles en una línea horizontal, estab
|
|||
|
||||
( dibujar 6 píxeles en una línea horizontal )
|
||||
#0008 .Pantalla/x DEO2
|
||||
#41 .Pantalla/pixel DEO
|
||||
#41 .Pantalla/píxel DEO
|
||||
|
||||
#0009 .Pantalla/x DEO2
|
||||
#41 .Pantalla/pixel DEO
|
||||
#41 .Pantalla/píxel DEO
|
||||
|
||||
#000a .Pantalla/x DEO2
|
||||
#41 .Pantalla/pixel DEO
|
||||
#41 .Pantalla/píxel DEO
|
||||
|
||||
#000b .Pantalla/x DEO2
|
||||
#41 .Pantalla/pixel DEO
|
||||
#41 .Pantalla/píxel DEO
|
||||
|
||||
#000c .Pantalla/x DEO2
|
||||
#41 .Pantalla/pixel DEO
|
||||
#41 .Pantalla/píxel DEO
|
||||
|
||||
#000d .Pantalla/x DEO2
|
||||
#11 .Pantalla/pixel DEO
|
||||
#11 .Pantalla/píxel DEO
|
||||
```
|
||||
|
||||
nótese que tenemos que establecer el color para cada píxel que dibujamos; esa operación señala el dibujo y tiene que repetirse.
|
||||
|
|
@ -372,7 +371,7 @@ nótese que tenemos que establecer el color para cada píxel que dibujamos; esa
|
|||
podemos definir una macro para que este proceso sea más fácil de escribir:
|
||||
|
||||
```
|
||||
%DIBUJAR-PIXEL { #41 .Pantalla/pixel DEO } ( -- )
|
||||
%DIBUJAR-PÍXEL { #41 .Pantalla/píxel DEO } ( -- )
|
||||
```
|
||||
|
||||
## leyendo y manipulando coordenadas
|
||||
|
|
@ -438,14 +437,14 @@ nuestra macro para incrementar la coordenada x podría entonces escribirse como
|
|||
usando estas macros que definimos arriba, nuestro código puede terminar viéndose de la siguiente forma:
|
||||
|
||||
```
|
||||
( hola-pixeles.tal )
|
||||
( hola-píxeles.tal )
|
||||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros )
|
||||
%DIBUJAR-PIXEL { #41 .Pantalla/pixel DEO } ( -- )
|
||||
%DIBUJAR-PÍXEL { #41 .Pantalla/píxel DEO } ( -- )
|
||||
%INC-X { .Pantalla/x DEI2 INC2 .Pantalla/x DEO2 } ( -- )
|
||||
|
||||
( programa princpal )
|
||||
|
|
@ -459,18 +458,18 @@ usando estas macros que definimos arriba, nuestro código puede terminar viéndo
|
|||
#0008 .Pantalla/y DEO2
|
||||
|
||||
( dibujar 6 píxeles en una línea horizontal )
|
||||
DIBUJAR-PIXEL INC-X
|
||||
DIBUJAR-PIXEL INC-X
|
||||
DIBUJAR-PIXEL INC-X
|
||||
DIBUJAR-PIXEL INC-X
|
||||
DIBUJAR-PIXEL INC-X
|
||||
DIBUJAR-PIXEL
|
||||
DIBUJAR-PÍXEL INC-X
|
||||
DIBUJAR-PÍXEL INC-X
|
||||
DIBUJAR-PÍXEL INC-X
|
||||
DIBUJAR-PÍXEL INC-X
|
||||
DIBUJAR-PÍXEL INC-X
|
||||
DIBUJAR-PÍXEL
|
||||
```
|
||||
|
||||
agradable, ¿no? ¡las operaciones ahora se ven más claras! y si quisiéramos tener esta línea disponible para usarla en otras posiciones, podríamos definir una macro para ella:
|
||||
|
||||
```
|
||||
%DIBUJAR-LINEA { } ( -- )
|
||||
%DIBUJAR-LÍNEA { } ( -- )
|
||||
```
|
||||
|
||||
¡intenta escribiendo la macro y utilizándola en diferentes posiciones de la pantalla!
|
||||
|
|
@ -657,7 +656,7 @@ además, 5, 'a' y 'f' en el nibble bajo dibujarán los píxeles que están "ence
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
|
|
@ -693,7 +692,7 @@ el siguiente código dibujará nuestro sprite cuadrado con las 16 combinaciones
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros )
|
||||
%INIT-X { #0008 .Pantalla/x DEO2 } ( -- )
|
||||
|
|
@ -924,7 +923,7 @@ el siguiente código mostrará nuestro sprite en las 16 diferentes combinaciones
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros )
|
||||
%INIT-X { #0008 .Pantalla/x DEO2 } ( -- )
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ el dispositivo controlador del ordenador varvara nos permite leer las entradas d
|
|||
la definición de sus puertos tendría el siguiente aspecto en un programa típico:
|
||||
|
||||
```
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
```
|
||||
|
||||
## el byte de botón
|
||||
|
|
@ -86,8 +86,8 @@ este utiliza el procedimiento de dibujo de sprites que probamos el día anterior
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
|
|
@ -107,7 +107,7 @@ BRK
|
|||
#0008 .Pantalla/y DEO2
|
||||
|
||||
( establecer la direccion del sprite )
|
||||
;cuadrado .Pantalla/direc DEO2
|
||||
;cuadrado .Pantalla/direc DEO2
|
||||
|
||||
( dibujar el sprite en el fondo )
|
||||
( usando el color 1 para el contorno )
|
||||
|
|
@ -280,9 +280,9 @@ hay varias runas que se refieren a direcciones y etiquetas. uxnasm las lee y las
|
|||
en los días anteriores ya hablamos de algunas de ellas; esta es una recapitulación de las mismas, y una introducción de las nuevas:
|
||||
|
||||
* dirección literal en la página cero: .etiqueta (un byte)
|
||||
* dirección literal en memoria principal: ;label (un corto)
|
||||
* dirección literal relativa en la memoria principal: ,label (un byte)
|
||||
* dirección cruda ("raw") en la memoria principal: :label (un byte)
|
||||
* dirección literal en memoria principal: ;etiqueta (un corto)
|
||||
* dirección literal relativa en la memoria principal: ,etiqueta (un byte)
|
||||
* dirección cruda ("raw") en la memoria principal: :etiqueta (un byte)
|
||||
|
||||
para definir las etiquetas, utilizamos:
|
||||
|
||||
|
|
@ -382,7 +382,7 @@ observe cómo las condiciones se escriben una tras otra: siempre que una bandera
|
|||
|
||||
también note que este código no está optimizado para el tamaño o la velocidad, sino para la legibilidad.
|
||||
|
||||
estaría en tí, por ejemplo, realizar una aritmética con el valor de la tecla que se pulsó para calcular el color a asignar al sprite - ¡podrías inspirarte en tu macro IMPRIMIR-DIGITO del día 1!
|
||||
estaría en tí, por ejemplo, realizar una aritmética con el valor de la tecla que se pulsó para calcular el color a asignar al sprite - ¡podrías inspirarte en tu macro IMPRIMIR-DÍGITO del día 1!
|
||||
|
||||
# manipulación de la pila
|
||||
|
||||
|
|
@ -491,15 +491,15 @@ en el caso que acabamos de discutir la entrada es la tecla que se presiona, pero
|
|||
esto implica que podríamos escribir la rutina como una macro:
|
||||
|
||||
```
|
||||
%?DIGITO-ASCII { DUP #2f GTH SWP #3a LTH AND } ( byte -- bandera )
|
||||
%?DÍGITO-ASCII { DUP #2f GTH SWP #3a LTH AND } ( byte -- bandera )
|
||||
```
|
||||
|
||||
y utilizarla con el byte que queramos:
|
||||
|
||||
```
|
||||
#30 ?DIGITO-ASCII ( empuja 01 hacia abajo en la pila )
|
||||
#20 ?DIGITO-ASCII ( empuja 00 hacia abajo en la pila )
|
||||
.Controlador/tecla DEI ?DIGITO-ASCII ( empuja la bandera correspondiente a la pila )
|
||||
#30 ?DÍGITO-ASCII ( empuja 01 hacia abajo en la pila )
|
||||
#20 ?DÍGITO-ASCII ( empuja 00 hacia abajo en la pila )
|
||||
.Controlador/tecla DEI ?DÍGITO-ASCII ( empuja la bandera correspondiente a la pila )
|
||||
```
|
||||
|
||||
### duplicados para los condicionales
|
||||
|
|
@ -635,8 +635,8 @@ observa el uso de las máscaras AND, los saltos condicionales y algunas operacio
|
|||
( dibujar-con-teclado.tal )
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
|
|
@ -656,13 +656,13 @@ observa el uso de las máscaras AND, los saltos condicionales y algunas operacio
|
|||
BRK
|
||||
|
||||
@en-controlador ( -> )
|
||||
.Controlador/boton DEI DUP ( leer y duplicar el byte del boton )
|
||||
.Controlador/botón DEI DUP ( leer y duplicar el byte del botón )
|
||||
#01 AND ( aislar el bit 0, correspondiente a Ctrl )
|
||||
,&relleno JCN ( si el bit no es 0, saltar al relleno, si no, continuar )
|
||||
|
||||
&contorno
|
||||
#01 .Pantalla/sprite DEO ( dibujar contorno )
|
||||
,&comprobar-flechas JMP ( continuar con la comprobación de las flechas )
|
||||
,&comprobar-flechas JMP ( continuar con comprobar-flechas )
|
||||
|
||||
&relleno
|
||||
#04 .Pantalla/sprite DEO ( dibujar relleno )
|
||||
|
|
@ -672,11 +672,11 @@ BRK
|
|||
DUP #10 AND ( aislar el bit 4, correspondiente a Arriba )
|
||||
,&arriba JCN ( saltar si no es 0 )
|
||||
DUP #20 AND ( aísla el bit 5, correspondiente a Abajo )
|
||||
&down JCN ( salta si no es 0 )
|
||||
&abajo JCN ( salta si no es 0 )
|
||||
DUP #40 AND ( aislar el bit 6, correspondiente a Izquierda )
|
||||
,&left JCN ( salta si no es 0 )
|
||||
,&izquierda JCN ( salta si no es 0 )
|
||||
DUP #80 AND ( aísla el bit 7, correspondiente a Derecha )
|
||||
&right JCN ( salta si no es 0 )
|
||||
&derecha JCN ( salta si no es 0 )
|
||||
|
||||
POP BRK
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ también hablamos del uso de la memoria del programa como un espacio para datos
|
|||
discutimos el dispositivo de pantalla de varvara en el día 2, pero nos saltamos su puerto vectorial para centrarnos en cómo dibujar con él:
|
||||
|
||||
```
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
```
|
||||
|
||||
ahora que ya tenemos el concepto de vectores de dispositivos en el {tutorial de uxn día 3}, ¡vamos a entrar de lleno en cómo usar el de la pantalla!
|
||||
|
|
@ -35,7 +35,7 @@ el siguiente programa demuestra un uso básico pero potente del vector pantalla:
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( init )
|
||||
|0100
|
||||
|
|
@ -53,8 +53,8 @@ el siguiente programa demuestra un uso básico pero potente del vector pantalla:
|
|||
BRK
|
||||
|
||||
@en-cuadro ( -> )
|
||||
( dibujar un pixel en el fondo con el color 1 )
|
||||
#01 .Pantalla/pixel DEO
|
||||
( dibujar un píxel en el fondo con el color 1 )
|
||||
#01 .Pantalla/píxel DEO
|
||||
|
||||
( incrementar Pantalla/x )
|
||||
.Pantalla/x DEI2 INC2 .Pantalla/x DEO2
|
||||
|
|
@ -83,7 +83,7 @@ estos son algunos cambios para que los pruebes y practiques:
|
|||
|
||||
merece señalar que muchas de estas posibilidades requieren formas de almacenar y recuperar datos entre fotogramas.
|
||||
|
||||
en el ejemplo anterior, estamos usando los puertos de pantalla para las coordenadas x e `y` como una forma de almacenar las coordenadas del pixel.
|
||||
en el ejemplo anterior, estamos usando los puertos de pantalla para las coordenadas x e `y` como una forma de almacenar las coordenadas del píxel.
|
||||
|
||||
pero, ¿qué sucede cuando queremos dibujar diferentes objetos, cada uno con su propio conjunto de coordenadas y otras características que pueden cambiar con el tiempo?
|
||||
|
||||
|
|
@ -106,23 +106,23 @@ sin embargo, no hemos utilizado los datos directamente; hemos enviado su direcci
|
|||
podríamos utilizar un sistema similar para almacenar, por ejemplo, las coordenadas x e `y` en lugar de los datos del sprite:
|
||||
|
||||
```
|
||||
@pixel-x 0008
|
||||
@pixel-y 0008
|
||||
@píxel-x 0008
|
||||
@píxel-y 0008
|
||||
```
|
||||
|
||||
o si no quisiéramos iniciarlas aquí, podríamos definirlas de la siguiente manera:
|
||||
|
||||
```
|
||||
@pixel-x $2
|
||||
@pixel-y $2
|
||||
@píxel-x $2
|
||||
@píxel-y $2
|
||||
```
|
||||
|
||||
recuerda que $2 crea un pad relativo de dos bytes: esto hace que píxel-y sea una etiqueta para una dirección en memoria dos bytes después de pixel-x. y cualquier código posterior ocurrirá dos bytes después de píxel-y.
|
||||
recuerda que $2 crea un pad relativo de dos bytes: esto hace que píxel-y sea una etiqueta para una dirección en memoria dos bytes después de píxel-x. y cualquier código posterior ocurrirá dos bytes después de píxel-y.
|
||||
|
||||
también podríamos usar etiquetas y sub-etiquetas, de manera muy similar a como definimos los dispositivos y sus puertos:
|
||||
|
||||
```
|
||||
@pixel [ &x $2 &y $2 ]
|
||||
@píxel [ &x $2 &y $2 ]
|
||||
```
|
||||
|
||||
### instrucciones: LDA y STA
|
||||
|
|
@ -140,32 +140,32 @@ en el modo corto, LDA2 cargará un corto desde la dirección dada, y STA2 almace
|
|||
|
||||
### ejemplos
|
||||
|
||||
como ejemplo, el siguiente código leería los dos bytes de pixel/x, los incrementaría en uno, y los almacenaría de nuevo en pixel/x:
|
||||
como ejemplo, el siguiente código leería los dos bytes de píxel/x, los incrementaría en uno, y los almacenaría de nuevo en píxel/x:
|
||||
|
||||
```
|
||||
;pixel/x LDA2 ( cargar pixel/x en la pila )
|
||||
;píxel/x LDA2 ( cargar píxel/x en la pila )
|
||||
INC2 ( incrementar )
|
||||
;pixel/x STA2 ( almacenar el resultado en pixel/x )
|
||||
;píxel/x STA2 ( almacenar el resultado en píxel/x )
|
||||
|
||||
BRK
|
||||
|
||||
@pixel [ &x $2 &y $2 ]
|
||||
@píxel [ &x $2 &y $2 ]
|
||||
```
|
||||
|
||||
nótese el uso de BRK antes de la etiqueta del píxel para que uxn se detenga antes de leer los datos como instrucciones.
|
||||
|
||||
lo siguiente es una variación que también duplica el nuevo valor de pixel/x para enviarlo a Pantalla/x:
|
||||
lo siguiente es una variación que también duplica el nuevo valor de píxel/x para enviarlo a Pantalla/x:
|
||||
|
||||
```
|
||||
;pixel/x LDA2 ( cargar pixel/x en la pila )
|
||||
;píxel/x LDA2 ( cargar píxel/x en la pila )
|
||||
INC2 ( incrementar )
|
||||
DUP2 ( duplicar el resultado )
|
||||
;pantalla/x DEO2 ( establecer como pantalla/x )
|
||||
;pixel/x STA2 ( y guardar el resultado en pixel/x )
|
||||
;píxel/x STA2 ( y guardar el resultado en píxel/x )
|
||||
|
||||
BRK
|
||||
|
||||
@pixel [ &x $2 &y $2 ]
|
||||
@píxel [ &x $2 &y $2 ]
|
||||
```
|
||||
|
||||
nótese que podríamos haber conseguido el mismo resultado almacenando el resultado, y luego recargándolo y enviándolo como salida.
|
||||
|
|
@ -177,7 +177,7 @@ aquí podemos ver cómo un DUP2 puede facilitar esa operación, siempre y cuando
|
|||
una posible ventaja de utilizar direcciones absolutas es que podemos iniciar el contenido de nuestras variables en el momento de ensamblaje, por ejemplo:
|
||||
|
||||
```
|
||||
@pixel [ &x 0008 &y 0008 ]
|
||||
@píxel [ &x 0008 &y 0008 ]
|
||||
```
|
||||
|
||||
estos contenidos iniciales cambiarán cada vez que usemos una instrucción STA allí :)
|
||||
|
|
@ -202,7 +202,7 @@ las etiquetas para la página cero funcionarían igual que antes; sólo tenemos
|
|||
|
||||
```
|
||||
|0000 ( página cero )
|
||||
@pixel [ &x $2 &y $2 ]
|
||||
@píxel [ &x $2 &y $2 ]
|
||||
```
|
||||
|
||||
para referirnos a ellas, utilizaríamos la runa punto (.) para las direcciones literales de página cero, en lugar de la runa dos puntos (;) para las direcciones literales absolutas.
|
||||
|
|
@ -229,11 +229,11 @@ en este caso el programa es más largo, pero puede ser visto como una buena plan
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( página cero )
|
||||
|0000
|
||||
@pixel [ &x $2 &y $2 ]
|
||||
@píxel [ &x $2 &y $2 ]
|
||||
|
||||
( init )
|
||||
|0100
|
||||
|
|
@ -243,8 +243,8 @@ en este caso el programa es más largo, pero puede ser visto como una buena plan
|
|||
#2ce5 .Sistema/b DEO2
|
||||
|
||||
( establecer coordenadas iniciales x,y )
|
||||
#0008 .pixel/x STZ2
|
||||
#0008 .pixel/y STZ2
|
||||
#0008 .píxel/x STZ2
|
||||
#0008 .píxel/y STZ2
|
||||
|
||||
( establecer el vector de pantalla )
|
||||
;en-cuadro .Pantalla/vector DEO2
|
||||
|
|
@ -252,27 +252,27 @@ BRK
|
|||
|
||||
@en-cuadro ( -> )
|
||||
( cargar las coordenadas x,y de la página cero y enviarlas a la pantalla )
|
||||
.pixel/x LDZ2 .Pantalla/x DEO2
|
||||
.pixel/y LDZ2 .Pantalla/y DEO2
|
||||
.píxel/x LDZ2 .Pantalla/x DEO2
|
||||
.píxel/y LDZ2 .Pantalla/y DEO2
|
||||
|
||||
( dibujar un pixel en el fondo con color 1 )
|
||||
#01 .Pantalla/pixel DEO
|
||||
( dibujar un píxel en el fondo con color 1 )
|
||||
#01 .Pantalla/píxel DEO
|
||||
|
||||
( incrementar el pixel/x )
|
||||
.pixel/x LDZ2 INC2 .pixel/x STZ2
|
||||
( incrementar el píxel/x )
|
||||
.píxel/x LDZ2 INC2 .píxel/x STZ2
|
||||
BRK
|
||||
```
|
||||
|
||||
notemos el uso de la runa literal de dirección de página cero (.) para referirse a la etiqueta .pixel.
|
||||
notemos el uso de la runa literal de dirección de página cero (.) para referirse a la etiqueta .píxel.
|
||||
|
||||
además, observe que en el caso de .pixel la dirección se refiere a la página cero, a la que se accede con LDZ/STZ, y en el caso de .Pantalla la dirección se refiere al espacio de direcciones entrada/salida (i/o), al que se accede con DEI/DEO.
|
||||
además, observe que en el caso de .píxel la dirección se refiere a la página cero, a la que se accede con LDZ/STZ, y en el caso de .Pantalla la dirección se refiere al espacio de direcciones entrada/salida (i/o), al que se accede con DEI/DEO.
|
||||
|
||||
### un poco de práctica de manipulación en la pila
|
||||
|
||||
nota que las siguientes instrucciones también incrementarían .pixel/x, pero estableciendo su dirección sólo una vez:
|
||||
nota que las siguientes instrucciones también incrementarían .píxel/x, pero estableciendo su dirección sólo una vez:
|
||||
|
||||
```
|
||||
.pixel/x DUP LDZ2 INC2 ROT STZ2
|
||||
.píxel/x DUP LDZ2 INC2 ROT STZ2
|
||||
```
|
||||
|
||||
te recomiendo que sigas cómo cambia el contenido de la pila en cada uno de los siguientes pasos: ten en cuenta que algunas de las instrucciones están en modo corto :)
|
||||
|
|
@ -312,17 +312,17 @@ lo siguiente es la subrutina en-cuadro que dibuja la línea creciente, pero alma
|
|||
```
|
||||
@en-cuadro ( -> )
|
||||
( carga las coordenadas x,y desde la página cero y las envía a la pantalla )
|
||||
,pixel/x LDR2 .Pantalla/x DEO2
|
||||
,pixel/y LDR2 .Pantalla/y DEO2
|
||||
,píxel/x LDR2 .Pantalla/x DEO2
|
||||
,píxel/y LDR2 .Pantalla/y DEO2
|
||||
|
||||
( dibujar un pixel en el fondo con el color 1 )
|
||||
#01 .Pantalla/pixel DEO
|
||||
( dibujar un píxel en el fondo con el color 1 )
|
||||
#01 .Pantalla/píxel DEO
|
||||
|
||||
( incrementa pixel/x )
|
||||
,pixel/x LDR2 INC2 ,pixel/x STR2
|
||||
( incrementa píxel/x )
|
||||
,píxel/x LDR2 INC2 ,píxel/x STR2
|
||||
BRK
|
||||
|
||||
@pixel [ &x $2 &y $2 ]
|
||||
@píxel [ &x $2 &y $2 ]
|
||||
```
|
||||
|
||||
nótese el uso de la runa coma (,) para indicar que es una dirección relativa; uxnasm calcula el desfase requerido asumiendo que será utilizado en la siguiente instrucción.
|
||||
|
|
@ -334,17 +334,17 @@ si declaráramos estas variables como sub-etiquetas de en-cuadro, el código que
|
|||
```
|
||||
@en-cuadro ( -> )
|
||||
( carga las coordenadas x,y de la página cero y las envía a la pantalla )
|
||||
,&pixel-x LDR2 .Pantalla/x DEO2
|
||||
,&pixel-y LDR2 .Pantalla/y DEO2
|
||||
,&píxel-x LDR2 .Pantalla/x DEO2
|
||||
,&píxel-y LDR2 .Pantalla/y DEO2
|
||||
|
||||
( dibujar un píxel en el fondo con el color 1 )
|
||||
#01 .Pantalla/pixel DEO
|
||||
#01 .Pantalla/píxel DEO
|
||||
|
||||
( incrementa píxel/x )
|
||||
,&pixel-x LDR2 INC2 ,&pixel-x STR2
|
||||
,&píxel-x LDR2 INC2 ,&píxel-x STR2
|
||||
BRK
|
||||
( variables locales de en-cuadro )
|
||||
&pixel-x $2 &pixel-y $2
|
||||
&píxel-x $2 &píxel-y $2
|
||||
```
|
||||
|
||||
observe que en este caso, la runa de la coma (,) va acompañada de la runa de la sub-etiqueta (&).
|
||||
|
|
@ -367,9 +367,9 @@ te recomiendo que revises y experimentes con uno a la vez, pacientemente :)
|
|||
|
||||
## cambio de posición autónomo
|
||||
|
||||
ya discutimos como hacer que uxn cambie la posición de un pixel en la pantalla, dejando un rastro.
|
||||
ya discutimos como hacer que uxn cambie la posición de un píxel en la pantalla, dejando un rastro.
|
||||
|
||||
cambiar ese programa para dibujar un sprite de 8x8 en su lugar sería relativamente sencillo, y puede que ya lo hayas probado: tendríamos que usar Pantalla/sprite en lugar de Pantalla/pixel, con un byte apropiado para definir su color y orientación, y tendríamos que establecer la dirección de los datos de nuestro sprite en Pantalla/direc.
|
||||
cambiar ese programa para dibujar un sprite de 8x8 en su lugar sería relativamente sencillo, y puede que ya lo hayas probado: tendríamos que usar Pantalla/sprite en lugar de Pantalla/píxel, con un byte apropiado para definir su color y orientación, y tendríamos que establecer la dirección de los datos de nuestro sprite en Pantalla/direc.
|
||||
|
||||
eso daría como resultado un sprite que se mueve y que además deja un rastro: ¡te invito a que lo pruebes primero!
|
||||
|
||||
|
|
@ -396,7 +396,7 @@ el siguiente programa ilustra los puntos anteriores, haciendo que nuestro cuadra
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros/constantes )
|
||||
%MITAD2 { #01 SFT2 } ( desplazar un bit a la derecha ) ( corto -- corto/2 )
|
||||
|
|
@ -494,8 +494,8 @@ el siguiente programa nos permite controlar la posición horizontal de nuestro c
|
|||
( hola-sprite-en-movimiento.tal )
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( macros/constantes )
|
||||
%MITAD2 { #01 SFT2 } ( desplazar un bit a la derecha ) ( corto -- corto/2 )
|
||||
|
|
@ -530,11 +530,11 @@ BRK
|
|||
|
||||
( 2: cambiar de posición con las flechas )
|
||||
&verificar-flechas
|
||||
.Controlador/boton DEI
|
||||
.Controlador/botón DEI
|
||||
#40 AND ( aislar el bit 6, correspondiente a la izquierda )
|
||||
,&izquierda JCN ( saltar si no es 0 )
|
||||
|
||||
.Controlador/boton DEI
|
||||
.Controlador/botón DEI
|
||||
#80 AND ( aislar el bit 7, correspondiente a la derecha )
|
||||
,&derecha JCN ( saltar si no es 0 )
|
||||
|
||||
|
|
@ -630,7 +630,7 @@ para efectos prácticos te recomendaría tener un número de fotogramas correspo
|
|||
por ejemplo, lo siguiente es una secuencia de ocho sprites de 1bpp que corresponden a una línea diagonal que se mueve desde abajo a la derecha hasta arriba a la izquierda:
|
||||
|
||||
```
|
||||
@animacion
|
||||
@animación
|
||||
&fotograma0 00 00 00 00 00 00 01 03
|
||||
&fotograma1 00 00 00 00 01 03 06 0c
|
||||
&fotograma2 00 00 01 03 06 0c 18 30
|
||||
|
|
@ -786,7 +786,7 @@ añadir este desfase a la dirección de nuestra animación es comparativamente s
|
|||
8MOD ( aplicar el módulo 8 para obtener la secuencia entre 0 y 7 )
|
||||
#08 MUL ( multiplicar por 8 para obtener el desfase )
|
||||
A-CORTO ( convertir a corto )
|
||||
;animacion ( obtener la dirección de la animación )
|
||||
; n ( obtener la dirección de la animación )
|
||||
ADD2 ( añadir el desfase a la dirección )
|
||||
```
|
||||
|
||||
|
|
@ -796,7 +796,6 @@ y entonces podríamos enviar eso al puerto Pantalla/direc:
|
|||
.Pantalla/direc DEO2 ( establecer la dirección calculada )
|
||||
```
|
||||
|
||||
|
||||
## el programa completo
|
||||
|
||||
el programa que hace todo esto tendría el siguiente aspecto.
|
||||
|
|
@ -810,14 +809,14 @@ nota que utiliza una secuencia similar a la de los programas anteriores:
|
|||
|
||||
la sección "borrar el sprite" no es realmente necesaria en este caso debido a los colores que se utilizan, pero lo sería cuando se utilizan colores con transparencia en ellos :)
|
||||
|
||||
=> ./img/screencap_uxn-animation.gif animación de una franja diagonal dentro de un cuadrado pixelado. la diagonal se mueve desde abajo a la derecha hasta arriba a la izquierda
|
||||
=> ./img/screencap_uxn-animation.gif animación de una franja diagonal dentro de un cuadrado píxelado. la diagonal se mueve desde abajo a la derecha hasta arriba a la izquierda
|
||||
|
||||
```
|
||||
( hola-animacion.tal )
|
||||
( hola-animación.tal )
|
||||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|
||||
( macros/constantes )
|
||||
%MITAD2 { #01 SFT2 } ( desplazar un bit a la derecha ) ( corto -- corto/2 )
|
||||
|
|
@ -843,7 +842,7 @@ la sección "borrar el sprite" no es realmente necesaria en este caso debido a l
|
|||
.Pantalla/alto DEI2 MITAD2 #0004 SUB2 .Pantalla/y DEO2
|
||||
|
||||
( establecer la dirección del sprite )
|
||||
;animacion .Pantalla/direc DEO2
|
||||
;animación .Pantalla/direc DEO2
|
||||
|
||||
( establecer el vector de pantalla )
|
||||
;en-cuadro .Pantalla/vector DEO2
|
||||
|
|
@ -856,14 +855,14 @@ BRK
|
|||
|
||||
( 1: borrar sprite )
|
||||
( borrar sprite del primer plano )
|
||||
color-clear .Pantalla/sprite DEO
|
||||
color-borrar .Pantalla/sprite DEO
|
||||
|
||||
( 2: actualizar la dirección del sprite )
|
||||
.cuentaftg LDZ ( cargar cuentafotograma )
|
||||
8MOD ( aplicar el módulo 8 para obtener la secuencia entre 0 y 7 )
|
||||
#08 MUL ( multiplicar por 8 para obtener el desfase )
|
||||
A-CORTO ( convertir a corto )
|
||||
;animacion ( obtener la dirección de la animación )
|
||||
;animación ( obtener la dirección de la animación )
|
||||
ADD2 ( añadir el desfase a la dirección )
|
||||
.Pantalla/direc DEO2 ( establecer la dirección calculada )
|
||||
|
||||
|
|
@ -872,7 +871,7 @@ BRK
|
|||
BRK
|
||||
|
||||
( datos del sprite )
|
||||
@animacion
|
||||
@animación
|
||||
&fotograma0 00 00 00 00 00 00 01 03
|
||||
&fotograma1 00 00 00 00 01 03 06 0c
|
||||
&fotograma2 00 00 01 03 06 0c 18 30
|
||||
|
|
@ -914,7 +913,7 @@ podemos utilizar estas macros para dividir la frecuencia en nuestro código:
|
|||
8MOD ( aplicar el módulo 8 para obtener la secuencia entre 0 y 7 )
|
||||
#08 MUL ( multiplicar por 8 para obtener el desfase )
|
||||
A-CORTO ( convertir a corto )
|
||||
;animacion ( obtener la dirección de la animación )
|
||||
;animación ( obtener la dirección de la animación )
|
||||
ADD2 ( añadir el desfase a la dirección )
|
||||
.Pantalla/direc DEO2 ( establecer la dirección calculada )
|
||||
```
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ adicionalmente, tiene un par de cortos correspondientes a las coordenadas x,y de
|
|||
vemos este dispositivo definido en uxntal de la siguiente manera:
|
||||
|
||||
```
|
||||
|90 @Raton [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|90 @Ratón [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
```
|
||||
|
||||
## byte de estado
|
||||
|
|
@ -26,17 +26,17 @@ normalmente, en un ratón de tres botones, el primer botón es el izquierdo, el
|
|||
|
||||
utilizando un ratón de tres botones como este, tendríamos ocho valores posibles para el byte de estado, por ejemplo :
|
||||
|
||||
* 00 cuando no se pulsa ninguno de los botones
|
||||
* 01 cuando sólo se pulsa el primer botón
|
||||
* 00 cuando no se presiona ninguno de los botones
|
||||
* 01 cuando sólo se presiona el primer botón
|
||||
* 02 cuando sólo se presiona el segundo botón
|
||||
* 04 cuando sólo se pulsa el tercer botón
|
||||
* 04 cuando sólo se presiona el tercer botón
|
||||
|
||||
nota que al igual que el dispositivo controlador, este sistema nos permite comprobar si hay varios botones pulsados a la vez:
|
||||
nota que al igual que el dispositivo controlador, este sistema nos permite comprobar si hay varios botones presionados a la vez:
|
||||
|
||||
* 03 cuando el primer y el segundo botón están presionados
|
||||
* 05 cuando se pulsan el primer y el tercer botón
|
||||
* 06 cuando se pulsan el segundo y el tercer botón
|
||||
* 07 cuando se pulsan los tres botones
|
||||
* 05 cuando se presionan el primer y el tercer botón
|
||||
* 06 cuando se presionan el segundo y el tercer botón
|
||||
* 07 cuando se presionan los tres botones
|
||||
|
||||
recuerda que podemos utilizar las máscaras AND, tal y como se introdujo en el {tutorial de uxn día 3}, para aislar y evaluar por separado cualquiera de estos bits.
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ dependiendo del dispositivo, los valores pueden ser mayores que 0001 o menores q
|
|||
|
||||
el vector del ratón se disparará en cualquiera de los siguientes eventos:
|
||||
|
||||
* se ha pulsado un botón
|
||||
* se ha presionado un botón
|
||||
* se suelta un botón
|
||||
* el ratón se ha movido
|
||||
* la rueda del ratón se ha movido
|
||||
|
|
@ -75,21 +75,21 @@ el siguiente es un ejemplo simple que ilustra el uso de los siguientes elementos
|
|||
|
||||
* vector del ratón
|
||||
* coordenadas x e `y` del ratón
|
||||
* estado del ratón (pulsado o no pulsado)
|
||||
* estado del ratón (presionado o no presionado)
|
||||
|
||||
combinado con un condicional y el dibujo de un sprite.
|
||||
|
||||
dibuja nuestro cuadrado en la posición del ratón, cambiando su color cuando se pulsa cualquier botón del ratón.
|
||||
dibuja nuestro cuadrado en la posición del ratón, cambiando su color cuando se presiona cualquier botón del ratón.
|
||||
|
||||
=> ./img/screenshot_uxn-draw-with-mouse.png captura de pantalla que muestra un dibujo realizado con el programa: líneas onduladas compuestas por cuadrados superpuestos de dos colores diferentes
|
||||
|
||||
```
|
||||
( hola-raton.tal )
|
||||
( hola-ratón.tal )
|
||||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|90 @Raton [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|90 @Ratón [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|
||||
( init )
|
||||
|0100
|
||||
|
|
@ -99,19 +99,19 @@ dibuja nuestro cuadrado en la posición del ratón, cambiando su color cuando se
|
|||
#2ce5 .Sistema/b DEO2
|
||||
|
||||
( establecer vector del ratón )
|
||||
;en-raton .Raton/vector DEO2
|
||||
;en-ratón .Ratón/vector DEO2
|
||||
|
||||
( establecer dirección del sprite )
|
||||
;cuadrado .Pantalla/direc DEO2
|
||||
|
||||
BRK
|
||||
|
||||
@en-raton ( -> )
|
||||
.Raton/x DEI2 .Pantalla/x DEO2
|
||||
.Raton/y DEI2 .Pantalla/y DEO2
|
||||
@en-ratón ( -> )
|
||||
.Ratón/x DEI2 .Pantalla/x DEO2
|
||||
.Ratón/y DEI2 .Pantalla/y DEO2
|
||||
|
||||
( salta si se pulsa algún botón )
|
||||
.Raton/estado DEI ,&presionado JCN
|
||||
( salta si se presiona algún botón )
|
||||
.Ratón/estado DEI ,&presionado JCN
|
||||
|
||||
( dibujar sprite usando el color 2 y 0 en el fondo )
|
||||
#02 .Pantalla/sprite DEO
|
||||
|
|
@ -156,8 +156,8 @@ este es un programa que logra dibujar el puntero en la pantalla
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|90 @Raton [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|90 @Ratón [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|
||||
( página cero )
|
||||
|0000
|
||||
|
|
@ -171,14 +171,14 @@ este es un programa que logra dibujar el puntero en la pantalla
|
|||
#2ce5 .Sistema/b DEO2
|
||||
|
||||
( establecer el vector del ratón )
|
||||
;en-raton .Raton/vector DEO2
|
||||
;en-ratón .Ratón/vector DEO2
|
||||
|
||||
( establecer dirección del sprite )
|
||||
;puntero_icn .Pantalla/direc DEO2
|
||||
|
||||
BRK
|
||||
|
||||
@en-raton ( -> )
|
||||
@en-ratón ( -> )
|
||||
( envía la posición del puntero a la pantalla )
|
||||
.puntero/x LDZ2 .Pantalla/x DEO2
|
||||
.puntero/y LDZ2 .Pantalla/y DEO2
|
||||
|
|
@ -187,8 +187,8 @@ BRK
|
|||
#40 .Pantalla/sprite DEO
|
||||
|
||||
( actualizar la posición del puntero )
|
||||
.Raton/x DEI2 .puntero/x STZ2
|
||||
.Raton/y DEI2 .puntero/y STZ2
|
||||
.Ratón/x DEI2 .puntero/x STZ2
|
||||
.Ratón/y DEI2 .puntero/y STZ2
|
||||
|
||||
( enviar la posición del puntero a la pantalla )
|
||||
.puntero/x LDZ2 .Pantalla/x DEO2
|
||||
|
|
@ -211,13 +211,13 @@ este modo de mezcla te permitiría dibujar cosas en el plano de fondo y que el p
|
|||
|
||||
### algunos problemas
|
||||
|
||||
ahora, podemos ver que el programa funciona, pero está inundando la subrutina en-raton con mucho código.
|
||||
ahora, podemos ver que el programa funciona, pero está inundando la subrutina en-ratón con mucho código.
|
||||
|
||||
eso es aun mas cierto si consideramos que solo estamos dibujando el puntero, y no tomando ninguna otra acción, como responder a los botones.
|
||||
|
||||
crear una macro para todo este código podría ser posible, pero también poco práctico debido a la cantidad de código.
|
||||
|
||||
¿tal vez podríamos tener un JMP a otra sección del programa, que al final tiene otro JMP para c vnm a la posición correspondiente en la subrutina en-raton?
|
||||
¿tal vez podríamos tener un JMP a otra sección del programa, que al final tiene otro JMP para c vnm a la posición correspondiente en la subrutina en-ratón?
|
||||
|
||||
de hecho, eso es casi lo que haremos, pero con un elemento adicional de uxn: ¡su pila de retorno!
|
||||
|
||||
|
|
@ -247,8 +247,8 @@ en primer lugar, vamos a mover nuestra subrutina de dibujo de punteros a otra et
|
|||
#40 .Pantalla/sprite DEO
|
||||
|
||||
( actualizar la posición del puntero )
|
||||
.Raton/x DEI2 .puntero/x STZ2
|
||||
.Raton/y DEI2 .puntero/y STZ2
|
||||
.Ratón/x DEI2 .puntero/x STZ2
|
||||
.Ratón/y DEI2 .puntero/y STZ2
|
||||
|
||||
( enviar la posición del puntero a la pantalla )
|
||||
.puntero/x LDZ2 .Pantalla/x DEO2
|
||||
|
|
@ -263,24 +263,24 @@ notemos que podríamos unir las acciones de actualizar la posición del puntero
|
|||
|
||||
```
|
||||
( actualizar la posición del puntero y enviarla a la pantalla )
|
||||
.Raton/x DEI2 DUP2 .puntero/x STZ2 .Pantalla/x DEO2
|
||||
.Raton/y DEI2 DUP2 .puntero/y STZ2 .Pantalla/y DEO2
|
||||
.Ratón/x DEI2 DUP2 .puntero/x STZ2 .Pantalla/x DEO2
|
||||
.Ratón/y DEI2 DUP2 .puntero/y STZ2 .Pantalla/y DEO2
|
||||
```
|
||||
|
||||
esto dejaría nuestra subrutina en-raton vacía:
|
||||
esto dejaría nuestra subrutina en-ratón vacía:
|
||||
|
||||
```
|
||||
@en-raton( -> )
|
||||
@en-ratón( -> )
|
||||
|
||||
BRK
|
||||
```
|
||||
|
||||
### usando saltos normales
|
||||
|
||||
con lo que ya sabemos, y dependiendo de la posición de dibuja-puntero con respecto a en-raton, podríamos hacer un salto relativo:
|
||||
con lo que ya sabemos, y dependiendo de la posición de dibuja-puntero con respecto a en-ratón, podríamos hacer un salto relativo:
|
||||
|
||||
```
|
||||
@en-raton ( -> )
|
||||
@en-ratón ( -> )
|
||||
,dibuja-puntero JMP
|
||||
|
||||
&retorno
|
||||
|
|
@ -291,7 +291,7 @@ BRK
|
|||
o un salto absoluto:
|
||||
|
||||
```
|
||||
@en-raton ( -> )
|
||||
@en-ratón ( -> )
|
||||
;dibuja-puntero JMP2
|
||||
|
||||
&retorno
|
||||
|
|
@ -299,12 +299,12 @@ o un salto absoluto:
|
|||
BRK
|
||||
```
|
||||
|
||||
el detalle esta en que si queremos que ocurra algo más después de dibujar el puntero dentro de en-raton, no podemos atrás fácilmente.
|
||||
el detalle esta en que si queremos que ocurra algo más después de dibujar el puntero dentro de en-ratón, no podemos atrás fácilmente.
|
||||
|
||||
al final de nuestra subrutina dibuja-puntero, necesitaríamos "saltar hacia atrás" así:
|
||||
|
||||
```
|
||||
;en-raton/retornar JMP2
|
||||
;en-ratón/retornar JMP2
|
||||
```
|
||||
|
||||
funcionaría, pero no es la mejor forma.
|
||||
|
|
@ -324,7 +324,7 @@ en ambos casos, JSR empujará una dirección absoluta (2 bytes) hacia abajo en l
|
|||
por ejemplo, nuestros saltos podrían reescribirse de la siguiente manera. en el caso de un salto relativo:
|
||||
|
||||
```
|
||||
@en-raton ( -> )
|
||||
@en-ratón ( -> )
|
||||
,dibuja-puntero JSR
|
||||
|
||||
( algo más aquí )
|
||||
|
|
@ -336,7 +336,7 @@ BRK
|
|||
y en el caso de un salto absoluto:
|
||||
|
||||
```
|
||||
@en-raton ( -> )
|
||||
@en-ratón ( -> )
|
||||
;dibuja-puntero JSR2
|
||||
|
||||
( algo más aquí )
|
||||
|
|
@ -414,8 +414,8 @@ este es el programa hola-puntero.tal, pero utilizando dibuja-puntero como subrut
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|90 @Raton [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &pad $2 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|90 @Ratón [ &vector $2 &x $2 &y $2 &estado $1 &pad $3 &despx $2 &despy $2 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
|
@ -432,14 +432,14 @@ este es el programa hola-puntero.tal, pero utilizando dibuja-puntero como subrut
|
|||
#2ce5 .Sistema/b DEO2
|
||||
|
||||
( establecer el vector del ratón )
|
||||
;en-raton .Raton/vector DEO2
|
||||
;en-ratón .Ratón/vector DEO2
|
||||
|
||||
( establecer dirección del sprite )
|
||||
;puntero_icn .Pantalla/direc DEO2
|
||||
|
||||
BRK
|
||||
|
||||
@en-raton ( -> )
|
||||
@en-ratón ( -> )
|
||||
;dibuja-puntero JSR2 ( o ,dibuja-puntero JSR )
|
||||
|
||||
( algo más )
|
||||
|
|
@ -454,8 +454,8 @@ BRK
|
|||
#40 .Pantalla/sprite DEO
|
||||
|
||||
( actualizar la posición del puntero )
|
||||
.Raton/x DEI2 .puntero/x STZ2
|
||||
.Raton/y DEI2 .puntero/y STZ2
|
||||
.Ratón/x DEI2 .puntero/x STZ2
|
||||
.Ratón/y DEI2 .puntero/y STZ2
|
||||
|
||||
( enviar la posición del puntero a la pantalla )
|
||||
.puntero/x LDZ2 .Pantalla/x DEO2
|
||||
|
|
@ -536,8 +536,8 @@ un signo de intercalación (^) después de un nombre de valor indica que corresp
|
|||
( almacenar la longitud y el conteo )
|
||||
STH2 ( pt: / pr: longitud conteo )
|
||||
|
||||
( dibujar pixel con color 2 )
|
||||
#02 .Pantalla/pixel DEO
|
||||
( dibujar píxel con color 2 )
|
||||
#02 .Pantalla/píxel DEO
|
||||
|
||||
( incrementar x )
|
||||
.Pantalla/x DEI2 INC2 .Pantalla/x DEO2
|
||||
|
|
@ -746,7 +746,7 @@ puedes tener diferentes "modos" seleccionables: tal vez cambien el pincel que es
|
|||
|
||||
considera cómo seleccionarías esos modos: ¿botones en pantalla? ¿teclas del teclado? ¿acordes con los botones del ratón?
|
||||
|
||||
ten en cuenta que puedes cambiar el vector de un dispositivo durante el tiempo de ejecución: podrías tener una subrutina en-raton diferente dependiendo del modo que hayas seleccionado :)
|
||||
ten en cuenta que puedes cambiar el vector de un dispositivo durante el tiempo de ejecución: podrías tener una subrutina en-ratón diferente dependiendo del modo que hayas seleccionado :)
|
||||
|
||||
¿cómo podrías utilizar la rueda del ratón como ayuda para dibujar?
|
||||
|
||||
|
|
|
|||
|
|
@ -31,15 +31,15 @@ empecemos con el siguiente programa como plantilla. incluye los datos para un sp
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
@configuracion
|
||||
@configuración
|
||||
( establecer los colores del sistema )
|
||||
#2ce9 .Sistema/r DEO2
|
||||
#01c0 .Sistema/g DEO2
|
||||
|
|
@ -79,7 +79,7 @@ el segundo paso, añadir 8 a x, ya lo sabemos:
|
|||
|
||||
```
|
||||
.Pantalla/x DEI2 #0008 ADD2 ( añadir 8 a x )
|
||||
.Pantalla/x DEO2 ( guardar la nueva x )
|
||||
.Pantalla/x DEO2 ( almacenar nueva x )
|
||||
```
|
||||
|
||||
comprobar si x es menor que el límite, saltando si lo es, sería algo así:
|
||||
|
|
@ -100,7 +100,7 @@ integrando todo ello, podríamos obtener:
|
|||
#03 .Pantalla/sprite DEO ( dibujar sprite de 1bpp con color 3 y 0 )
|
||||
.Pantalla/x DEI2 #0008 ADD2 ( añadir 8 a la x )
|
||||
DUP2 ( duplicar la nueva x )
|
||||
.Pantalla/x DEO2 ( guardar la nueva x )
|
||||
.Pantalla/x DEO2 ( almacenar nueva x )
|
||||
.Pantalla/ancho DEI2 ( obtener el límite )
|
||||
LTH2 ,&bucle-x JCN ( saltar si x es menor que el límite )
|
||||
```
|
||||
|
|
@ -175,15 +175,15 @@ lo siguiente muestra nuestro programa en contexto, llenando completamente la pri
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
@configuracion
|
||||
@configuración
|
||||
( establecer los colores del sistema )
|
||||
#2ce9 .Sistema/r DEO2
|
||||
#01c0 .Sistema/g DEO2
|
||||
|
|
@ -420,7 +420,7 @@ adicionalmente, guardaré el color en la pila de retorno:
|
|||
|
||||
```
|
||||
@dibuja-pala ( x^ y^ color -- )
|
||||
( guardar color )
|
||||
( almacenar color )
|
||||
STH
|
||||
|
||||
( establecer `y` y x iniciales )
|
||||
|
|
@ -571,8 +571,8 @@ omitiendo la definición de las subrutinas dibuja-fondo y dibuja-pala, y como fo
|
|||
|
||||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1 &x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
|
@ -592,7 +592,7 @@ omitiendo la definición de las subrutinas dibuja-fondo y dibuja-pala, y como fo
|
|||
|
||||
( programa principal )
|
||||
|0100
|
||||
@configuracion
|
||||
@configuración
|
||||
( establecer los colores del sistema )
|
||||
#2ce9 .Sistema/r DEO2
|
||||
#01c0 .Sistema/g DEO2
|
||||
|
|
@ -676,13 +676,13 @@ todo esto puede ir dentro de su propia subrutina para facilitar la lectura:
|
|||
@actualiza-palas ( -- )
|
||||
&izquierda
|
||||
( pala izquierda: botones arriba y abajo )
|
||||
.Controlador/boton DEI
|
||||
.Controlador/botón DEI
|
||||
DUP #10 AND ( comprobar bit para arriba )
|
||||
,&izquierda-arriba JCN
|
||||
DUP #20 AND ( comprobar bit para abajo )
|
||||
&izquierda-abajo JCN
|
||||
|
||||
&derecha JMP ( salta si no se ha pulsado ninguno de los dos )
|
||||
&derecha JMP ( salta si no se ha presionado ninguno de los dos )
|
||||
|
||||
&izquierda-arriba
|
||||
.izquierda/y LDZ2 VEL-PALA SUB2 .izquierda/y STZ2
|
||||
|
|
@ -698,7 +698,7 @@ todo esto puede ir dentro de su propia subrutina para facilitar la lectura:
|
|||
DUP #02 AND ( comprobar bit para B )
|
||||
&derecha-abajo JCN
|
||||
|
||||
&fin JMP ( salta si no se ha pulsado ninguno de los dos )
|
||||
&fin JMP ( salta si no se ha presionado ninguno de los dos )
|
||||
|
||||
&derecha-arriba
|
||||
.derecha/y LDZ2 VEL-PALA SUB2 .derecha/y STZ2
|
||||
|
|
@ -990,7 +990,7 @@ basándonos en lo que acabamos de discutir, podemos empezar nuestra subrutina ac
|
|||
( obtener velocidad-x y `x` )
|
||||
.pelota/vel-x LDZ2 .pelota/x LDZ2
|
||||
ADD2 ( sumar ambas cosas )
|
||||
.pelota/x STZ2 ( guarda la nueva x )
|
||||
.pelota/x STZ2 ( almacenar nueva x )
|
||||
|
||||
( obtener velocidad-y e `y` )
|
||||
.pelota/vel-y LDZ2 .pelota/y LDZ2
|
||||
|
|
@ -1098,7 +1098,7 @@ nuestra subrutina actualiza-pelota tiene el siguiente aspecto hasta el momento:
|
|||
( obtener velocidad-x y x )
|
||||
.pelota/vel-x LDZ2 .pelota/x LDZ2
|
||||
ADD2 ( sumar ambas cosas )
|
||||
.pelota/x STZ2 ( guardar la nueva x )
|
||||
.pelota/x STZ2 ( almacenar nueva x )
|
||||
|
||||
( actualizar y )
|
||||
( obtener velocidad-y e `y` )
|
||||
|
|
@ -1302,8 +1302,8 @@ aquí está todo el código que hemos escrito hoy:
|
|||
( dispositivos )
|
||||
|00 @Sistema [ &vector $2 &pad $6 &r $2 &g $2 &b $2 ]
|
||||
|20 @Pantalla [ &vector $2 &ancho $2 &alto $2 &auto $1 &pad $1
|
||||
&x $2 &y $2 &direc $2 &pixel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &boton $1 &tecla $1 ]
|
||||
&x $2 &y $2 &direc $2 &píxel $1 &sprite $1 ]
|
||||
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
|
||||
|
||||
( macros )
|
||||
%RTN { JMP2r }
|
||||
|
|
@ -1331,7 +1331,7 @@ aquí está todo el código que hemos escrito hoy:
|
|||
|
||||
( configuración )
|
||||
|0100
|
||||
@configuracion ( -> )
|
||||
@configuración ( -> )
|
||||
( establecer los colores del sistema )
|
||||
#2ce9 .Sistema/r DEO2
|
||||
#01c0 .Sistema/g DEO2
|
||||
|
|
@ -1411,12 +1411,12 @@ RTN
|
|||
( obtener velocidad-x y x )
|
||||
.pelota/vel-x LDZ2 .pelota/x LDZ2 ( obtener x )
|
||||
ADD2 ( sumar ambas cosas )
|
||||
.pelota/x STZ2 ( guardar la nueva x )
|
||||
.pelota/x STZ2 ( almacenar nueva x )
|
||||
|
||||
( obtener velocidad-y e `y` )
|
||||
.pelota/vel-y LDZ2 .pelota/y LDZ2 ( obtener y )
|
||||
ADD2 ( sumar ambas cosas )
|
||||
.pelota/y STZ2 ( guardar la nueva y )
|
||||
.pelota/y STZ2 ( almacenar nueva y )
|
||||
|
||||
( comprobar colisiones con las paredes )
|
||||
&verif-pared-sup
|
||||
|
|
@ -1546,13 +1546,13 @@ RTN
|
|||
@actualiza-palas ( -- )
|
||||
&izquierda
|
||||
( pala izquierda: botones arriba 10 y abajo 20 )
|
||||
.Controlador/boton DEI
|
||||
.Controlador/botón DEI
|
||||
DUP #10 AND ( comprobar bit para arriba )
|
||||
,&izquierda-arriba JCN
|
||||
DUP #20 AND ( comprobar bit para abajo )
|
||||
,&izquierda-abajo JCN
|
||||
|
||||
,&derecha JMP ( salta si no se ha pulsado ninguno de los dos )
|
||||
,&derecha JMP ( salta si no se ha presionado ninguno de los dos )
|
||||
|
||||
&izquierda-arriba
|
||||
.izquierda/y LDZ2 VEL-PALA SUB2 .izquierda/y STZ2
|
||||
|
|
@ -1568,7 +1568,7 @@ RTN
|
|||
DUP #02 AND ( comprobar bit para B )
|
||||
,&derecha-abajo JCN
|
||||
|
||||
,&fin JMP ( salta si no se ha pulsado ninguno de los dos )
|
||||
,&fin JMP ( salta si no se ha presionado ninguno de los dos )
|
||||
|
||||
&derecha-arriba
|
||||
.derecha/y LDZ2 VEL-PALA SUB2 .derecha/y STZ2
|
||||
|
|
@ -1585,7 +1585,7 @@ RTN
|
|||
|
||||
```
|
||||
@dibuja-pala ( x^ y^ color -- )
|
||||
( guardar color )
|
||||
( almacenar color )
|
||||
STH
|
||||
|
||||
( establecer `y` y x iniciales )
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ el dispositivo de archivo en el ordenador varvara nos permite leer y escribir en
|
|||
sus puertos se definen normalmente de la siguiente manera:
|
||||
|
||||
```
|
||||
|a0 @Archivo [ &vector $2 &exito $2 &estad $2 &borrar $1 &adjuntar $1 &nombre $2 &largo $2 &leer $2 &escribir $2 ]
|
||||
|a0 @Archivo [ &vector $2 &éxito $2 &estad $2 &borrar $1 &adjuntar $1 &nombre $2 &largo $2 &leer $2 &escribir $2 ]
|
||||
```
|
||||
|
||||
* el corto vector no se utiliza actualmente
|
||||
|
|
@ -51,9 +51,9 @@ podemos usar una estructura como la siguiente, donde el nombre del archivo y la
|
|||
;archivo/datos .Archivo/lectura DEO2
|
||||
|
||||
( comprobar el byte éxito y saltar según corresponda )
|
||||
Archivo/exito DEI2 #0000 EQU2 ,&fallo JCN
|
||||
Archivo/éxito DEI2 #0000 EQU2 ,&fallo JCN
|
||||
|
||||
&exito
|
||||
&éxito
|
||||
LIT 'Y .Consola/escribir DEO
|
||||
RTN
|
||||
|
||||
|
|
@ -68,9 +68,9 @@ RTN
|
|||
|
||||
nótese que para el nombre del archivo estamos usando la runa de cadena cruda o `raw` (") que nos permite escribir varios caracteres en la memoria del programa hasta encontrar un espacio en blanco.
|
||||
|
||||
en este ejemplo estamos escribiendo un carácter en la consola en función de que el corto `exito` sea cero o no, pero podríamos decidir realizar cualquier acción que consideremos apropiada.
|
||||
en este ejemplo estamos escribiendo un carácter en la consola en función de que el corto `éxito` sea cero o no, pero podríamos decidir realizar cualquier acción que consideremos apropiada.
|
||||
|
||||
además, en este ejemplo no nos preocupa realmente cuántos bytes se han leído realmente: ¡tenga en cuenta que esta información se almacena en Archivo/exito hasta que se produzca otra lectura o escritura!
|
||||
además, en este ejemplo no nos preocupa realmente cuántos bytes se han leído realmente: ¡tenga en cuenta que esta información se almacena en Archivo/éxito hasta que se produzca otra lectura o escritura!
|
||||
|
||||
es importante recordar que, como siempre en este contexto, estamos tratando con bytes crudos.
|
||||
|
||||
|
|
@ -97,9 +97,9 @@ el siguiente programa escribirá "hola" y una nueva línea (0a) en un archivo ll
|
|||
;archivo/datos .Archivo/escribir DEO2
|
||||
|
||||
( leer y evaluar el byte éxito )
|
||||
.Archivo/exito DEI2 #0006 NEQ2 ,&fallo JCN
|
||||
.Archivo/éxito DEI2 #0006 NEQ2 ,&fallo JCN
|
||||
|
||||
&exito
|
||||
&éxito
|
||||
LIT 'Y .Consola/escribir DEO
|
||||
RTN
|
||||
|
||||
|
|
@ -139,9 +139,9 @@ podríamos adaptar nuestra subrutina anterior para cargar el archivo de temas y
|
|||
;tema/datos .Archivo/cargar DEO2
|
||||
|
||||
( comprobar el byte éxito y saltar según corresponda )
|
||||
.Archivo/exito DEI2 #0006 NEQ2 ,&fallo JCN
|
||||
.Archivo/éxito DEI2 #0006 NEQ2 ,&fallo JCN
|
||||
|
||||
&exito
|
||||
&éxito
|
||||
( establecer los colores del sistema a partir de los datos leídos )
|
||||
;tema/r LDA2 .Sistema/r DEO2
|
||||
;tema/g LDA2 .Sistema/g DEO2
|
||||
|
|
@ -177,9 +177,9 @@ y para hacer la operación contraria, podemos leer los colores del sistema en nu
|
|||
;tema/datos .Archivo/guardar DEO2
|
||||
|
||||
( comprobar el byte de éxito y saltar según corresponda )
|
||||
.Archivo/exito DEI2 #0006 NEQ2 ,&fallo JCN
|
||||
.Archivo/éxito DEI2 #0006 NEQ2 ,&fallo JCN
|
||||
|
||||
&exito
|
||||
&éxito
|
||||
( ¿informar el éxito? )
|
||||
RTN
|
||||
|
||||
|
|
@ -198,7 +198,7 @@ el dispositivo fechahora (o "datetime") puede ser útil para el cronometraje de
|
|||
tiene varios campos que podemos leer, todos ellos basados en la hora del sistema actual y la zona horaria:
|
||||
|
||||
```
|
||||
|b0 @FechaHora [ &ano $2 &mes $1 &dia $1 &hora $1 &minuto $1 &segundo $1 &ddls $1 &dda $2 &eshdv $1 ]
|
||||
|b0 @FechaHora [ &año $2 &mes $1 &día $1 &hora $1 &minuto $1 &segundo $1 &ddls $1 &dda $2 &eshdv $1 ]
|
||||
```
|
||||
|
||||
* el byte año corresponde al número de año de la llamada era común
|
||||
|
|
@ -234,10 +234,10 @@ por fin, ¡el dispositivo de audio! o debería decir, ¡los dispositivos de audi
|
|||
varvara tiene cuatro dispositivos estéreo idénticos (o "canales"), que se mezclan antes de pasar a los altavoces/auriculares:
|
||||
|
||||
```
|
||||
|30 @Audio0 [ &vector $2 &posicion $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|40 @Audio1 [ &vector $2 &posicion $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|50 @Audio2 [ &vector $2 &posicion $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|60 @Audio3 [ &vector $2 &posicion $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|30 @Audio0 [ &vector $2 &posición $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|40 @Audio1 [ &vector $2 &posición $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|50 @Audio2 [ &vector $2 &posición $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|60 @Audio3 [ &vector $2 &posición $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
```
|
||||
|
||||
de forma similar a como en el dispositivo de pantalla podemos dibujar apuntando a direcciones con datos de sprite, en los dispositivos de audio podremos reproducir sonidos apuntando a direcciones con datos de audio (muestras o "samples").
|
||||
|
|
@ -273,7 +273,7 @@ el ejemplo piano.tal en el repositorio uxn, tiene varios de ellos, todos de 256
|
|||
3d3c 3b3a 3a39 3838 3839 393a 3c3e 4146
|
||||
4a50 575b 6064 686a 6e70 7274 7677 7a7d
|
||||
|
||||
@violin-pcm
|
||||
@violín-pcm
|
||||
8186 8d94 9ba0 a3a7 acb1 b5bc c2c7 cacc
|
||||
cecf d0d1 d3d5 d8db dee1 e3e5 e6e5 e5e3
|
||||
dfdc d7d0 c8c2 bbb2 a99f 968c 847c 746e
|
||||
|
|
@ -406,7 +406,7 @@ en teoría, parecería que el siguiente programa debería reproducir nuestra mue
|
|||
( hola-sonido.tal )
|
||||
|
||||
( dispositivos )
|
||||
|30 @Audio0 [ &vector $2 &posicion $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|30 @Audio0 [ &vector $2 &posición $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
|
|
@ -472,7 +472,7 @@ ok, ¡ahora estamos listos para reproducir el sonido!
|
|||
( hola-sonido.tal )
|
||||
|
||||
( dispositivos )
|
||||
|30 @Audio0 [ &vector $2 &posicion $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|30 @Audio0 [ &vector $2 &posición $2 &salida $1 &pad $3 &adsr $2 &largo $2 &direc $2 &volumen $1 &tono $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100
|
||||
|
|
|
|||
Loading…
Reference in New Issue