# tutorial de uxn: día 3, saltos condicionales y el teclado o controlador
lang=es en->{uxn tutorial day 3}
¡esta es la tercera sección del {tutorial de uxn}!

aquí introducimos el uso del dispositivo controlador en la computadora uxn varvara: esto nos permitirá añadir interactividad a nuestros programas y empezar a discutir el flujo de control en uxntal.

también hablamos de las instrucciones lógicas y de manipulación de la pila en uxntal.

# el dispositivo controlador

el dispositivo controlador del ordenador varvara nos permite leer las entradas del teclado o de los botones del controlador.

la definición de sus puertos tendría el siguiente aspecto en un programa típico:

```
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]
```

## el byte de botón

el byte de botón codifica en cada uno de sus ocho bits el estado de ocho "botones" diferentes, basados en la disposición del controlador de NES, la videoconsola clásica de 8 bits de Nintendo.

=> https://wiki.nesdev.com/w/index.php/Standard_controller controlador NES estándar

numerando los bits de derecha a izquierda y de 0 a 7, las teclas correspondientes (y los botones de NES) son

+ <table>
+ <tr><th>bit</th><th>tecla</th><th>botón</th></tr>
+ <tr><td class="num">7</td><td colspan="2">Derecha</td></tr>
+ <tr><td class="num">6</td><td colspan="2">Izquierda</td></tr>
+ <tr><td class="num">5</td><td colspan="2">Abajo</td></tr>
+ <tr><td class="num">4</td><td colspan="2">Arriba</td></tr>
+ <tr><td class="num">3</td><td>Home</td><td>Iniciar</td></tr>
+ <tr><td class="num">2</td><td>Shift</td><td>Selecccionar</td></tr>
+ <tr><td class="num">1</td><td>Alt</td><td>B</td></tr>
+ <tr><td class="num">0</td><td>Ctrl</td><td>A</td></tr>
+ </table>
& * 7: Derecha
& * 6: Izquierda
& * 5: Abajo
& * 4: Arriba
& * 3: Home (Iniciar)
& * 2: Shift (Selecccionar)
& * 1: Alt (botón B)
& * 0: Ctrl (botón A)

codificar los estados de los botones de esta manera nos permite presionar y leer muchas de estas teclas al mismo tiempo.

## el byte de tecla

el byte de tecla almacena el código ascii de la tecla del teclado que se está pulsando en ese momento.

la diferencia entre el byte 'de tecla' y el byte 'de botón' puede ser confusa, especialmente cuando se ejecuta varvara desde uxnemu, donde varias teclas actúan además de botones.

una posible manera de recordar podría ser pensar en el byte 'de botón' como refiriéndose a un controlador de gamepad.

## el vector del controlador

en el contexto de la programación de uxn, un vector se refiere a una dirección en la memoria principal donde se asigna a uxn para que salte cuando ocurra un evento específico.

en el caso del vector del controlador, este evento específico consiste en cada vez que se pulsa o suelta una tecla.

en otras palabras: uxn saltará a la dirección asignada como vector del controlador, cada vez que se pulse o suelte una tecla.

la siguiente línea de código asignaría ese vector, utilizando la dirección absoluta de la etiqueta en-controlador:

```
;en-controlador .Controlador/vector DEO2
```

¡veamos a continuación como funcionaría!

# flujo de control: subrutinas vectoriales

hasta ahora nuestros programas uxntal han seguido un flujo lineal: comienzan en la dirección 0100 y terminan en la primera instrucción BRK que se encuentra.

podemos pensar en estos programas como rutinas de configuración: configuran los colores del sistema, pueden dibujar o imprimir algunas cosas y luego dejan a uxn esperando. ¿qué estaría esperando uxn?

sí, una opción sería: ¡esperar la entrada del teclado!

vamos a empezar a organizar nuestros programas uxntal en términos de subrutinas que corresponden a diferentes vectores.

cada una de estas subrutinas terminará con la instrucción BRK, para que puedan hacer que uxn vuelva al estado de espera.

