Estructuras de programación avanzadas

Lua no es un lenguaje de programación orientado a objetos (POO) como Java o Ruby, sin embargo tiene la capacidad de implementar clases y tablas que actúan de forma semejante a la POO.

Este modelo de programación implica una forma particular de pensar y escribir código, en la que se utilizan los elementos básicos vistos anteriormente: variables, expresiones y funciones…, pero organizados de modo más próximo al lenguaje verbal. El hecho de ser un modelo implica que tiene su propia lógica.

La POO nos hace pensar las cosas de una manera más abstracta y con una estructura muy organizada, que sigue un proceso de descomposición del problema diferente. En la programación estructurada se descompone la complejidad en partes más simples y fáciles de codificar, de modo que cada sub-programa realiza una acción, mientras que en la POO lo hace en objetos.

Hay que pensar en el posible escenario de esos objetos para definir sus propiedades y comportamiento. Los objetos son la representación de un concepto,  y es necesario describir las propiedades que lo definen y los métodos que gestionan su comportamiento en ese escenario.

Esta forma particular de estructurar el código favorece su reutilización al compartimentarse en módulos independientes.

Primero veremos el funcionamiento de las tablas y después las clases.

1. Tablas

Las tablas son el único tipo de «contenedor» en Lua-Mosaic, funcionan como un array asociativo que almacena un conjunto de elementos ordenados consecutivamente mediante un [id] y organizados en pares: clave y valor (key/value), de manera que puedes almacenar un valor bajo una clave y después recuperarlo usando esa clave.

El orden consecutivo asigna a cada elemento un ID, este ID es una forma numérica consecutiva que en Lua empieza por 1, a diferencia de otros lenguajes que empiezan por 0,  y este ID lo identifica de manera que se puede acceder a ese elemento en la programación individualmente. En lua, los datos almacenados pueden ser de cualquier tipo y además se pueden mezclar distintos tipos en una misma tabla (en otros lenguajes un array solo puede almacenar un tipo de datos).  

Vamos a ver cómo se utilizan las tablas en Lua (librería table de Lua), pueden hacer las mismas operaciones que los arrays o las listas, pero con mayor flexibilidad. Porque las tablas permiten utilizar datos de diferente tipo y simplifican mucho el proceso de programación. Además, las tablas en Lua no se entienden como lineales o de dos dimensiones, sino que una tabla lineal puede albergar múltiples dimensiones de datos.

La sintaxis para declarar una tabla es:   

nombreTabla = {}

Para crearla pueden enumerarse los elementos que la constituyen dentro de corchetes » {}», separados por coma:

nombreTabla = {12, 0.3, «cosa», 123, 0.002}

O simplemente declararla  y posteriormente inicializarla, e ir insertando elementos y asignándole valores.

Una vez declarada, los componentes de la tabla se expresan con paréntesis cuadrados: nombreTabla[x], donde x corresponde al ID de ese elemento:

nombreTabla[1], nombreTabla[2], nombreTabla[3], nombreTabla[4]...

Pasamos a describir su uso, comentado el código de algunos ejemplos.    

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    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
--    ----------------------------------------------------------   E-3-6                  
-- 					
--    Ejemplos tabla/tabla de circulos fijos					
-- 
mouseX = 0
mouseY = 0
------------ 
 
myTable = {}

----------------------------------------------------
function setup()
    of.setCircleResolution(60)
    for i = 1, 100 do    -- establece nº objetos de la tabla	
        myTable[i] = {}  -- crea otra tabla para cada elementos de la tabla
                         -- of.randomuf devuelve nº float random entre 0 y 1	  		
        myTable[i].x = of.randomuf()*OUTPUT_WIDTH      -- valores coordenadas x		
        myTable[i].y = of.randomuf()*OUTPUT_HEIGHT     -- valores coordenadas y		
        myTable[i].radio = of.random(0,OUTPUT_WIDTH/2) -- valores radios		
    end	
end
----------------------------------------------------
function update()
     
end
----------------------------------------------------
function draw()																							
    mosaicBackground(255,255,255,255)  																					
																			
    of.setColor(0,255,255)      -- color cyan															
    of.noFill()                 -- no rellenar
															
    for i = 1, 100 do           -- dibuja los 100 círculos											
       of.drawCircle(myTable[i].x, myTable[i].y, myTable[i].radio)							
    end																										
end

En este ejemplo la tabla adopta la sintaxis de un array simple, que incorpora otras tablas dentro de cada elemento de la tabla principal.

En el bloque function setup(), una estructura for recorre los elementos de la tabla asignándoles el ID con la variable i . Con la primera línea del código:  myTable[i] = {}, se crea una tabla de tablas, es decir, una tabla para cada uno de los elementos de la tabla inicial, lo que permite definir sus propiedades sin hacer nuevas tablas (como debería hacerse en otros lenguajes), simplemente en el mismo for se van asignando valores a cada una de esas propiedades utilizando el operador «.» junto al código que representa cada objeto en  la tabla inicial, como por ejemplo:  myTable[i].x

