Estructuras básicas de programación

Expresiones relacionales programación Lua

Sintaxis

>   (mayor que)                         < (menor que)

== (igualdad)                          ~= (desigualdad)

true                                             false

Una expresión relacional está compuesta por dos valores que se comparan con un operador relacional para evaluar si la relación establecida entre los datos es verdadera o falsa (true o false).

Expresión                                Resultado

12 > 8                                        true   

60 < 40                                    false   

La expresión de igualdad se hace con ==, doble signo porque un solo = significa la asignación de un valor, como en x = 14. El símbolo != es lo contrario a == e indica que dos valores no son equivalentes.

Estructuras de Control

Las expresiones relacionales se utilizan en las estructuras de control, estas pueden ser de dos tipos:

Estructuras condicionales: permiten que se realicen determinados conjuntos de instrucciones, en función de que se verifique, o no, una o varias condiciones enunciadas.

Estructuras iterativas o de repetición: permiten que se realice un conjunto de instrucciones repetidas veces, ya sea un número predeterminado de veces, o hasta que se verifique una determinada condición.

Estructuras condicionales y operadores lógicos

Sintaxis

Condicionales if, elseif, else

La estructura condicional simple if, permite a un programa seguir comportamientos diferentes, dependiendo de que los valores de sus variables cumplan unas condiciones u otras, esta comprobación se obtiene a través de una expresión relacional (test), de modo que las acciones pueden tener lugar, o no, sólo si una condición específica se cumple: si la condición se cumple (si el test tiene como resultado true), realiza la instrucción, si no se cumple se la salta. Para plantear el test se utilizan expresiones relacionales y operadores lógicos.

La estructura condicional doble else amplía las posibilidades de  if, de manera que cuando la expresión asociada es falsa, el código del bloque else se ejecuta en su lugar.

La estructura condicional múltiple elseif, amplía aun más las opciones de la condicional. Si no se cumple la condición if, pasa a evaluar la condición elseif, y si tampoco se cumple puede aun establecer un else para efectuar una tercera instrucción, si las dos anteriores no se cumplen. Pueden haber varios elseif encadenados.      

Las estructuras condicionales utilizan operadores lógicos para combinar dos o más expresiones relacionales o para invertir los valores lógicos.

Sintaxis

Operadores lógicos or, and, not

Los operadores lógicos permiten formular más de una condición de forma simultánea. El operadornot invierte el valor lógico de las variables booleanas, cambiando verdadero a falso, y falso a verdadero.

La  estructura condicional if en Lua, a diferencia de otros software, no utiliza () ni {}.

if not b then             -- si b es falso, (también puede escribirse if b == false)  entonces
  -- instrucción          -- haz tal cosa
end                       -- end, cierra el bloque if

if b then                 -- si b es verdadero (también puede ser if b == true then), entonces 
  a = not a               -- si la variable booleana a era verdadera pasa a ser falsa 
end                          -- y viceversa

if a > 5 or b < 30 then   -- si a es mayor que 5 ó b es menor que 30               
  -- instrucción          -- solo hace falta que cumpla una de las condiciones
end       

if a > 5 and a < 30 then   -- si a es mayor que 5 y es menor que 30    
  -- instrucción           -- hace falta que se cumplan las dos condiciones
end

La estructura if con operadores lógicos más las opciones elseif y else amplían mucho la capacidad del código en situaciones en que las variables son cambiantes.

if a == b then       -- si a es igual a b, entonces  
  -- instrucción 1   -- haz instrucción 1   
elseif a ~= c then   -- si no, pero a es distinto de c, entonces    
  -- instrucción 2   -- haz instrucción 2   
else                 -- si no se cumple ninguna condición anterior    
  -- instrucción 3   -- haz instrucción 3   
end

En el siguiente ejemplo se reasignan nuevos valores a las variables cuando las formas alcanzan los límites de la ventana de salida, generando un loop en la animación. Retomamos el ejemplo anterior, aplicando control a esos límites, cuando la línea llega al final de la pantalla, su coordenada y vuelve a valer 0

--
--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform            E-3-2
--
--	Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--	Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--	----------------------------------------------------------
--
--
--	Control movimiento con
--	Expresiones condicionales
--
--


mouseX = 0
mouseY = 0
-----------
y = 0													
inc = 20

----------------------------------------------------
function setup()

end