## subrutina del vector del controlador

para ilustrar ese comportamiento, leamos el siguiente programa.

este utiliza el procedimiento de dibujo de sprites que probamos el día anterior, pero hace que ocurra solo cuando se pulsa una tecla. al principio, la pantalla está vacía, y cuando pulsamos una tecla, se dibuja un cuadrado:

```
( hola-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 &píxel $1 &sprite $1 ]
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]

( programa principal )
|0100
      ( establecer los colores del sistema )
      #2ce9 .Sistema/r DEO2
      #01c0 .Sistema/g DEO2
      #2ce5 .Sistema/b DEO2

      ( asignar vector del controlador )
      ;en-controlador .Controlador/vector DEO2
BRK

( ejecutar este código cada vez que se pulse o suelte una tecla )
@en-controlador ( -> )
      ( establecer coordenadas x,y )
      #0008 .Pantalla/x DEO2
      #0008 .Pantalla/y DEO2

      ( establecer la direccion del sprite )
      ;cuadrado .Pantalla/direc DEO2

      ( dibujar el sprite en el fondo )
      ( usando el color 1 para el contorno )
      #01 .Pantalla/sprite DEO
BRK

( sprite )
@cuadrado ff81 8181 8181 81ff
```

bonito, ¿no?

ahora, ¿cómo podemos realizar diferentes acciones dependiendo de la tecla que se haya pulsado?

en primer lugar, tenemos que hacer que nuestro programa sepa qué tecla se ha pulsado para que pueda actuar en consecuencia.

para ello, veamos algunas instrucciones uxntal nuevas.

# instrucciones de comparación y lógica

## instrucciones de comparación

uxntal tiene cuatro instrucciones para comparar los dos primeros elementos de la pila:

* EQU: empuja 01 hacia abajo en la pila si los dos elementos superiores de la pila son iguales, o empuja 00 en caso contrario ( a b -- a==b )
* NEQ: empuja 01 hacia abajo en la pila si los dos elementos superiores de la pila no son iguales, o empuja 00 en caso contrario ( a b -- a!=b )
* GTH: empuja 01 hacia abajo en la pila si el primer elemento es mayor que el segundo, o empuja 00 en caso contrario ( a b -- a>b )
* LTH: empuja 01 hacia abajo en la pila si el primer elemento es menor que el segundo, o empuja 00 en caso contrario ( a b -- a<b )

podemos pensar en los resultados empujados por estas instrucciones como banderas booleanas: son 01 si la comparación fue verdadera y son 00 si fue falsa.

el siguiente código leerá el valor de la tecla del controlador y empujará a la pila una bandera correspondiente a que sea igual al carácter 'a':

```
.Controlador/tecla DEI ( lee la tecla y la empuja hacia abajo en la pila )
LIT "a ( empuja el código ascii del carácter 'a' )
EQU ( compara ambos bytes y empuja 01 si son iguales, 00 si no )
```

EQU2, NEQ2, GTH2 y LTH2 funcionarán de la misma manera, pero comparando cortos en lugar de bytes.

## instrucciones lógicas

uxntal tiene tres instrucciones lógicas a nivel de bit.

pueden funcionar como operadores lógicos que utilizan como operandos las banderas dadas por las instrucciones de comparación que hemos comentado anteriormente:

* AND: realiza un AND a nivel de bits con los dos elementos superiores de la pila y empuja el resultado ( a b -- a&b )
* ORA: realiza un OR a nivel de bits con los dos primeros elementos de la pila y empuja el resultado ( a b -- a|b )
* EOR: realiza un OR exclusivo a nivel de bits con los dos primeros elementos de la pila y empuja hacia abajo el resultado ( a b -- a^b )

AND2, ORA2, EOR2 funcionarán de la misma manera, pero con cortos en lugar de bytes.

### AND

lo siguiente empujará hacia abajo en la pila una bandera que indica si el byte tecla está entre 30 y 39 inclusive, usando 01 para representar 'verdadero' y 00 para representar 'falso':