En el bloque function draw(), además de las funciones internas para el color y no relleno, otra estructura for dibuja todos los círculos recogiendo los datos de las propiedades definidas en el setup(). No hay function update() porque en el ejemplo las formas están fijas, no hay comportamiento.

Vamos a ver con otro ejemplo, cómo ir incorporando elementos a una tabla semejante a la anterior, pero que se declara inicialmente vacía y con eventos de teclado se le van insertando los elementos. En este ejemplo también se utiliza la relación key/value, y para trabajar con esa doble relación se debe utilizar con una estructura for iterativa que va recorriendo la clave (key  [k]) y el valor (value [v]) de cada elemento:

--
--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform
--
--	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
--	----------------------------------------------------------
--
--
--	empty.lua: A Lua script template for Mosaic,
--	mimicking the standard OF app structure
--
--


-- variables for mouse interaction
mouseX = 0
mouseY = 0

-- An empty table (for now!)
myTable = {}
myTableLength = 0
theIndex = 1
navi = 0

-- Drawing
chapter = 0

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

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

----------------------------------------------------
function draw()
   mosaicBackground(0,0,0,255)
   if chapter == 1 then
     	for k,v in pairs(myTable) do
     		if k == navi then
     			of.fill()
     		else
     			of.noFill()
     		end

     		of.setLineWidth(4)
    		of.setColor(0,255,255,myTable[k].alpha)
    		of.drawCircle(myTable[k].posX, myTable[k].posY, myTable[k].radio)
    	end
        of.setLineWidth(1)
        x = OUTPUT_WIDTH/4
        y = 100
        of.setColor(255)
        of.drawBitmapString(tostring("myTable"), x, y)

        for k,v in pairs(myTable) do
            if k == navi then
                 of.fill()
                 of.drawLine(x+16, y+34+(20*k), x+16+200, y+34+(20*k))
                 cc = 0
                 for k2,v2 in pairs(myTable[k]) do
                     of.drawBitmapString(string.format("%s - %s", tostring(k2), tostring(v2)), x+30+200, y+30+(20*k)+(20*cc))
                     cc = cc + 1
                  end
            else
                  of.noFill()
            end

            of.drawRectangle(x+(16*k), OUTPUT_HEIGHT-20, 16, 16)
            of.drawBitmapString(string.format("%i - %s", k, tostring(v)), x+16, y+30+(20*k))
       end
   end
end

----------------------------------------------------
function exit()

end

-- input callbacks

----------------------------------------------------
function keyPressed(key)

end

function keyReleased(key)
  if key == string.byte('a') then  -- con la tecla 'a'   
    object = {}                    -- inicializa la tabla, define sus propiedades y les asigna un valor
    object.posX = of.randomuf()*OUTPUT_WIDTH
    object.posY = of.randomuf()*OUTPUT_HEIGHT
    object.alpha = of.random(50, 155)
    object.radio = of.random(0, OUTPUT_WIDTH/2)
    table.insert(myTable, theIndex,object)
    theIndex = theIndex + 1 
  elseif key == string.byte(' ') then -- con la tecla ' ' (espacio) 
    if navi <  theIndex then          -- establece otro index (ID)
      navi = navi + 1
    else
      navi = 1
    end

  elseif key == string.byte('0') then  -- con la tecla '1'
    chapter = 0                        -- cambia el estado
  elseif key == string.byte('1') then
    chapter = 1                        -- solo dibuja si chapter = 1
  end
end

Tanto el bloque setup() como el update() están casi vacíos, solo la función para que los círculos se vean redondos. Todo empieza a generarse en el bloque keyReleased().
Si se suelta la tecla «a» se genera un elemento de la tabla. El ID se lo da la variable theIndex que suma 1 cada vez.
Vemos también que si se suelta la tecla/barra espacio » » se va generando otro index llamado navi, siempre que navi sea menor que theIndex, al soltar la barra espacio, navi suma 1.
Y por último con la tecla ‘0’ chapter = 0, y con la tecla ‘1’ chapter = 1. Solo se dibujarán cosas en el bloque draw si chapter es igual a 1.

Sabiendo esto vamos a explicar cómo funciona el programa antes de entrar en los detalles del bloque draw().