----------------------------------------------------
function update()
  if y < OUTPUT_HEIGHT  then    -- si y es menor que la altura de pantalla				
    y = y + inc                 -- suma 20 a su valor en cada frame					
  else                          -- si no						     								
    y = 0                       -- y vale 0					                 				
  end 
end

----------------------------------------------------
function draw()
     -- fondo transparente: alpha = 20, para ver el rastro de las líneas pasadas
    mosaicBackground(255,255,255,20)
									
    of.setColor(0)                      -- color negro											
    of.setLineWidth(4)                  -- grosor línea											
    of.drawLine(0, y, OUTPUT_WIDTH, y)  -- recoge el valor de y actualizado en el bloque update()
end

----------------------------------------------------

Estructuras iterativas o de repetición

Sintaxis

Repetición for

Las estructuras iterativas se utilizan para realizar acciones repetitivas en una o varias instrucciones, hasta que determinada expresión relacional deje de ser cierta. Cuando se sabe de antemano el número de repeticiones necesario, se utiliza la estructura for, si no se sabe el número de repeticiones se puede utilizar la estructura while.

La estructura for se articula con tres declaraciones: el valor inicial de la variable, el test con una expresión relacional y la actualización del valor de esa variable. Las declaraciones dentro del bloque for se procesan de forma continua, generando un loop con las instrucciones que hay dentro del bloque que se repiten una y otra vez mientras el test sea verdadero (true).

Explicado de una forma más directa, imaginemos que el valor inicial de una variable i es igual a cero, el valor del test para comparar es 100 y el valor de actualización es 50 (for i = 0, 100, 50 do no se pone coma entre el último valor y do).  En la primera vuelta del for la relación pregunta: ¿0 es menor que 100? –> true (sí), entonces el programa procesa las instrucciones que hay dentro del bloque, y actualiza el valor de i que pasa a ser 50. En la segunda vuelta pregunta ¿50 es menor que 100? –> true; y el programa procesa otra vez las instrucciones  del bloque, y actualiza de nuevo el valor de i, ahora i = 100. En la tercera vuelta pregunta ¿100 es menor que 100?  –> false (no);  ya no se verifica el test, el loop termina y el sistema continúa con las líneas de código que estén después del bloque for.

Cuando la actualización del valor es sumar 1, pueden ponerse solo dos declaraciones: valor inicial de la variable y test: (for i = 0, 100 do).

Lua, igual que en las estructuras condicionales, no utiliza () ni {} en la estructura for, y la cierra con end.

--
--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform            E-3-3
--
--	Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--	Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--	----------------------------------------------------------
--
--
--	Estructura programación básica
--	Repetición simple: for
--
--


mouseX = 0
mouseY = 0
-----------											
distance = 50

----------------------------------------------------
function setup()
	of.enableSmoothing()
end

----------------------------------------------------
function update()
		
end

----------------------------------------------------
function draw()
        -- draw background first
        mosaicBackground(255,255,255,255)

        of.setColor(0)
        of.setLineWidth(3)

        for i = 0, OUTPUT_WIDTH, distance do       -- no lleva () ni {}
             of.drawLine(i, 0, OUTPUT_WIDTH-i, OUTPUT_WIDTH-i)
                                                   -- dibuja el valor de i 
             of.drawBitmapString(string.format("%i", i), i, 10)
  	end                                        -- cierra el for con end	
				 	
end

----------------------------------------------------

La estructura for se repetirá en loop hasta que la variable i tenga el valor OUTPUT_WIDTH, ancho de la ventana de salida (que en este caso era igual 1280), y en cada vuelta el valor de i sumará 50. Con esa lista de valores aplicada al parámetro x1 del primer par de coordenadas , e y1  siempre es igual a 0, es decir, recorre el eje de las X situando un punto cada 50 px.

El segundo par de parámetros de las líneas, x2  e y2  tienen el mismo valor por lo que los puntos  se sitúan siempre en una diagonal de 45º,  y como este valor se va reduciendo simultáneamente a como crece x1 , generan la representación plana de un paraboloide hiperbólico.

La segunda línea de código del for (of.drawBitmapString(string.format("%i", i), i, 10)) dibuja en la parte alta de la ventana de salida  los valores de i y los coloca en el eje de las X en ese mismo valor  (x = i). Esto se ha hecho para clarificar gráficamente los valores que va tomando i, si la explicación de estas funciones confunde os lo podéis saltar.