```
.Controlador/tecla DEI ( lee la tecla y la introduce en la pila )
#2f GTH ( ¿es mayor que 2f? empuja la bandera a la pila )
Controlador/tecla DEI ( lee la tecla y la introduce en la pila )
#3a LTH ( ¿es menor que 3a? empuja la bandera a la pila )
AND ( aplica un AND a las banderas de la pila y empuja el resultado a la pila )
```

que la instrucción sea a nivel de bit (o "bitwise") significa que aplica la operación AND a cada uno de los bits de los operandos.

si ambas banderas fueran "verdaderas":

```
    0000 0001 ( verdadero )
AND 0000 0001 ( verdadero )
   ----------
    0000 0001 ( verdadero )
```

si alguno (o ambos) de los indicadores fuera "falso":

```
    0000 0001 ( verdadero )
AND 0000 0000 ( falso )
   ----------
    0000 0000 ( falso )
```

como estos indicadores solo utilizan el bit menos significativo (el bit más a la derecha) para codificar su valor, un AND a nivel de bits es equivalente a un AND lógico convencional.

### OR

el siguiente código empujará una bandera hacia abajo en la pila si el byte tecla es '1' o 'a':

```
.Controlador/tecla DEI ( lee la tecla y la empuja a la pila )
LIT "1 EQU ( ¿es '1'? empuja la bandera a la pila )
.Controlador/tecla DEI ( lee la tecla y empujar a la pila )
LIT "a EQU ( ¿es 'a'? empuja la bandera a la pila )
ORA ( aplica un OR a las banderas en la pila y empuja el resultado en la pila )
```

cuando alguna o ambas banderas son verdaderas, la bandera será verdadera:

```
   0000 0001 ( verdadero )
OR 0000 0000 ( falso )
  ----------
   0000 0001 ( verdadero )
```

solo cuando ambas banderas sean falsas, la bandera resultante será falsa.

### EOR

un "exclusive-OR", o también "o-exclusivo", es una operación lógica que tiene un resultado de verdadero solo cuando una u otra entrada es verdadera. si ambas entradas son verdaderas, o si ambas entradas son falsas, el resultado es falso.

basándose en este comportamiento, esta instrucción puede utilizarse para invertir el valor de una bandera utilizando un valor especial en el que el o los bits que queremos invertir se pongan a 1. este tipo de valores se llaman máscaras.

por ejemplo, el siguiente código empujará una bandera correspondiente a que la tecla sea mayor o igual a 20, calculando primero si es menor que 20 y luego invirtiendo el resultado:

```
.Controlador/tecla DEI ( lee la tecla y la empuja a la pila )
#20 LTH ( ¿es menor que 20? empuja la bandera a la pila )
#01 EOR ( invierte el bit más a la derecha de la bandera y empuja el resultado a la pila )
```

cuando la bandera original es verdadera, lo que significa que el valor de la tecla es menor que 20, el EOR la invertirá y la hará falsa: el valor NO es mayor o igual que 20:

```
    0000 0001 ( verdadero )
EOR 0000 0001 ( máscara )
   ----------
    0000 0000 ( falso )
```

como podemos ver, debido a que los dos bits de entrada son 1, el bit de salida es 0.

cuando la bandera original es falsa, lo que significa que el valor NO es menor que 20, el EOR lo invertirá y lo hará verdadero: el valor es mayor o igual que 20:

```
    0000 0000 ( falso )
EOR 0000 0001 ( máscara )
   ----------
    0000 0001 ( verdadero )
```

observa que la máscara es la misma y el resultado es el valor opuesto de la bandera.

# flujo de control: saltos condicionales

ok, ahora nuestros programas pueden identificar y almacenar en banderas si un valor (como la tecla de teclado leída) es un valor específico, o dentro de algún rango.

¿cómo podemos usar estas banderas para tener comportamientos condicionales en nuestros programas, donde se toman diferentes acciones dependiendo de los resultados?

¡introduzcamos otro conjunto de nuevas instrucciones para que uxn rompa su flujo lineal!