Al activar el script vemos que no sucede nada, si tecleamos ‘1’, aparece el nombre myTable.
Si tecleamos ‘a’, se dibuja un círculo sin relleno y los datos del primer elemento de la tabla del que solo nos da el código de respaldo de ese elemento en la memoria del ordenador.
Tecleamos de nuevo ‘a’, pinta otro círculo y da los datos del 2º elemento y así sucesivamente, 3º, 4º,….
Si tecleamos la barra ‘espacio’, el primer círculo que se dibujó aparece relleno, y en la lista, ese elemento queda subrayado y nos da los valores de sus propiedades: posY, alpha, radio y posX.
Si se teclea de nuevo ‘espacio’ da los valores de las propiedades del 2º elemento, y en la parte inferior podemos ver la representación de la tabla como una fila de cuadrados  en la que también se rellena el que corresponde al elemento que activa navi.
Si tecleamos ‘espacio’ más veces de lo que lo hemos hecho con ‘a’, como no hay más elementos generados en la tabla, navi no nos da nada.
Es un buen ejercicio para entender visualmente cómo funcionan las tablas.

Vamos a analizar brevemente el código del bloque draw().

Si chapter == 1 se aplica el for iterativo que empieza verificando que si k (la llave) es igual a navi, se activa la función de rellenar, y si no son iguales, la de no rellenar, y dibuja el círculo que corresponde con la igualdad entre k y navi.
Después hay 5 líneas de código destinadas a escribir myTable.

De nuevo otro for iterativo [para k(clave), v(valor) emparejados (en los elementos que tenga myTable)]
Si k es igual a navi, dibuja la línea para subrayar, situada en relación a los valores de k. Y dentro de este for, otro for con los valores k2 y v2 que pintará los nombres de las propiedades del círculo seleccionado por navi.
Si k no es igual a navi (else), no rellenar, dibujar todos los círculos generados y los datos en la lista de myTable.

En el siguiente ejemplo sí se incluyen datos en el bloque function update()para generar comportamientos, y se incrementa el número de propiedades de cada uno de los objetos de la tabla.

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    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
--    ----------------------------------------------------------   E-3-7                  
-- 
--    tabla de círculos rebotan					
-- 
mouseX = 0
mouseY = 0
------------ 
 
circulos ={} 	-- declara la tabla  
maxCirculos = 20

----------------------------------------------------
function setup()
        of.setCircleResolution(60)
	for i = 1, maxCirculos do  -- inicializa la tabla y for recorre todos los objetos 		
		circulos[i] = {}                                  -- crea otra tabla de tablas			
		circulos[i].posX = of.random(30, OUTPUT_WIDTH)    -- coordenadas X al azar 	   
		circulos[i].posY = of.random(OUTPUT_HEIGHT/2)     -- coordenadas Y al azar	    	
		circulos[i].radio = of.random(15, 100)            -- radio círculos					
		circulos[i].velX = 0.000000                       -- velocidad X 							
		circulos[i].velY = 0.000000                       -- velocidad Y 							
		circulos[i].gY = 0.00184562                       -- gravedad Y							
		circulos[i].gX = of.random(-0.018326, 0.044326)   -- gravedad X			    		
		circulos[i].color= of.random(0, 100)              -- gris azar para cada objeto		
		circulos[i].transp = 220                          -- transparencia 						
	end		
end
----------------------------------------------------
function update()
        
	for i=1, maxCirculos do	       																				
		circulos[i].velX = circulos[i].velX + circulos[i].gX    -- velocidad + gravedad	
		circulos[i].velY = circulos[i].velY + (circulos[i].gY*circulos[i].radio) 
                               -- en el eje Y, velocidad + gravedad + radio para simular mayor peso
                circulos[i].posX = circulos[i].posX + circulos[i].velX -- posición + velocidad 
                circulos[i].posY = circulos[i].posY + circulos[i].velY 
		
		if circulos[i].posX <= 0 or circulos[i].posX >= OUTPUT_WIDTH-10 then -- control de bordes		
			circulos[i].velX = circulos[i].velX *-0.972773 							
		end				     																			
		if circulos[i].posY >= OUTPUT_HEIGHT or circulos[i].posY <= 0 then			
			circulos[i].velY = circulos[i].velY * -0.962722	-- invierte dirección 	
		end		
	end	

end
----------------------------------------------------
function draw()																							
   mosaicBackground(255,255,255,255) 
 																					
                                           -- dibuja todos los círculos
   for i= 1, maxCirculos do              -- transparencia vinculada al diámetro
      of.setColor(circulos[i].color,circulos[i].color,circulos[i].color,circulos[i].transp-circulos[i].radio)    														
      of.drawCircle(circulos[i].posX, circulos[i].posY, circulos[i].radio)				
   end    																									
end

En el bloque function setup() se inicializa la tabla y mediante una estructura for ,  la primera línea del código crea una tabla de tablas, y después se asignan valores iniciales a las propiedades de los objetos utilizando el operador «.» junto al nombre de la tabla y el identificador  [i].

nombreTabla[i].propiedad

El for recorre la tabla, reserva la memoria que el sistema necesita para estos datos y les asigna las propiedades definidas, que en este caso son: posición X y posición Y (para localizar el centro de cada circulo), radio (tamaño), velocidad X y velocidad Y (para el movimiento de los círculos) gravedad X y gravedad Y (para representar los rebotes y un movimiento menos lineal), color y transparencia.