Ahí va la explicación:  la función of.drawBitmapString() sirve para dibujar texto plano sin necesidad de incorporar fuentes, sus parámetros son el texto a escribir entre comillas, posición x, y posición y de ese texto. Vemos que su primer parámetro es  la función  string.format() porque esta función sirve para transformar el tipo de variable i, que es un número entero (int), en una cadena de caracteres de texto (string). Coincide que el signo para expresarlo como un número entero es %i (si quisiéramos un valor float sería %f) y que el valor que queremos expresar es el de la variable i, pero ambos i indican cosas muy diferentes.

Pasando a otro ejemplo, la estructura repetitiva  for  puede combinarse con la condicional if . En este caso la condición del if  nos sirve también para ver cómo funciona el operador aritmético %.

--
--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform            E-3-4
--
--	Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--	Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--	----------------------------------------------------------
--
--
--	Estructuras programación básicas
--	Repetición simple for; Condicional; Modular % 
--
--


mouseX = 0
mouseY = 0

----------------------------------------------------
function setup()
	
end

----------------------------------------------------
function update()
		
end

----------------------------------------------------
function draw()
     -- draw background first
     mosaicBackground(255,255,255,255)
				 
     of.setLineWidth(3)                 -- grosor línea 3 px
     for i = 0,  OUTPUT_WIDTH,  13  do  -- desde i=0 hasta i=ancho pantalla 															 
                                        -- sumando 13 cada vez		
        if (i % 2) == 0  then           -- si i es par, entonces
             of.setColor(255)           -- color blanco					     											  
        elseif (i % 5) == 0 then        -- si no es par, pero es múltiplo de 5
             of.setColor(255, 0, 0)     -- color rojo
        else                            -- para el resto de opciones
             of.setColor(0,255,0)       -- color verde
        end
        of.drawLine(i, 0, i, OUTPUT_HEIGHT)  -- dibuja líneas con los valores
     end                                     -- que i obtiene en el for para X  			
end                                          
----------------------------------------------------

Como los valores que se van obteniendo en el loop tienen que cumplir varias condiciones, se ha elegido el número 13, raro, para tener un rango más diverso, pero siempre generará un pattern:

0, 13, 26, 39, 52, 65, 78, 91, 104, 117, 130, 143, 156, 169, 182, 195…,

Par, impar, par, impar…, por lo que dibuja una línea blanca cada dos. El primer múltiplo de 5 que no sea par es el 6º y luego cada 10. De este modo se dibujan las líneas verticales cada 13 píxeles, y la condicional if determina los colores.

La estructura iterativa for genera repeticiones en una dimensión, pero si se anida unfor  dentro de otrofor  se generan repeticiones en dos dimensiones, como muestra el siguiente ejemplo.

--
--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform            E-3-5
--
--	Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--	Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--	----------------------------------------------------------
--
--
--	Estructuras programación básicas
--	Repetición doble for; Condicional; Modular %
--
--



mouseX = 0
mouseY = 0
inc = 20

----------------------------------------------------
function setup()
     of.setCircleResolution(60)
end

----------------------------------------------------
function update()
     
end

----------------------------------------------------
function draw()
      -- draw background first
      mosaicBackground(255,255,255,255)

     for i = 0, OUTPUT_WIDTH, inc do
          for j = 0, OUTPUT_HEIGHT, inc do
              if i > 0 and j > 0 then
                    if (i%j) == 0 or (j%i) == 0 then
                         of.setColor(0)
                    else
                         of.setColor(255)
                    end
                    of.drawCircle(i, j, inc/2-1)
               end               
          end
     end
end

----------------------------------------------------

En este doble for, cuando la variable i adopta el primer valor, i = 0, la lectura del código pasa al segundo for para asignar el primer valor a j, j=0, luego j=20, j=40,.. hasta que j llega al valor de la altura de la ventana de salida, con ello ha generado las coordenadas (0,0) (0,20) (0,40)…(0,OUTPUT_HEIGHT). Después vuelve al primer for e i adquiere el valor 20 y de nuevo pasa al segundo for para asignar valores a j desde 0 hasta el valor de la altura de ventana de salida, generando las coordenadas de la segunda columna de círculos (20,0) (20,20) (20,40)…, así hasta que completa toda la retícula cuando i alcanza el valor del ancho de ventana y j el alto: (OUTPUT_WIDTH, OUTPUT_HEIGHT). Si quitamos el bloque condicional if del código y dejamos solo el color negro, la ventana de salida mostraría una retícula regular de círculos, porque los huecos que se perciben corresponden a círculos blancos que se confunden con el fondo cuando i es múltiplo de j  o viceversa.