## instrucciones para saltos

* JMP: "jump" o salto incondicional a la dirección de la pila ( direc -- )
* JCN: "conditional jump" o salto condicional: toma una dirección y un valor de la pila, y si el valor no es 00, salta a la dirección; en caso contrario continúa con la siguiente instrucción ( valor direc -- )

en modo byte, las direcciones que utilizan estas instrucciones son de un byte.

estas direcciones de un byte son relativas y pueden considerarse positivas y negativas: indican cuántos bytes hay que saltar en la memoria principal desde la posición actual del contador de programa, ya sea hacia delante (positivo) o hacia atrás (negativo). el rango de estas direcciones relativas es de -128 a 127 inclusive.

en modo corto, las direcciones que toman estas instrucciones son absolutas (es decir, de dos bytes de longitud), pero el valor que toma JCN para decidir sigue siendo un byte.

## runas para direcciones

hay varias runas que se refieren a direcciones y etiquetas. uxnasm las lee y las convierte a los valores binarios correspondientes.

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:

### direcciones literales

* dirección literal en la página cero: .etiqueta (un byte)
* dirección literal en memoria principal: ;etiqueta (un corto)
* dirección literal relativa en la memoria principal: ,etiqueta (un byte)

### direcciones crudas

existe un conjunto más avanzado de runas que nos permiten usar las direcciones crudas ("raw"), es decir sin LIT o LIT2 implícitos:

* dirección cruda en la página cero: -etiqueta (un byte)
* dirección cruda en la memoria principal: =etiqueta (un corto)
* dirección relativa cruda en la memoria principal: _etiqueta (un byte)

### etiquetas

para definir las etiquetas, utilizamos:

* definición de etiquetas: @etiqueta
* definición de la subetiqueta: &subetiqueta, donde esta subetiqueta será "hije" de la etiqueta previamente definida

y finalmente, para referirse a las etiquetas dentro de nuestro código uxntal, tenemos los siguientes casos:

* para una etiqueta principal: utilizar el nombre de la etiqueta
* para una subetiqueta: utilizar etiqueta/subetiqueta
* para una subetiqueta local: utilizar &subetiqueta

## salto condicional

¡unamos todo esto!

la siguiente subrutina en-controlador ilustra el uso de los saltos, dibujando nuestro sprite solo cuando la tecla que se pulsó fue '1':

```
@en-controlador
      .Controlador/tecla DEI ( lee la tecla )
      LIT "1 EQU ( ¿es '1'? )

      ( salta a dibuja-sprite si es el caso )
      ,&dibuja-sprite JCN

      ,&fin JMP ( si no, salta al final )

      &dibuja-sprite
        ( fijar coordenadas x,y )
        #0008 .Pantalla/x DEO2
        #0008 .Pantalla/y DEO2

        ( establece la dirección del sprite )
        ;cuadrado .Pantalla/direc DEO2

        ( dibuja el sprite en el fondo )
        ( usando el color 1 para el contorno )
        #01 .Pantalla/sprite DEO

      &fin
BRK
```

nota el uso de subetiquetas "dentro" (después) de en-controlador.

también nota como la expresión ,&subetiqueta corresponde a la dirección relativa (,) que se necesita para saltar a esa ubicación en el código nombrado con una subetiqueta local (&).

estas direcciones relativas, de un byte, son utilizadas por JCN o JMP.

## saltos condicionales

el siguiente código ilustra el uso de muchas condiciones: el color del sprite cambia según se pulsen las teclas 1, 2 o 3.