Los comportamientos se establecen en el bloque function update(), donde se actualizan los valores de las  propiedades. Con un nuevo for, a las coordenadas de posición de cada objeto se le suman las de velocidad; y a las de velocidad las de gravedad en la coordenada de las X; y las de gravedad por el diámetro del círculo en la coordenada Y para producir un movimiento más físico de peso en el círculo. Después se ajustan los rebotes a los límites de la ventana mediante bloques condicionales if, invirtiendo la dirección del movimiento al multiplicar el valor de su velocidad por un número negativo con muchos decimales que no llega a 1 para simular un efecto de gravedad. Finalmente, en el bloque function draw() se dibujan todos los círculos mediante un nuevo for.

El siguiente ejemplo, más complejo, está basado en la noción de Random Walker, utiliza varias tablas, la función of.noise() y of.map()

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    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
--    ----------------------------------------------------------   E-3-8                  
-- 
--    Tabla Noise Walker								
--    Shiffman_NatureOfCode/CH0_noiseWalk       
--    creado por n3m3da | www.d3cod3.org
			
mouseX = 0
mouseY = 0
------------ 
 
walkers = {}										
noiseTimeX = {}									
noiseTimeY = {}
stepX = {}
stepY = {}
numW = 300
	

----------------------------------------------------
function setup()
	for i = 0,numW-1 do
		walkers[i] = {}
		walkers[i].x = OUTPUT_WIDTH/2
		walkers[i].y = OUTPUT_HEIGHT/2
		noiseTimeX[i] = of.random(0,10000)
		noiseTimeY[i] = of.random(7000,14000)
		stepX[i] = of.random(0.001,0.003)
		stepY[i] = of.random(0.001,0.003)
	end
end
----------------------------------------------------
function update()
	for i=0,numW-1 do
		mapX = of.map(of.noise(noiseTimeX[i]), 0.15, 0.85, 0, OUTPUT_WIDTH, true) 			
		mapY = of.map(of.noise(noiseTimeY[i]),0.15, 0.85, 0, OUTPUT_HEIGHT, true)			
		walkers[i].x = mapX 
		walkers[i].y = mapY
		noiseTimeX[i] = noiseTimeX[i]+stepX[i]
		noiseTimeY[i] = noiseTimeY[i]+stepY[i]
	end		

end
----------------------------------------------------
function draw()																					    
        mosaicBackground(255,255,255,20)										
        of.noFill()
        for i=0,numW-1 do
             if math.fmod(i,7) == 0 then  -- Devuelve el resto de la división de i por 7 	
                  of.setColor(255)        -- y redondea el cociente a cero. 					
             else
                  of.setColor(0)
             end
             of.drawRectangle(walkers[i].x,walkers[i].y,1,1)
        end
end

Con las tablas podemos tener control de cada elemento mediante su ID que viene representado por el valor que adopta en [i]. En el siguiente ejemplo vamos a ver como pueden controlarse las propiedades de un elemento concreto a través de su ID.

--
--	----------------------------------------------------------
--      Mosaic | OF Visual Patching Developer Platform
--
--	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
--	----------------------------------------------------------
--
--	Tabla id control
--


mouseX = 0
mouseY = 0
------------

circulo = {}
tex = of.TrueTypeFont()

----------------------------------------------------
function setup()
    of.setCircleResolution(60)
    for i = 0, 13 do
        circulo[i] = {}
        circulo[i].radio = of.random(40, 80)
        circulo[i].x = of.random(circulo[i].radio, OUTPUT_WIDTH- circulo[i].radio)
        circulo[i].y = of.random(circulo[i].radio, OUTPUT_HEIGHT- circulo[i].radio)
        circulo[i].ID = i
    end
    tex:load(SCRIPT_PATH .. "/data/Anonymous_Pro_B.ttf", 20, true, true) -- cargar la fuente
end

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

----------------------------------------------------
function draw()
    of.setColor(255,255,255,255)
    of.drawRectangle(0, 0, OUTPUT_WIDTH, OUTPUT_HEIGHT)

    rojo = 0                          -- variable local
    for i = 0, 13 do
        of.noFill()
        if circulo[i].ID == 10 then   -- control por el ID de los objetos
            rojo = 255
        else
            rojo = 0
        end
        of.setColor(rojo, 0, 0)
        of.drawCircle(circulo[i].x, circulo[i].y, circulo[i].radio)
        tex:drawString(tostring(circulo[i].ID),circulo[i].x,circulo[i].y)
    end
end

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

El siguiente ejemplo vincula la posición del primer elemento de la tabla a la del ratón, y después la posición de cada elemento a la del elemento anterior, estando así todas las posiciones vinculadas a la del ratón.