```
@en-controlador
      ( establecer coordenadas x,y )
      #0008 .Pantalla/x DEO2
      #0008 .Pantalla/y DEO2

      ( establecer direccion del sprite )
      ;cuadrado .Pantalla/direc DEO2

      .Controlador/tecla DEI LIT "1 EQU ( ¿es la tecla '1'? )
      ,&color-1 JCN ( salta al color-1 si es el caso )

      .Controlador/tecla DEI LIT "2 EQU ( ¿es la tecla '2'? )
      ,&color-2 JCN ( salta al color-2 si es el caso )

      .Controlador/tecla DEI LIT "3 EQU ( ¿es la tecla '3'? )
      ,&color-3 JCN ( salta al color-3 si es el caso )

      ( en cualquier otro caso, terminar )
      BRK

      &color-1
        ( dibujar el sprite en el fondo )
        ( usando el color 1 para el contorno )
        #01 .Pantalla/sprite DEO
      BRK

      &color-2
        ( dibujar sprite en el fondo )
        ( usando el color 2 para el contorno )
        #02 .Pantalla/sprite DEO
      BRK

      &color-3
        ( dibujar sprite en el fondo )
        ( usando el color 3 para el contorno )
        #03 .Pantalla/sprite DEO
      BRK
BRK
```

observa cómo las condiciones se escriben una tras otra: siempre que una bandera es falsa, JCN permite a uxn continuar con la siguiente instrucción en memoria.

también nota que este código no está optimizado para el tamaño o la velocidad, sino para la legibilidad.

estaría en ti, 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

hasta ahora hemos estado usando la pila como un lugar para almacenar operandos de instrucciones y sus resultados, ¡pero aún no hemos usado todo el potencial de este entorno basado en pila!

## instrucciones de pila

uxntal tiene seis instrucciones que actúan sobre los elementos de la pila más cercanos a la parte superior:

* POP: eliminar el elemento superior de la pila ( a -- )
* DUP: duplicar; empujar una copia del elemento superior ( a -- a a )
* SWP: "swap" o intercambiar; cambiar el orden de los dos primeros elementos de la pila ( a b -- b a )
* NIP: elimina el segundo elemento superior de la pila ( a b -- b )
* OVR: "over" o encima; empuja una copia del segundo elemento superior ( a b -- a b a )
* ROT: rotar; reordenar los tres primeros elementos de la pila de forma que el tercero esté ahora en la parte superior ( a b c -- b c a )

en modo corto, POP2, DUP2, SWP2, NIP2, OVR2 y ROT2 realizan las mismas acciones pero utilizando cortos en lugar de bytes.

## ejemplos

vamos a utilizar estas instrucciones de muchas maneras diferentes durante los próximos días.

los siguientes son algunos ejemplos basados en fragmentos de código que ya hemos discutido.

ten en cuenta que el uso de estas instrucciones puede contribuir a que el código sea difícil de seguir o leer, por lo que siempre será una buena idea utilizarlas dentro de macros o tener comentarios en el código explicando lo que está sucediendo :)

### dígito ascii: duplicar e intercambiar

discutimos anteriormente este segmento de código, que empuja una bandera que responde si la tecla que se pulsa tiene un código ascii entre 30 y 39, ambos inclusive (es decir, calcula si un byte tiene un código ascii correspondiente a un dígito decimal)

```
.Controlador/tecla DEI ( lee la tecla y la empuja a la pila)
#2f GTH ( ¿es mayor que 2f? empuja la bandera a la pila )
.Controlador/tecla DEI ( lee la tecla y la introduce en la pila )
#3a LTH ( ¿es menor que 3a? empuja la bandera a la pila )
AND ( aplica un AND a las banderas en la pila y empuja el resultado en la pila )
```

en lugar de leer la tecla dos veces, podríamos hacerlo una vez y luego usar la instrucción DUP para copiar el valor:

```
.Controlador/tecla DEI DUP ( leer y duplicar la tecla )
```

la pila después de estas instrucciones tendría dos copias del valor de la tecla:

```
tecla tecla <- arriba
```

entonces en nuestro código podemos seguir añadiendo la primera comparación:

```
#2f GTH ( ¿es mayor que 2f? empuja la bandera en la pila )
```

después de esto, la pila se vería como:

```
tecla bandera1 <- arriba
```

para realizar la segunda comparación, necesitamos tener la tecla en la parte superior, no la bandera.

¿cómo lo conseguimos? así es, utilizando un SWP:

```
SWP ( poner la tecla en la parte superior )
```

ahora la pila se ve así:

```
bandera1 tecla <- arriba
```

finalmente podemos proceder a la comparación y al AND:

```
#3a LTH ( ¿es menor que 3a? empuja la bandera en la pila )
AND ( aplica un AND a las banderas en la pila y empuja el resultado en la pila )
```

terminando con una pila que solo tiene el resultado:

```
resultado <- arriba
```

el código completo se leería como:

```
.Controlador/tecla DEI DUP ( lee y duplica la tecla )
#2f GTH ( ¿es mayor que 2f? empuja la bandera a la pila )
SWP ( poner la tecla en la parte superior )
#3a LTH ( ¿es menor que 3a? empuja la bandera a la pila )
AND ( aplica un AND a las banderas en la pila y empuja el resultado en la pila )
```

el primer código se ensambla en 13 bytes y este se ensambla en 12 bytes. quizá no haya demasiada diferencia en ese aspecto.

sin embargo, la ventaja más significativa es que esta nueva rutina ahora necesita su entrada empujada hacia abajo en la pila solo al principio.

en el caso que acabamos de discutir la entrada es la tecla que se presiona, pero podríamos fácilmente tener como entrada cualquier otro valor de la pila.

esto implica que podríamos escribir la rutina como una macro:

```
%?DÍGITO-ASCII { DUP #2f GTH SWP #3a LTH AND } ( byte -- bandera )
```

y utilizarla con el byte que queramos:

```
#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

otro caso anterior en el que repetimos muchas lecturas de la tecla del teclado fue cuando usamos las condicionales múltiples.

podríamos reescribirlo usando varios DUPs y POPs:

```
@en-controlador
      ( establecer coordenadas x,y )
      #0008 .Pantalla/x DEO2
      #0008 .Pantalla/y DEO2

      ( establecer dirección del sprite )
      ;cuadrado .Pantalla/direc DEO2

      .Controlador/tecla DEI ( leer tecla )
      DUP LIT "1 EQU ( ¿es la tecla '1'? )
      ,&color-1 JCN ( salta al color-1 si es el caso )

      DUP LIT "2 EQU ( ¿es la tecla '2'? )
      ,&color-2 JCN ( salta al color-2 si es el caso )

      DUP LIT "3 EQU ( ¿es la tecla '3'? )
      ,&color-3 JCN ( salta al color-3 si es el caso )

      ( en cualquier otro caso, termina )
      POP
      BRK

      &color-1
        ( dibujar el sprite en el fondo )
        ( usando el color 1 para el contorno )
        #01 .Pantalla/sprite DEO
        POP
      BRK

      &color-2
        ( dibujar sprite en el fondo )
        ( usando el color 2 para el contorno )
        #02 .Pantalla/sprite DEO
        POP
      BRK

      &color-3
        ( dibujar sprite en el fondo )
        ( usando el color 3 para el contorno )
        #03 .Pantalla/sprite DEO
        POP
      BRK
BRK
```

¿puedes decir por qué necesitamos todos esos POPs?

pista: compara el estado final de la pila con y sin las instrucciones POP.

¡en los próximos días veremos más usos y ejemplos de manipulación de la pila!

# botón del controlador

la última cosa que discutiremos hoy es el uso del byte de botón del controlador en la computadora varvara.

como ya hemos mencionado, la principal diferencia aquí es que este byte mantiene el estado de 8 botones en cada uno de sus bits.

dependiendo de nuestra aplicación, podríamos necesitar permitir que algunos de estos botones sean presionados al mismo tiempo.

en ese caso, ¿cómo podríamos aislar cada uno de los bits para comprobar su estado individualmente?

conoce las máscaras AND a nivel de bits.

## máscara AND

una máscara AND es un valor especial que utilizaremos para mantener o perder bits específicos de otro valor dado, como el byte de botón del controlador.

en nuestra máscara AND, estableceremos como 1 los bits en las posiciones en las que queramos mantener el valor de los bits de entrada. las posiciones en las que los bits de la máscara sean 0 se convertirán a 0 en la salida.

por ejemplo, digamos que queremos ver si el bit número 4, que corresponde al botón Arriba, está encendido o apagado, independientemente del estado de los otros botones.

nuestra máscara AND tendrá un 1 en el bit número 4 (de derecha a izquierda y empezando por el 0) y 0 en el resto:

```
0001 0000: 10
```

¿qué pasaría si se pulsa el botón A (tecla Ctrl), con su estado codificado en el bit 0 y nada más?

```
    0000 0001 ( botón )