--
--
--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform
--
--	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
--	----------------------------------------------------------
--
--
--	Tablas interactividad raton
--
--


-- variables for mouse interaction
mouseX = 0
mouseY = 0

circulos = {}
numCirculos = 100
----------------------------------------------------
function setup()
  of.setCircleResolution(60)
  for i = 0, numCirculos do
    circulos[i] = {}      --inicializa la tabla de tablas
    circulos[i].x = 0
    circulos[i].y = 0
  end
end

----------------------------------------------------
function update()
  
  for i = numCirculos, 0, -1  do -- recorre la tabla al revés, 
                                 -- restando uno cada vuelta
    if i > 1 then                -- para todos los elementos menor el primero
      circulos[i].x = circulos[i-1].x
      circulos[i].y = circulos[i-1].y
     end
  end
  circulos[1].x = mouseX + of.random(-3, 3) -- la posición del circulo 1 vinculada a 
  circulos[1].y = mouseY + of.random(-3, 3) -- la del raton

end

----------------------------------------------------
function draw()
  mosaicBackground(0,0,0,2)     -- fondo transparente
  
  of.setColor(255, 255, 255, 100)
  of.noFill()
  of.setLineWidth(3)

  for i = 1, numCirculos-1 do
    of.drawCircle(circulos[i].x,circulos[i].y, i/2 )
  end

end

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

2. Clases

En una clase, el concepto más destacado es el de objeto que representa cualquier cosa, real o abstracta, y es el componente conceptual del problema planteado. En  programación, un objeto se define en dos partes: 1) Constructor: una serie de datos que constituyen las propiedades del objeto, de entre ellas algunas destacan por ser necesarias como parámetros del constructor. 2) Métodos: modifican el valor de las propiedades para generar el comportamiento de los objetos.

Como se ha visto en los ejemplos de las tablas, el objeto círculo tiene una serie de propiedades declaradas con variables según lo que requiera la situación planteada: coordenadas del centro, radio  o diámetro, color, transparencia, grosor del trazo…, de ellas, las que se decidan como necesarias para definir el objeto serán los parámetros del constructor.

El comportamiento quedará regulado por los métodos que programemos para que esos objetos círculo sitúen sus coordenadas fijas o en movimiento, sigan una dirección u otra, reboten con los límites de la ventana, etc.,   

Definición de Clase

Estableciendo una relación algo simplista podemos entender las clases aludiendo a la Teoría de las ideas (o Teoría de las formas) de Platón. Las clases se corresponderían al mundo inteligible donde están las estructuras o modelos (las ideas) en las cuales se basan las cosas físicas concretas (los objetos) que podemos percibir en el mundo sensible.

Por ejemplo, la clase círculos puede contener todos los objetos circulares, con sus distintos tamaños, colores, etc., y sus distintos comportamientos. El objeto círculo es una instancia de la clase círculos. Cada objeto círculo tiene un estado particular independiente, pero todos tienen en común el hecho de tener una propiedad color, radio, etc. E igualmente deben tener en común la posibilidad de adoptar determinados comportamientos, por lo que la clase debe declarar o implementar los métodos que regulan el comportamiento de los objetos que contiene.

En resumen, una clase es como una plantilla que define las propiedades y los métodos que son comunes para todos los objetos que agrupa, por lo que para programarlos siempre hay un bloque dedicado al constructor que lleva el mismo nombre que la clase y define los parámetros necesarios para crear o instanciar un objeto de la clase.

En este curso no entraremos en las herencias y mensajes entre clases, aun así, aunque la estructura sea más simple, es conveniente hacer diagramas con las propiedades y comportamientos de los objetos antes de empezar a escribir el código, para planificar cuestiones como:

¿Qué propiedades necesitan los objetos?

¿Cuáles son los métodos que ofrecen?      

¿Dónde implementamos cada método?

Es normal escribir las clases en archivos independientes que se llaman igual que la clase y se guardan en la misma carpeta que el archivo principal. Para vincular ambos archivos, al principio del archivo principal hay que poner la siguiente línea de código:

require("NombreClase")

El archivo de la clase se inicia con el constructor que contendrá los parámetros necesarios para definir los objetos de esa clase. La sintaxis es:

NombreClase = class(function(this, p1, p2, p3)
  this.P1 = p1		-- Parámetro 1
  this.P2 = p2		-- Parámetro 2
  this.P3 = p3		-- Parámetro 3 ...
end)

Observad que el paréntesis que inicia la clase se cierra tras el end de la función que define el constructor. El número de parámetros del constructor serán los que se consideren necesarios para definir las propiedades de los objetos.

Las clases tiene sus propios métodos definidos en la programación, por ejemplo pueden tener un método update() que se define como un bloque:

function NombreClase:update()

donde se  actualizarán los valores de los parámetros y variables necesarios para  programar el comportamiento de los objetos.

O su método draw() que contiene el código de las formas que va a dibujar.

function NombreClase:draw()

Pueden plantearse los métodos que se consideren necesarios, asignándoles el nombre que se vea oportuno para la función que realicen.

En el archivo principal, tras llamar a la clase, require("NombreClase"), se pueden crear los objetos que se quieran dándole valores concretos a los parámetros definidos en el constructor:

objetoClase1 = NombreClase(valorP1, valorP2, valorP3)
objetoClase2 = NombreClase(valorP1, valorP2, valorP3)

Vamos a analizar con más detalle la sintaxis a través de algunos ejemplos de clases simples

ARCHIVO DE LA CLASE

---------------------------------------------------
------- class Foco

-- constructor
Foco = class(
     function(this,x, d, s, g)
     this.posX = x -- posición X
     this.diam = d -- diametro
     this.speed = s -- velocidad
     this.grav = g -- gravedad
end
)

function Foco:update()
  self.speed = self.speed + (self.grav * self.diam)
  self.posX = self.posX + self.speed

  if self.posX > OUTPUT_WIDTH - self.diam/2  then
    self.speed = self.speed * -0.999722
  end
  if self.posX < 0 + self.diam/2 then
    self.speed = self.speed * -0.999722
  end
end

function Foco:draw()
    of.drawCircle(self.posX,OUTPUT_HEIGHT/2, self.diam)
end

---------------------------------------------------
------- end class foco

ARCHIVO PRINCIPAL

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    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
--    ----------------------------------------------------------   E-3-9
--
--	claseTest.lua: A simple class example
--	need Foco.lua inside same folder!!!
--

require("Foco")

mouseX = 0
mouseY = 0

foco1 = Foco(25, 50, 3.5, 0.00184562)   -- Crear dos objetos de la clase Foco
foco2 = Foco(125, 30, 1.5, 0.00184562)

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

----------------------------------------------------
function update()
  
  foco1:update()
  foco2:update()
end

----------------------------------------------------
function draw()
  mosaicBackground(0,0,0,3)

  of.setColor(255)
  foco1:draw()
  foco2:draw()
end

Como se ha mencionado antes, las clases suelen organizarse en archivos independientes, ubicados en la misma carpeta y desde el archivo principal se llama a la clase o clases, en este caso:

require("Foco")