AND 0001 0000 ( máscara )
   ----------
    0000 0000 ( resultado )
```

¿qué ocurre si se pulsa el botón Arriba?

```
    0001 0000 ( botón )
AND 0001 0000 ( máscara )
   ----------
    0001 0000 ( resultado )
```

¿y si se pulsan tanto Arriba como Ctrl?

```
    0001 0001 ( botón )
AND 0001 0000 ( máscara )
   ----------
    0001 0000 ( resultado )
```

así vemos cómo la máscara nos permite aislar efectivamente el bit que nos importa, independientemente del estado de los otros bits.

aplicar esta máscara sería tan sencillo como escribir:

```
#10 AND ( aplicar máscara 0001 0000 )
```

## ejemplo: dibujar con flechas y Ctrl

=> ./img/screenshot_uxn-draw-with-keyboard.png captura de pantalla de un posible resultado de la ejecución del siguiente programa; muestra un rastro dibujado con cuadrados rellenos o delineados.

el siguiente programa uxntal permite dibujar utilizando las teclas de las flechas y la tecla Ctrl (botón A).

las flechas mueven la posición de un sprite, y al pulsar Ctrl mientras se mueve, lo dibujará con los colores inversos en relleno y trazo.

observa el uso de las máscaras AND, los saltos condicionales y algunas operaciones de la pila.

```
( 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 &píxel $1 &sprite ]
|80 @Controlador [ &vector $2 &botón $1 &tecla $1 ]

( programa principal )
|0100
      ( establecer los colores del sistema )
      #2ce9 .Sistema/r DEO2
      #01c0 .Sistema/g DEO2
      #2ce5 .Sistema/b DEO2

      ( asignar vector del controlador )
      ;en-controlador .Controlador/vector DEO2

      ( establecer coordenadas iniciales x,y )
      #0008 .Pantalla/x DEO2
      #0008 .Pantalla/y DEO2
      ( establece la dirección del sprite )
      ;cuadrado .Pantalla/direc DEO2
BRK

@en-controlador ( -> )
      .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 es 0, continuar )

      &contorno
        #01 .Pantalla/sprite DEO ( dibujar contorno )
        ,&comprobar-flechas JMP ( continuar con comprobar-flechas )

      &relleno
        #04 .Pantalla/sprite DEO ( dibujar relleno )

      &comprobar-flechas
        ( usar el byte del botón de la pila )
        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 )
        &abajo JCN ( salta si no es 0 )
        DUP #40 AND ( aislar el bit 6, correspondiente a Izquierda )
        ,&izquierda JCN ( salta si no es 0 )
        DUP #80 AND ( aísla el bit 7, correspondiente a Derecha )
        &derecha JCN ( salta si no es 0 )

        POP BRK

      &arriba
       .Pantalla/y DEI2 #0008 SUB2 .Pantalla/y DEO2 ( disminuye y )
       POP
      BRK
      &abajo
       .Pantalla/y DEI2 #0008 ADD2 .Pantalla/y DEO2 ( incrementa y )
       POP
      BRK
      &izquierda
       .Pantalla/x DEI2 #0008 SUB2 .Pantalla/x DEO2 ( disminuye x )
       POP
      BRK
      &derecha
       .Pantalla/x DEI2 #0008 ADD2 .Pantalla/x DEO2 ( incrementa x )
       POP
      BRK