En el archivo de la clase, se escribe el constructor, para ello deben conocerse los parámetros necesarios para definir las propiedades concretas de los objetos que queremos crear. En el ejemplo, el código del constructor se inicia con:

 Foco = class(function(foco, parametro1, parámetro2,...)

Y dentro de esa función, utilizando el operador «.» se define cada propiedad de los objetos con la identidad (foco.). Los paréntesis de  class contienen todo el bloque.

La clase planteada en el ejemplo tiene sus propios métodos update() y draw() para determinar los comportamientos y dibujar los objetos que se asocian a la clase mediante el operador «:» . En ambos bloques de la clase la identidad de los objetos se determina con «self.».

function Foco:update()

function Foco:draw()

Dentro del método :update(), para definir el comportamiento de movimiento, se suma el valor de la posición X a la velocidad, suma el valor de la velocidad al de la gravedad y se establecen las condiciones para cambiar el sentido de la velocidad cuando la coordenada X llega a los límites de la ventana. En el método :draw() se sitúa la funciones que dibujan el objeto.

En el archivo principal, como se ha indicado antes,  se llama al de la clase  con require("Foco"). Después se crean el objeto u objetos concretos, dando valores específicos a los parámetros determinados en el constructor. En este caso, los parámetros (x, d, s, g) para el objeto foco1 son (80, 80, 3.5, 0.00184562), es decir, el objeto aparece en la coordenada  x= 80, tiene un diámetro de 80 pixels, se mueve a una velocidad de 3.5 y con una gravedad de 0.00184562. En los bloques habituales de un programa en Lua, el código llama a los métodos de la clase.

En el siguiente ejemplo se combina tabla y clase con los pasos:

• Se define el objeto mediante una clase
• Se establece una tabla con objetos de esa clase
• Se generan los objetos mediante un evento de ratón

ARCHIVO CLASE

---------------------------------------------------
------- class Cosa

-- constructor
Cosa = class(
function(this,px,py,id)
this.px = px
this.py = py
this.radio = 40
this.radio2 =10
this.id = id
this.vx = of.random(-3.98183,3.984326)
this.vy = of.random(-2.98183,2.984326)
this.parpadea = 0
end
)

function Cosa:update()
    self.px = self.px + self.vx
    self.py = self.py + self.vy
    self.parpadea = math.floor(of.random(5, 8))

    if self.px - self.radio <= self.radio or self.px+self.radio*2 > OUTPUT_WIDTH then
        self.vx = self.vx * -1
    end

    if self.py - self.radio <= 0 or self.py + self.radio*1.5 > OUTPUT_HEIGHT then
        self.vy = self.vy * -1
    end

    if of.getElapsedTimeMillis()%self.parpadea == 0 then
        self.radio2 = 4
        self.radio = 35
    else
        self.radio2 = 10
        self.radio = 40
    end
end

function Cosa:draw()
    of.fill() 			-- fondo blanco círculos para superposición
    of.setColor(255)
    of.drawCircle(self.px - self.radio, self.py, self.radio)
    of.drawCircle(self.px +self.radio, self.py, self.radio)

    of.setColor(0) 		-- Contorno círculos anteriores
    of.setLineWidth(2)
    of.noFill()
    of.drawCircle(self.px - self.radio, self.py, self.radio)
    of.drawCircle(self.px + self.radio, self.py, self.radio)

    of.fill()			-- Círculos pequeños
    of.setColor(0)
    of.drawCircle(self.px - self.radio, self.py, self.radio2)
    of.drawCircle(self.px + self.radio, self.py, self.radio2)
    of.drawCircle(self.px, self.py + self.radio, self.radio/2)
end

---------------------------------------------------
------- end class foco

ARCHIVO PRINCIPAL

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    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
--    ----------------------------------------------------------   E-3-7
--
--	  Class and table example: A Lua script for Mosaic,
--
mouseX = 0 
mouseY = 0

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

require("Cosa")

maxCosas = 100
actualCosa = 0
cosas = {}


----------------------------------------------------
function setup()
  -- no inicializa los objetos de la clase 
  -- porque lo hace con un evento de ratón
   of.setCircleResolution(120)
end

----------------------------------------------------
function update()
   
   for i = 0, actualCosa-1 do  
     -- actualiza datos de las cosas actualmente creadas
     if actualCosa > 0 then
       cosas[i]:update()
     end
   end
end

----------------------------------------------------
function draw()
  -- draw background first
  of.setColor(255,255,255,255)
  of.drawRectangle(0,0,OUTPUT_WIDTH,OUTPUT_HEIGHT)
  
  for i = 0, actualCosa-1 do
    cosas[i]:draw()  -- dibuja los objetos creados
  end

  of.setColor(0)
  -- indica el número de objetos creados
  of.drawBitmapString(tostring(actualCosa),20,20) 
end

----------------------------------------------------
function exit()

end

-- input callbacks

----------------------------------------------------
function keyPressed(key)

end
----------------------------------------------------

function keyReleased(key)

end
----------------------------------------------------

function mouseMoved(x,y)
	mouseX = x
	mouseY = y
end
----------------------------------------------------

function mouseDragged(x,y)
	mouseX = x
	mouseY = y
end
----------------------------------------------------

function mouseReleased(x,y)
       if actualCosa < maxCosas then
            cosas[actualCosa] = Cosa(mouseX, mouseY, actualCosa) -- iguala la tabla a la clase
            actualCosa = actualCosa + 1   -- incrementa actualCosa +1 con cada evento del ratón
       end
end
----------------------------------------------------

Por último, un ejemplo que funciona con dos clases relacionadas entre sí. Se trata de la traducción a Lua-OFlua de uno de los ejemplos de sistemas de partículas de Daniel Shiffman en su libro Nature of Code, que utiliza una imagen png como núcleo de la partícula, la posición del ratón dirige la orientación horizontal del flujo de partículas, y el uso de  of.Vec2f() da mucha más fluidez a los movimientos.

El código de la primera clase Particle:

--
--
--	----------------------------------------------------------
--	OFlua | OF lua live coding
--
--	Copyright (c) 2020 Emanuele Mazza aka n3m3da
--
--	OFlua 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/OFlua for source code
--	----------------------------------------------------------


---------------------------------- OFlua SPECIFIC CODING INFO

-- OFlua system variable for loading external resources (files)
-- Example:
-- img = of.Image()
-- img:load(SCRIPT_PATH .. "/data/test.jpg")

---------------------------------- OFlua SPECIFIC CODING INFO


-- Simple Particle System
-- Daniel Shiffman <http://www.shiffman.net>

-- A simple Particle class

class 'Particle'

----------------------------------------------------
Particle = class(
function(this,pos,_img)
    this.loc = of.Vec2f(pos.x,pos.y)               -- position x, y
    this.vel = of.Vec2f(of.random(1),of.random(1)) -- speed
    this.acc = of.Vec2f(0,0)                       -- acceleration
    this.lifespan = 255
    this.decaying = of.random(2, 7)
    this.img = of.Image()
    this.img = _img
end
)

----------------------------------------------------
function Particle:run()
    self:update()
    self:display()
end
----------------------------------------------------

function Particle:applyForce(force)
    self.acc = self.acc + force    -- controls acceleration
end

----------------------------------------------------
function Particle:update()
 	self.vel = self.vel + self.acc  -- speed + acceleration
    self.loc = self.loc + self.vel  -- position + spped
    self.lifespan = self.lifespan - self.decaying -- life time
    self.acc = self.acc * 0         -- restart acceleration to applyForce

end

----------------------------------------------------
function Particle:display()
    of.setColor(255, 255, 255,self.lifespan)
    self.img:draw(self.loc.x, self.loc.y)
end

----------------------------------------------------
function Particle:isDead()
    if self.lifespan < 0.9 then
        return true      -- particle disappears
    else
        return false
    end

end
----------------------------------------------------

El código de la segunda clase ParticleSystem:

--
--
--	----------------------------------------------------------
--	OFlua | OF lua live coding
--
--	Copyright (c) 2020 Emanuele Mazza aka n3m3da
--
--	OFlua 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/OFlua for source code
--	----------------------------------------------------------
--
--
--	empty.lua: the basic OFlua template

---------------------------------- OFlua SPECIFIC CODING INFO

-- Mosaic system variable for loading external resources (files)
-- Example:
-- img = of.Image()
-- img:load(SCRIPT_PATH .. "/data/test.jpg")

---------------------------------- OFlua SPECIFIC CODING INFO


-- Simple Particle System
-- Daniel Shiffman <http://www.shiffman.net>

-- A simple Particle System class

class 'ParticleSystem'

----------------------------------------------------
ParticleSystem = class(
function(this,num, loc,_img)
    this.startPos = of.Vec2f(loc.x,loc.y)
    this.particles = {}
    this.index = 1
    this.img = of.Image()
    this.img = _img
    for i=0,num-1 do
        this:addParticle()
    end
end
)

----------------------------------------------------
function ParticleSystem:addParticle()
    table.insert(self.particles,Particle(self.startPos,self.img))
end

----------------------------------------------------
function ParticleSystem:applyForce(f)
    for k,v in pairs(self.particles) do
        self.particles[k]:applyForce(f)
    end
end

----------------------------------------------------
function ParticleSystem:run()
    for k,v in pairs(self.particles) do
    	self.particles[k]:run()
    	if self.particles[k]:isDead() then
    		self.particles[k] = nil
    	end
    end
end

----------------------------------------------------
function ParticleSystem:isDead()
    tableSize = # self.particles
    if tableSize == 0 then
        return true
    else
        return false
    end
end

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

Y el código del archivo principal:

--
--	----------------------------------------------------------
--	OFlua | OF lua live coding
--
--	Copyright (c) 2020 Emanuele Mazza aka n3m3da
--
--	OFlua 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/OFlua for source code
--	----------------------------------------------------------

---------------------------------- OFlua SPECIFIC CODING INFO

-- Mosaic system variable for loading external resources (files)
-- Example:
-- img = of.Image()
-- img:load(SCRIPT_PATH .. "/data/test.jpg")

---------------------------------- OFlua SPECIFIC CODING INFO
mouseX = 0
mouseY = 0

----------------------------------- MY VARS

baseImg = of.Image()
ground = of.Vec2f(1,0)
startPos = of.Vec2f(0,0)
wind = of.Vec2f(0,0)

require ("Particle")
require ("ParticleSystem")

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

    startPos = of.Vec2f(OUTPUT_WIDTH/2,OUTPUT_HEIGHT/2) -- initial position particle system
    baseImg:load(SCRIPT_PATH .. "/data/texture.png")    -- load image
    system = ParticleSystem(0,startPos,baseImg)         -- init ParticleSystem class
end

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

    dx = of.map(mouseX,0,OUTPUT_WIDTH,-0.2,0.2,true)       -- map mouseX position
    wind:set(dx,0)                                         -- wind.x = dx, wind.y = 0
    system:applyForce(wind)  -- call applyForce class method, wind (mouseX position) controls acceleration
    system:addParticle()     -- call addParticle class method, adds one particle per frame
end

----------------------------------------------------
function draw()

    -- draw background first
    of.setColor(0,0,0,255)
    of.drawRectangle(0,0,OUTPUT_WIDTH,OUTPUT_HEIGHT)

    -- draw particle system
    system:run()
    -- draw upper arrow
    drawVector(wind, of.Vec2f(OUTPUT_WIDTH/2, 50), 500) -- call custom function
end

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

function drawVector(v,loc,scayl)
    of.pushMatrix()
    arrowSize = 4
    of.translate(loc.x,loc.y,0)
    of.setColor(255)
    of.rotateZDeg(v:angle(ground))
    len = v:length()*scayl        --- Return the length (magnitude) of this vector
    -- draw arrow
    of.drawLine(0,0,len,0)
    of.drawLine(len,0,len-arrowSize,arrowSize/2)
    of.drawLine(len,0,len-arrowSize,-arrowSize/2)
    of.popMatrix()
end

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