BRK
( sprite )
@cuadrado ff81 8181 8181 81ff
```

algunas posibilidades para que practiques:

* modificar el código para que también responda a que pulses más de una flecha al mismo tiempo.
* convertir los incrementos y decrementos de las coordenadas en macros que tomen la dirección del puerto como entrada y realizar una operación equivalente. estas dos líneas deberían funcionar usando la misma macro:

```
.Pantalla/x INCREMENTO
.Pantalla/y INCREMENTO
```

recuerde que .Pantalla/x es una dirección literal en la página cero, es decir, empuja un byte correspondiente a la dirección de la subetiqueta Pantalla/x :)

# practica posibilidades

¡aquí tienes otras ideas para que practiques con lo que hemos cubierto hoy!

* dibujar un controlador virtual que muestre cuáles de sus botones, mapeados a teclas del teclado, están siendo presionados
* crear una especie de máquina de escribir que dibuje diferentes símbolos y mueva el cursor de dibujo dependiendo de la tecla que se haya pulsado
* dibujar un personaje que cambie su estado según la tecla que se haya pulsado. ¿tal vez utilizar múltiples tiles para dibujarlo?
* crea un simple tablero de tres-en-raya para dos jugadores: una tecla dibuja una X, otra dibuja una O y las flechas permiten elegir la casilla a dibujar.

¡ten en cuenta que para un suave movimiento interactivo puede ser mejor utilizar el vector de pantalla que se llama 60 veces por segundo!

¡lo cubriremos en profundidad en el próximo día del tutorial!

# instrucciones del día 3

¡estas son todas las instrucciones uxntal de las que hemos hablado hoy!

## instrucciones de comparación

* EQU: empuja 01 hacia abajo en la pila si los dos primeros elementos de la pila son iguales, o empuja 00 en caso contrario ( a b -- a==b )
* NEQ: empuja 01 hacia abajo en la pila si los dos primeros elementos de la pila no son iguales, o empuja 00 en caso contrario ( a b -- a!=b )
* GTH: empuja 01 hacia abajo en la pila si el primer elemento es mayor que el segundo, o empuja 00 en caso contrario ( a b -- a>b )
* LTH: empuja 01 hacia abajo en la pila si el primer elemento es menor que el segundo, o empuja 00 en caso contrario ( a b -- a<b )

## lógica a nivel de bits

* AND: realiza un AND a nivel de bits con los dos primeros elementos de la pila y empuja hacia abajo el resultado ( a b -- a&b )
* ORA: realiza un OR a nivel de bits con los dos primeros elementos de la pila y empuja el resultado ( a b -- a|b )
* EOR: realiza un OR exclusivo a nivel de bits con los dos primeros elementos de la pila y empuja hacia abajo el resultado ( a b -- a^b )

## saltos

* JMP: salto incondicional a la dirección de la pila ( direc -- )
* JCN: salto condicional: toma una dirección y un valor de la pila y si el valor no es 00, salta a la dirección; en caso contrario continúa con la siguiente instrucción ( valor direc -- )

## pila

* POP: eliminar el elemento superior de la pila ( a -- )
* DUP: duplicar; empujar una copia del elemento superior ( a -- a a )
* SWP: "swap" o intercambiar; cambiar el orden de los dos primeros elementos de la pila ( a b -- b a )
* NIP: elimina el segundo elemento superior de la pila ( a b -- b )
* OVR: "over" o encima; empuja una copia del segundo elemento superior ( a b -- a b a )
* ROT: rotar; reordenar los tres primeros elementos de la pila de forma que el tercero esté ahora en la parte superior ( a b c -- b c a )

# día 4

en el {tutorial de uxn día 4} cubrimos el uso del vector de pantalla para crear animaciones, ya sean interactivas o no.

¡también exploramos las posibilidades de usar "variables" en uxntal que pueden ayudarnos a crear programas más elaborados!

¡antes de entrar en materia, te invito a seguir explorando y también a tomar un descanso!

¡mantente en sintonía!

# apoyo

si te ha gustado este tutorial y te ha resultado útil, considera compartirlo y darle tu {apoyo} :)