Que es lua? , lua es un lenguaje de programación imperativo, estructurado y bastante ligero que fue diseñado como un lenguaje interpretado con una semántica extendible. El nombre significa "luna" en portugués y gallego.

Wikipedia: http://es.wikipedia.org/wiki/LUA

Manual de referencia lua 5.1: http://www.lua.org/manual/5.1/es/manual.html

Anfitriones o interpretes de lua para la consola  psp.

• ONElua
• Lua Dev 
• Lua HM
• Lua PGE

Como hacer mi propio juego en lua.

• Primer paso
• Conocimientos Basicos
• Mostrar imagen
• Mostrar texto
• Palabras reservadas
• Sentencias y condiciones
• Controles
• Función
• Tablas
• Lectura de la maquina
• Librería estándar
• Explorador de archivos

Primer paso.

nota: las funciones que vamos a utilizar en este tutorial, son para el interprete de Lua Dev.

¿Que necesito para empezar a hacer mi propio programa o juego para psp en lua?.

• Interprete, puede ser uno de los antes mencionados.
• Crear un archivo llamado script.lua.
• un editor de texto Notepad++.
• imágenes, sonidos, etc, esto no es necesario para empezar a programar pero si para hacer un buen programa.

Instalación:

para instalar nuestro homebrew, lo primero es tener el interprete que vamos a utilizar en este caso Lua Dev, dentro encontraran, un manual en formato .html, un Eboot.pbp, un manual en formato .txt, ahora conectamos el psp ala pc y crearemos una carpeta en nuestro PSP, en la ruta: ms0:/PSP/GAME/aqui , nombramos la carpeta como queramos, ejemplo: ms0:/PSP/GAME/mi juego/, dentro de la carpeta que creamos ponemos el Eboot.pbp, quedara: ms0:/PSP/GAME/mijuego/eboot.pbp, junto al Eboot.pbp creamos o ponemos el archivo script.lua, que es el que va a leer el interprete, listo la instalación esta hecha.

Ahora desde la pc abrimos notepad++, y en donde dice lenguaje elegimos el lenguaje lua, ahora desde el notepad++ abrimos el archivo script.lua , aquí vamos a escribir los códigos que leerá el interprete.

Conocimientos basicos

Aqui veremos las cosas básicas de lua.

¿Que es una variable?

literalmente una variable es un nombre que se le da a un valor, para poder utilizarlo cuantas veces quiera, y que este valor puede cambiar, conforme avanza el programa.

¿Cuantos tipos de variables hay?

hay tres tipos de variables.

LOCALES: la variable no puede salir del lugar de donde esta por ejemplo dentro de una if (condición) then, solo puede entrar a otras sentencias.

GLOBALES: por defecto todas las variables son globales, puede entrar y salir de cualquier sentencia.

CAMPOS DE TABLAS: puede almacenar muchas variables.

Los distintos valores que puede tener una variable.

NUMBER: 0-9.
 
STRING: "texto".
 
BOLEAN: true o false.
 
FUNCTION: funciones.
 
USERDATA: imágenes,fuentes,ficheros.
 
TABLET: tablas o array.
 
NIL: significa que no tiene valor.

Asi se crea una variable.

nombre = valor

Tambien se puenden crear muchas variables en una sola linea, solo hay que separar los nombres y los valores con comas.

nombre,nombre,nombre = valor,valor,valor

Ejemplo:

casa,carro,varco = 1,30,"juan"
 
Seria lo mismo así:
 
casa=1
 
carro=30
 
varco="julia"

Asi se utiliza.

nombre = "Persona"
 
edad= 20
 
estatura = 1.80
 
 
 
screen.print(10,10,nombre)
 
screen.print(10,10,edad)
 
screen.print(10,10,estatura)

¿Por que es nesesario crear variables?

en el ejemplo de arriba podríamos utilizar directamente los valores pero eso significaría que no podemos cambiar ese valor cuando el programa este en ejecución.

eso quiere decir que las variables nos sirven para poder cambiar los valores sin nesecidad de editar el código.

por ejemplo podemos cambiar la variable edad cuando le piquemos a un botón y en pantalla veremos que el valor esta cambiando, esto no es posible sin una variable.

¿Como se declara una variable local?

las variables de antemano son variables globales sin necesidad de declararlas como tal, para declarar una variable como local es muy sencillo

local variable=valor

si se declara una variable como local no puede ser  usada fuera de donde fue declarada, por ejemplo si declaramos una variable como local dentro de una función no se puede usar afuera de la función.

¿Cual es la ruta del psp?

cuando programemos para el psp siempre que queramos cargar una imagen o una fuente o un archivo, necesitaremos poner la ruta del archivo, para que el interprete carge ese archivo y lo podamos utilizar.

la ruta que usaremos siempre, depende si es un psp fat,slim o go.

"ms0:/" -- usar esta ruta para psp fat o slim.
"ef0:/" -- usar esta ruta para psp go.

siempre se ponen como texto "".

"ms0:/" -- es: eme(m), ese(s), cero(0), dos puntos(:), y diagonal(/).
 
"ef0:/" -- es: (e), efe(f), cero(0), dos puntos(:), y diagonal(/)

para facilitarnos la tarea podemos crear unas variables que guarden la ruta de trabajo.

r_trabajo="ms0:/psp/game/mi_juego/"

incluso podemos crear una para guardar la ruta ala carpeta donde tenemos las imágenes por ejemplo.

r_imagenes="ms0:/psp/game/mi_juego/imagenes/"  

para que cuando carguemos la imágenes que vallamos a utilizar solo pongamos.

personaje=image.load(r_imagenes.."personaje.png")

los dos puntos(..) sirven para unir textos, es como si pusiéramos.

personaje=image.load("ms0:/psp/game/mi_juego/imagenes/personaje.png")

Mostrar imagen

Ahora veremos como se muestra una imagen en pantalla.

para imprimir una imagen en pantalla, primero cargamos la imagen.

mi_imagen=image.load("mis_imagenes/imagen.png")

mi_imagen es la variable que guarda la imagen para poder utilizarla en la siguiente función, image.load() esta función sirve para cargar la imagen, dentro de los paréntesis debe ponerse la ruta donde se encuentra la imagen en formato texto es decir entre comillas "".

ahora a mostrar la imagen.

image.blit(mi_imagen,0,0)

image.blit(), esta función sirve para imprimir una imagen, (0,0), son las coordenadas donde se mostrara la imagen, la primera equivale a horizontal(X), la segunda equivale a vertical(Y), la pantalla de PSP contiene 480(X) por 272(Y) pixeles, cada pixel equivale a una posición empezando desde la posición cero(0) (la esquina superior izquierda) hasta la posición 479(X) o 271(Y) dando un total de 480 por 272 pixeles.

Lo que hemos puesto no es suficiente para poder ver la imagen en la pantalla, ya que existen unas funciones indispensables wile true do y screen.flip(),  que podríamos decir que todos los programas que hagamos de ahora en adelante deben tenerlo.

mi_imagen=image.load("Ruta a la imagen/imagen.png o jpg")
 
while true do
 
image.blit(mi_imagen,0,0)
 
screen.flip()
 
end

Mostrar texto

Veamos como se muestra un texto.

Para mostrar un texto en pantalla sin mas se utiliza la función.

screen.print(10,10,"Hola :D")

De esta forma mostrara el texto de color por default(blanco) y tamaño también por default(1), ya que no proporcionamos el color ni el tamaño.

Pero ala hora de hacer nuestro programa necesitaremos algo mas personalizado.

color_azul=color.new(0,0,200)
sombra=color.new(200,0,0)
tamano=0.5
 
screen.print(10,10,"Hola :D",tamano,color_azul,sombra)

Ahora esta mucho mejor, como pueden ver hemos creado dos colores y una variable de tipo numérica que utilizamos para el tamaño del texto, para crear los colores se utiliza la función color.new(), los valores que se le dan equivalen a R,G,B(Rojo,Verde,Azul) y un valor opcional A(transparencia), 0,0,0 es igual a negro, por el contrario 255,255,255 es igual a blanco, A por default es igual 255 significa sin transparencia, por el contrario 0 significa total transparencia, en ese caso el color no se ve, el ultimo argumento es la sombra del texto si no queremos sombra basta con poner 0x0.

Pero y si quiero utilizar otra fuente de texto, pues si hay mas para utilizar una fuente propia.

fuente=font.load("ruta_ala_fuente/fuente.pgf")
 
color_azul=color.new(0,0,200)
sombra=color.new(200,0,0)
tamano=0.5
 
 
screen.print(fuente,10,10,"Hello :D",tamano,color_azul,sombra)

Primero tuvimos que cargar la fuente, como pueden ver la fuente se pone como primer argumento.

como les dije antes así no basta ya que faltan las funciones indispensables while true do, y screen.flip().

fuente=font.load("ruta_ala_fuente/fuente.pgf")
 
color_azul=color.new(0,0,200)
sombra=color.new(200,0,0)
tamano=0.5
 
 
 
while true do
 
 
screen.print(fuente,10,10,"Hello :D",tamano,color_azul,sombra)
 
 
screen.flip()
end

El screen.flip() es la función que se encarga de mostrar todo en pantalla sin esa función no podríamos ver nada.

Resultado en pantalla.

sin fuente propia con tamaño 1 color azul y sombra roja.

Palabras reservadas

Estas son todas las palabras reservadas en lua, estas palabras no pueden usarse como nombre, son las herramientas con las que contamos junto ala librería estándar y las funciones de lua dev.

  and  break  do  else  elseif
  end  false  for  function  if
  in  local  nil  not  or
  repeat  return  then  true  until  while

Caracteres reservados:

 +     -     *     /     %     ^     #
 ==    ~=    <=    >=    <     >     =
 (     )     {     }     [     ]
 ;     :     ,     .     ..    ...

Les explicare para que sirve cada carácter.

Asignación = este carácter que es el que usaremos muchas veces ya que es el que sirve para asignar un valor cuando ponemos a=b , estamos pasando el valor de la variable b a la variable a, es decir el valor se pasa de derecha a izquierda, pero esto no quiere decir que b sera siempre igual ala a ni que a sera igual a b, solo le hemos pasado o copiado el valor que tiene b ala a, lo que quiere decir que si en un futuro le cambiamos el valor ala variable a=a+1 no afectara ala variable b al menos que se use b=a de nuevo como al principio.

Numérico #, este carácter sirve para saber cual es el máximo contenido de una tabla, por ejemplo.

tabla={"a","b","1","2"}
 
longitud_de_la_tabla = #tabla
 
 
--_resultado_--
 
longitud_de_la_tabla = 4

Caracteres de Comparación.

En lua todas las comparaciones devuelven true o false, si es verdadera la comparación entonces devuelve true y se ejecuta el codigo, sino devuelve false y no se ejecuta el codigo, 

Igualdad ==, devuelve true si los argumentos son iguales.

Diferente ~=, devuelve true si los argumentos son diferentes.

Mayor >, devuelve true si el primer argumento es mayor al segundo.

Menor <, devuelve true si el primer argumento es menor al segundo.

Mayor o igual >=, devuelve true si el primer argumento es mayor o igual al segundo.

Menor o igual <=, devuelve true si el primer argumento es menor o igual al segundo

Caracteres Matemáticos.

los caracteres matemáticos se utilizan de la siguiente manera, primero se pone la variable que recibirá el resultado final después se pone el carácter de asignación (=), después se pone la misma variable, después el carácter matemático y al final el valor que se desee, ejemplo (variable = variable + numero), también se pueden utilizar los caracteres matemáticos en una sentencia, en una llamada a función por ejemplo: screen.print(x+10,y+30,"TEXTO"),  para otorgar un valor temporal ala variable.

Suma +, se usa para sumar un valor, si una variable tiene el valor 10, y queremos sumarle ala misma variable un valor, puede ser cualquier valor numérico, variable=variable+1, como pueden ver se pone la misma variable antes y después 

Resta -, para restar un valor, variable=variable-1.

Multiplicación *, multiplica un valor, variable=variable*2, esto es: variable igual a variable multiplicado por dos.

División /, divide un valor, variable=variable/2, esto es: variable igual a variable dividido por dos.

Resto de la división %, devuelve el resto de la división, variable=variable%2, devolverá el sobrante de la división /2.

Sentencias y condiciones

Ahora veremos como son las condiciones en lua, para así controlar el flujo del programa.

primero veremos el bucle while, que lo que hace este bucle es repetir el código mientras la condición se cumpla, la condición se pone entre el while y el do.

while true do
 
 
 
 
 
 
 
end

la forma mas común usada, todo el código que este dentro del bucle se repetirá infinitamente, por eso decía que es indispensable por que sino lo ponemos el juego acabaría muy rápido, se pueden poner while dentro de while, para salir se utiliza la palabra break.

a=10
b=1
 
 
while a>b do
 
 
 
 
 
 
end

en este caso estoy utilizando unas variables esta condición dice mientras a sea mayor a b hacer.

If condición then , esta sentencia se utiliza de la siguiente manera,

if variable==true then
 
 
 
 
 
end

esto es: si variable es igual a true entonces ejecutamos el código que esta dentro de la sentencia.

pero hay mas, por ejemplo si queremos que haga algo aunque no se cumpla la condición, entonces agregamos la palabra else.

if variable==true then
 
 
 
 
else
 
 
 
 
end

esto es si la variable es igual a true entonces ejecutamos el código sino (else) este código fin (end).

pero también podemos agregar otra condición a else, else se cambia por la palabra elseif.

if variable==1 then
 
 
 
elseif variable==2 then
 
 
 
elseif variable==3 then
 
 
 
end

esto es, si variable es igual a 1 entonces, sino si variable es igual a 2 entonces, sino si variable es igual 3 entonces  fin, solo se ejecutara una de esas tres condiciones empezando desde la primera hasta la ultima, si la primera se cumple la segunda y tercera no se cumplen, también se puede poner al final un else .

el bucle for,este bucle se utiliza de la siguiente manera.

for i=1,10 do
 
 
end

lo que hace es parecido al while, solo que al for se le puede especificar un numero de inicio y otro de fin, esto es recorrerá el código con una variable local en este caso la hemos llamado i pero la pueden llamar como sea no importa pero es necesario crear una,en este caso el código se repetirá 10 veces, la variable i es una variable de control si no se desea utilizar no afecta en nada, la variable i en cada recorrido sumara 1 hasta llegar al limite que hemos puesto.

el for es especial para recorrer una tabla por ejemplo.

tabla={"a","b","c","d","e"}
 
for i=1,#tabla do
 
 
screen.print(100,100,tabla[i])
 
 
end

aquí primero creamos una tabla, después estoy imprimiendo el texto que esta en la tabla "a","b","c","d","e", y estoy utilizando la variable de control i, este carácter # devuelve el máximo contenido de la tabla, y lo utilice para poner el limite del for, así que solo recorrerá ese numero de veces y así no hay errores, ya que si se imprime por ejemplo tabla[6], provocara un error ya que no existe, no hay nada en la parte 6 de la tabla por que solo tenemos 5 cosas en la tabla.

al for también se le puede agregar un argumento mas, este equivale ala suma que se le dará ala variable de control.

paso=2
maximo=10
 
for i=1,maximo,paso do
 
 
 
 
end

de esta forma el for recorrerá el código empezando desde el numero 1 hasta el numero 10 de 2 en 2, esto quiere decir que el código solo se repetirá 5 veces.

Controles

Ahora veremos como utilizar los botones de la psp con lua dev.

para poder utilizar los controles en lua dev lo primero es poner esta función controls.read(), dentro del while.

while true do
 
controls.read()
 
 
 
 
 
 
 
 
 
end

esta función permite la lectura de los botones del psp, sino lo ponemos no podremos utilizar los controles, debe haber uno en cada bucle(while,for,repeat) si se desea utilizar los controles dentro del bucle.

Lista de los botones.

cross() = botón equis
 
circle() = botón circulo
 
triangle() = botón triangulo
 
square() = botón cuadro
 
down() = pad digital abajo
 
left() = pad digital izquierda
 
up() = pad digital arriba
 
right() = pad digital derecha
 
r() = botón derecho
 
l() = botón izquierdo
 
home() = botón home
 
hold() = botón hold
 
start() = botón start
 
select() botón select
 
analogx() pad analógico (x) derecha-izquierda
 
analogy() pad analógico (y) arriba-abajo

hay tres formas de usar los controles.

controls.boton()
 
controls.press("boton")
 
controls.release("boton")

la primera forma funciona mientras se tenga pulsado el botón, la segunda solo cuando se acaba de pulsar, la tercera cuando se acaba de soltar, la palabra boton solo es ilustrativa se debe cambiar por uno de la lista.

la forma mas común usada de los controles son dentro de una sentencia if.

if controls.cross() then
 
 
 
end

esto es: si se pulsa el botón equis entonces, se hace lo que esta dentro de la sentencia.

para combinar los botones se utiliza la palabra reservada and.

if controls.cross() and controls.circle() then
 
 
 
 
end

esto es: si se pulsa el botón equis y el botón circulo entonces, se hace lo que esta dentro de la sentencia, se pueden combinar todos los botones que quieran.

si queremos que cualquiera de los dos botones sea la condición, se utiliza la palabra or.

if controls.cross() or controls.circle() then
 
 
 
 
 
 
end

esto es: si se pulsa el botón equis o el botón circulo entonces, se hace lo que esta dentro de la sentencia.

para utilizar el análogo se debe comparar con números, ya que esta función devuelve un numero que va de -128 a 127, que izquierda y arriba serian de -128 a 0, y abajo y derecha serian de 0 a 127, quiere decir que si analogx() es menor a -100 el análogo esta a la izquierda, si es mayor a 100 esta ala derecha.

if controls.analogx() >100 then
 
 
 
end

esto es: si el análogo es mayor a cien entonces, se hace lo que esta dentro de la sentencia.

--_izquierda_--
 
if controls.analogx() <-100 then
 
 
end
 
--_derecha_--
 
if controls.analogx() >100 then
 
end
 
--_arriba_--
 
if controls.analogy() <-100 then
 
 
end
 
--_abajo_--
 
if controls.analogy() >100 then
 
end

Función

Ahora aprenderemos como crear y utilizar correctamente una función.

crear funciones es muy importante ala hora de programar ya que nos ayuda a realizar tareas repetitivas que si no creáramos funciones tendríamos que estar escribiendo lo mismo cada vez, también podemos hacer que una función pase de hacer una cosa a hacer otra con tan solo cambiar sus argumentos.

para crear una función se utiliza la palabra reservada function después el nombre que se le quiera dar ala función y dos paréntesis () y termina con un end, dentro de los paréntesis se pueden poner un sin números de argumentos pero es opcional, los argumentos son variables locales que solo se utilizan dentro de la función, y que al llamar ala función tenemos que inicializar esas variables con un valor de lo contrario su valor sera nil.

function mi_funcion(a,b,c,d)
 
 
(codigo)
 
 
 
 
end

esta función se llama mi_funcion y tiene como argumentos 4 variables locales, a,b,c,d.

las funciones se ejecutan solo cuando son llamadas, para llamar ala función que hemos creado, basta con poner su nombre y sus argumentos, si es que tiene.

mi_funcion(10,5,true,"hola")

aquí he puesto la función que cree arriba, y le he puesto valores a los argumentos, el argumento (a) es igual a 10, el argumento (b) es igual 5, el (c) es igual a true, y el (d) es igual a el texto "hola",

podemos llamar ala misma función las veces que queramos, otra cosa importante de la función es que podemos retornar un valor, por decirlo de alguna forma podemos retornar el resultado de lo que a hecho nuestra función.

para retornar uno o varios valores de una función se utiliza la palabra reservada return, seguido de los valores que se quieran retornar, tómese en cuenta que la función termina al retornar un valor.

function mi_funcion()
 
 
(codigo)
 
 
return a,b
 
end

en este caso cree una función y estoy retornando los valores de las variables (a) y (b).

para obtener los valores retornados basta con utilizar variables cuando llamamos ala función, después el carácter de asignación (=), y después la función, si la función retorna dos o mas valores hay que poner mas variables, separadas por comas, la primera variable recibe el primer valor retornado y la segunda el segundo valor retornado y así sucesivamente.

variable_1,variable_2=mi_funcion()

Lectura de la maquina

En este apartado les enseñare como es que la maquina lee los códigos que hemos programado, esto nos ayudara a entender mejor como funcionan los códigos y también para detectar mas rápidos los errores.

Vamos a ver el recorrido que hace la maquina en el código

Primero el interprete carga el archivo llamado script.lua, bien digamos que tengo este código.

la maquina empezara a leer el código desde la primera linea de izquierda a derecha luego la siguiente linea y así sucesivamente

1-> (entramos)-v
 
2-> (nada)-v
 
3-> (nada)-v
 
4-> (:D un while)-> while true do <-- aquí la maquina checara si la condición es verdadera o falsa(true o false).
 
5->(entre por que es verdadera)-v
 
6->screen.print(0,0,"Hola")-v <-- con esto se imprimirá un texto en pantalla pero todavia no asido mostrada.
 
7->(nada)
 
8->(nada)
 
9->(nada)
 
10->screen.flip() <-mostrare lo que hay en la pantalla
 
11-> end <- final del while tendré que regresar me al while true do, y comprobar nuevamente la condición.
 
12->(de aquí para abajo la maquina no ejecutara nada hasta que la condición del while sea falsa o se salga con un break)
 
13

Si llegamos a tener un error en el código y no encontramos el problema, puede ser que nos este diciendo mal la linea de error, esto pasa cuando utilizamos un dofile(), para comprobar esto hay que provocar un error a propósito después del dofile(), checamos en que linea provocamos el error a propósito y ejecutamos el programa, si hemos provocado un error por ejemplo en la linea 111, y el interprete nos dice que el error esta en la linea 123 significa que esta adelantado por 12, ahora ya sabemos donde esta el error de verdad, cada vez que nos salga un error le restamos 12 ala linea de error.

Tablas

En esta parte veremos como crear y utilizar una tabla y como funcionan.

¿Que es una tabla?

una tabla es una variable que guarda como una lista los valores que se le otorgan.

¿para que sirve una tabla?

una tabla sirve para almacenar muchos valores diferentes.

Así se crea una tabla vacía.

nombre_tabla = {}

Así se utiliza.

como es una tabla vacia antes de utilizarla hay que otorgarle valores.

nombre_tabla[1]="texto"
 
esto quiere decir que en la parte uno de la tabla estará el texto "texto".
 
para utilizarla se utiliza el indice así como le otorgamos el valor.
 
 
 
screen.print(0,0,nombre_tabla[1])

Lo bueno de las tablas es que podemos guardar muchos valores en una misma variable solo hay que cambiar el indice.

nombre_tabla[1]="hola"
 
nombre_tabla[2]=100
 
nombre_tabla[4]=true
 
nombre_tabla[5]=false

para crear la tabla utilizamos los caracteres {} y para utilizarla los caracteres [] .

también se pueden otorgar valores al momento de crear la tabla, los valores se ponen dentro de {}, y se separan por comas.

nombre_tabla={"texto",1,true,false}

se utilizan igual, con los indices.

También se pueden crear tablas dentro de las tablas.

nombre_tabla={{},{}}

en esta tabla hay dos tablas mas adentro las tablas esta en el indice 1 y 2, entonces para utilizar esas tablas se pone el indice donde se encuentra la tabla y otro indice donde se quire guardar el valor.

nombre_tabla[1][1]="hola" -- aquí estamos guardando el valor dentro la tabla 1 en la posición 1.
 
nombre_tabla[2][1]=100   -- aquí estamos guardando el valor dentro de la tabla 2 en el posición 1.

seria un error hacer esto.

nombre_tabla[1]="hola"

porque estaríamos cambiando la tabla que esta en el indice 1 por el texto "hola".

Librería estándar

• Biblioteca básica.
  • collectgarbage()
  • dofile()
  • loadfile()
  • tonumber()
  • tostring()
• Manejo de string.
• Manejo de tablas.
• Funciones matemáticas.
• Entrada y salida(I/O)
• Sistema operativo.

La biblioteca básica proporciona algunas funciones del núcleo de lua.

collectgarbage(), esta funciona sirve para limpiar la memoria de cosas que ya no utilizamos, por ejemplo si quiero eliminar una imagen que cargué anteriormente, por que ya no la voy a utilizar.

mi_imagen=image.load("mi_imagen.png")
 
menu=1
 
 
while true do
controls.read()
 
if menu==1 then
 
      image.blit(mi_imagen,0,0)
 
      if controls.press("cross") then
            menu=2
            mi_imagen=nil
            collectgarbage()
      end
 
elseif menu==2 then
 
       if controls.press("cross") then
 
            menu=3
       end
 
elseif menu==3 then
 
       if controls.press("cross") then
            menu=1
            mi_imagen=image.load("mi_imagen.png")
       end
 
end
 
 
screen.flip()
end

en este ejemplo puse 3 sentencias if, utilizando una variable numérica que llame menu como condición, en la primera sentencia puse a imprimir una imagen que es la que cargué al principio, también puse que si se pulsa el botón cross X, cambiamos la variable menu a 2 y puse que imagen es igual a nil, esto nos permitirá borrar la imagen, cuando llamo al collectgarbage se limpia la memoria y se borra por completo la imagen, esto significa que ya no podemos utilizarla tenemos que cargarla de nuevo, cosa que hago en la sentencia 3, pero para que quiero borrar una imagen?, pues simplemente por que entre menos memoria libre le quede al psp mas lento estará el programa.

dofile(), esta funcion sirve para ejecutar un codigo en lua que se encuentre en otro archivo, sirve mucho a la hora de dividir nuestro programa en partes.

dofile("otras_funciones.lua")
dofile("sistema.lua")
dofile("aqui_tengo_otro_codigo.lua")
 
 
while true do
 
 
 
 
 
 
end

loadfile(), esta función es parecida a dofile() la única diferencia es que el archivo cargado se convierte en una función, y que es necesario llamar a la función.

una_funcion=loadfile("aqui_hay_codigo.lua")
 
 
while true do
 
 
una_funcion()
 
 
end

tonumber(), esta función intenta convertir el argumento en numero, se puede especificar la base véase Manual de referencia lua 5.1

numero=tonumber("125")

tostring(), esta función, intenta convertir el argumento en string "texto", si el valor proporcionado no existe, osea que es igual a nil, devolverá el texto "nil".

texto=tostring(variable)
otro_texto=tostring(123)

• Biblioteca básica.
• manejo de string.
  • string.byte()
  • string.char()
  • string.dump()
  • string.find()
  • string.format()
  • string.gmatch()
  • string.gsub()
  • string.len()
  • string.lower()
  • string.match()
  • string.rep()
  • string.reverse()
  • string.sub()
  • string.upper()
  • patrones
• Manejo de tablas.
• Funciones matemáticas.
• Entrada y salida(I/O)
• Sistema operativo.

Esta biblioteca proporciona funciones genéricas de manejo de strings, tales como encontrar y extraer texto y detectar patrones,en lua el primer carácter está en la posición 1 (no en 0 como en C), se permite el uso de índices negativos que se interpretan como indexado hacia atrás, desde el final del texto, por tanto el último carácter del texto está en la posición -1, el penúltimo en la posición -2 y así sucesivamente.

string.byte(texto,inicio,fin), devuelve el código numérico interno de los caracteres del texto, inicio y fin son argumentos opcionales, inicio por defecto es igual a 1 y fin es igual a inicio

texto="abcde"
 
extraccion=string.byte(texto)
 
 
extraccion_2=string.byte(texto,1,-1)
 
 
 
while true do
 
 
screen.print(10,10,extraccion)
 
 
screen.print(10,30,extraccion_2)
 
 
 
 
 
screen.flip()
end

aquí tengo un texto que es igual a "abcde", en el primer string.byte(), me devolverá los códigos internos de "a", porque "a" esta en la posición 1, y como no puse ningún argumento inicio es igual a 1 y fin es igual a inicio, es como si hubiera puesto string.byte(texto,1,1), en el segundo me devolverá los códigos numéricos internos de todo el texto "abcde", por que en el 2do argumento puse 1 y en el 3er argumento puse -1 esto hace referencia al primer y ultimo carácter, es decir que me devolverá desde el primero hasta el ultimo.

string.char(argumentos), recibe cero o más enteros, devuelve un texto con igual longitud que el número de argumentos, en el que cada carácter tiene un código numérico interno igual a su correspondiente argumento, es lo contrario de string.byte().

string.dump(función), recibe una función, devuelve un texto que contiene la representación binaria de la función dada.

string.find(texto,patron,inicio,básica), busca la primera aparición del patrón en el texto, Si la encuentra, devuelve los índices del texto donde comienza y acaba la aparición, en caso contrario retorna nil, Un tercer argumento numérico opcional inicio especifica dónde comenzar la búsqueda, su valor por defecto es 1 y puede ser negativo, Un valor true como cuarto argumento opcional básica desactiva las utilidades de detección de patrones, realizando entonces una "búsqueda básica de texto", sin caracteres "mágicos" en el patrón. Téngase en cuenta que si se proporciona el argumento básica también debe proporcionarse el argumento inicio, Si el patrón tiene capturas entonces en una detección con éxito, se devuelven los valores capturados, después de los dos índices.

texto="abcde"
 
empieza,acaba=string.find(texto,"d",1,true)

en este ejemplo estoy buscando el texto "d", me devolverá los indices donde empieza y acaba el texto que estoy buscando, en este caso me devolverá los números 4 y 4, ya que el texto "d" empieza en la posición 4 y acaba en la posición 4 porque es un solo carácter.

string.format(formato,""), devuelve una versión formateada de sus argumentos (en número variable) siguiendo la descripción dada en su primer argumento (formato, que debe ser un texto). El texto de formato sigue las mismas reglas que la familia de funciones C estándar printf, Las únicas diferencias son que los modificadores, *, l, L, n, p, h, no están soportadas, y que existe una opción extra q, Esta última opción da formato a un texto en una forma adecuada para ser leída de manera segura de nuevo por el intérprete de Lua, el texto es escrito entre dobles comillas, y todas las dobles comillas, nuevas líneas, ceros y barras inversas del texto se sustituyen por las secuencias de escape adecuadas en la escritura, Por ejemplo.

string.format('%q', 'un string con "comillas" y \n nueva línea')
 
 
producirá el string:
 
"un string con \"comillas\" y \
 nueva línea"

Las opciones c, d, E, e, f, g, G, i, o, u, X y x esperan un número como argumento, mientras que q y s esperan un texto, esta función no acepta valores de textos que contengan caracteres cero, excepto como argumentos de la opción q.

string.gmatch(texto,patron), devuelve una función iteradora que, cada vez que se invoca, retorna las siguientes capturas del patrón en el texto, si el patrón no produce capturas entonces la coincidencia completa se devuelve en cada llamada.

texto="hola mundo desde Lua"
 
for w in string.gmatch(s, "%a+") do
 
        print(w)
 
end

iterará sobre todas las palabras del texto, imprimiendo una por línea.

el siguiente ejemplo devuelve en forma de tabla todos los pares clave=valor del texto dado.

 tabla = {}
 
texto = "desde=mundo, a=Lua"
 
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
 
      tabla[k] = v
 
end

para esta función, un '^' al principio de un patrón no funciona como un ancla, sino que previene la iteración.

string.gsub(texto,patron,reemplazamiento,[numero]), devuelve una copia del texto en la que todas o las numero primeras, si se especifica el argumento opcional, las apariciones del patrón han sido reemplazadas por el reemplazamiento especificado, que puede ser un texto, una tabla o una función. gsub también devuelve, como segundo valor, el número total de coincidencias detectadas. si reemplazamiento es un texto entonces su valor se usa en la sustitución. El carácter % funciona como un carácter de escape, cualquier secuencia en el reemplazamiento de la forma %num, con num entre 1 y 9, significa el valor de la captura número num en el sub texto (véase más abajo), La secuencia %0 significa toda la coincidencia, La secuencia %% significa un carácter porcentaje %.

Si reemplazamiento es una tabla entonces en cada captura se devuelve el elemento de la tabla que tiene por clave la primera captura, si el patrón no proporciona ninguna captura entonce toda la coincidencia se utiliza como clave.

Si reemplazamiento es una función entonces la misma es invocada cada vez que exista una captura con todos los sub textos capturados pasados como argumentos en el mismo orden, si no existen capturas entonces toda la coincidencia se pasa como un único argumento.

Si el valor devuelto por la tabla o por la llamada a la función es un texto o un número, entonces se usa como texto de reemplazamiento, en caso contrario si es false o nil, entonces no se realiza ninguna sustitución (esto es, la coincidencia original se mantiene en el texto).

ejemplos.

x = string.gsub("hola mundo", "(%w+)", "%1 %1")
 
   --> x="hola hola mundo mundo"
 
x = string.gsub("hola mundo", "%w+", "%0 %0", 1)
 
   --> x="hola hola mundo"
 
x = string.gsub("hola mundo desde Lua", "(%w+)%s*(%w+)", "%2 %1")
 
   --> x="mundo hola Lua desde"
 
x = string.gsub("casa = $HOME, usuario = $USER", "%$(%w+)", os.getenv)
 
   --> x="casa = /home/roberto, usuario = roberto"
 
x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s) return loadstring(s)() end)
 
   --> x="4+5 = 9"
 
  local t = {nombre="lua", versión="5.1"}
 
   x = string.gsub("$nombre-$versión.tar.gz", "%$(%w+)", t)
 
   --> x="lua-5.1.tar.gz"

string.len(texto), resibe un texto y devuelve un numero que es la longitud del texto, el texto vació "" tiene longitud 0.

longitud=string.len("Hola")
 
longitud_2=string.len("Que hay!")
 
longitud_3=string.len("Hola mundo desde lua")

aquí por ejemplo, la variable longitud es igual a 4, longitud_2 es igual a 8, longitud_3 es igual a 20, digamos que cada carácter vale 1, recuerden que también se cuentan los espacios en blanco " " y los caracteres "0" cero.

string.lower(texto), recibe un texto y devuelve el mismo texto pero con todas
las letras mayúsculas cambiadas a minúsculas, el resto de los caracteres
permanece sin cambios, La definición de letra mayúscula depende del
sistema local.

string.match(texto,patron,inicio), busca la primera aparición del patrón en el texto, si encuentra una, entonces string.match() retorna la captura del patrón, en caso contrario devuelve nil, si el patrón no produce ninguna captura entonces se devuelve la coincidencia completa, Un tercer y opcional argumento numérico inicio especifica dónde comenzar la búsqueda, su valor por defecto es 1 y puede ser negativo.

string.rep(texto,numero de repeticiones), devuelve un texto que es una concatenación de las repeticiones del texto

texto="Hola"
 
repeticiones=string.rep(texto,3)
 
--_"resultado"_--
 
repeticiones="HolaHolaHola"

string.reverse(texto), devuelve un texto que es el original pero invertido.

texto="anita lava la tina"
 
texto_alrevez=string.reverse(texto)
 
--_"resultado"_--
 
texto_alrevez="anit al aval atina"

string.sub(texto,inicio,fin), devuelve una parte del texto, que comienza en inicio y continúa hasta fin, inicio y fin pueden ser negativos, Si fin está ausente entonces se asume que vale -1 (equivalente a la longitud del texto), En particular, la llamada string.sub(texto,1,fin) retorna un prefijo del texto con longitud fin, y string.sub(texto, -inicio) retorna un sufijo del texto con longitud inicio.

texto="Hola mundo desde lua?"
 
extraccion=string.sub(texto,-4)
 
 
extraccion_2=string.sub(texto,1,10)
 
 
---_"Resultado"_---
 
extraccion="lua?"
 
 
extraccion_2="Hola mundo"

esta función es muy útil ala hora de manipular los string, con esta función se puede extraer texto de una forma muy sencilla.

string.upper(texto), recibe un texto y devuelve el mismo texto pero con todas las letras minúsculas cambiadas a mayúsculas, el resto de los caracteres permanece sin cambios, la definición de letra minúscula depende del sistema local.

texto="abcde"
 
 
texto_cambiado=string.upper(texto)
 
 
--_"Resultado"_--
 
texto_cambiado="ABCDE"

Patrones,

Clases de caracteres:

Se usan clases de caracteres para representar conjuntos de caracteres. Están permitidas las siguientes combinaciones para describir una clase de caracteres:

    x: (donde x no es uno de los caracteres mágicos ^$()%.[]*+-?) representa el propio carácter x.
    .: (un punto) representa cualquier carácter.
    %a: representa cualquier letra.
    %c: representa cualquier carácter de control.
    %d: representa cualquier dígito.
    %l: representa cualquier letra minúscula.
    %p: representa cualquier carácter de puntuación.
    %s: representa cualquier carácter de espacio.
    %u: representa cualquier letra mayúscula.
    %w: representa cualquier carácter alfanumérico.
    %x: representa cualquier dígito hexadecimal.
    %z: representa el carácter con valor interno 0 (cero).
    %x: (donde x es cualquier carácter no alfanumérico) representa el carácter x. Ésta es la manera estándar de "escapar" los caracteres mágicos. Cualquier carácter de puntuación (incluso los no mágicos) pueden ser precedidos por un signo de porcentaje '%' cuando se quieran representarse a sí mismos en el patrón.

    [conjunto]: representa la clase que es la unión de todos los caracteres en el conjunto. Un rango de caracteres puede ser especificado separando el carácter del principio y del final mediante un guión '-'. Todas las clases del tipo %x descritas más arriba pueden ser también utilizadas como componentes del conjunto. Todos los otros caracteres en el conjunto se representan a sí mismos. Por ejemplo, [%w_] (o [_%w]) representa cualquier carácter alfanumérico o el subrayado, [0-7] representa un dígito octal, y [0-7%l%-] representa un dígito octal, una letra minúscula o el carácter '-'.

    La interacción entre los rangos y las clases no está definida. Por tanto, patrones como [%a-z] o [a-%%] carecen de significado.

    [^conjunto]: representa el complemento de conjunto, donde conjunto se interpreta como se ha indicado más arriba.

Para todas las clases representadas por letras simples (%a, %c, etc.) las correspondientes letras mayúsculas representan la clase complementaria. Por ejemplo, %S representa cualquier carácter no espacio.

Las definiciones de letra, espacio y otros grupos de caracteres dependen del sistema local. En particular, la clase [a-z] puede no ser equivalente a %l.
Elementos de un patrón

Cada elemento de un patrón puede ser

    una clase de carácter simple, que equivale a cualquier carácter simple de la clase;
    una clase de carácter simple seguida por '*', que equivale a 0 ó más repeticiones de los caracteres de la clase. Estos elementos de repetición siempre equivaldrán a la secuencia de caracteres más larga posible;
    un clase de carácter simple seguida por '+', que equivale a 1 ó más repeticiones de los caracteres de la clase. Estos elementos de repetición siempre equivaldrán a la secuencia de caracteres más larga posible;
    un clase de carácter simple seguida por '-', que también equivale a 0 ó más repeticiones de los caracteres de la clase. Al contrario que '*', Estos elementos de repetición siempre equivaldrán a la secuencia de caracteres más corta posible;
    una clase de carácter simple seguida por '?', que equivale a 0 ó 1 apariciones de un carácter de la clase;
    %n, para n entre 1 y 9; este elemento equivale a un sub texto igual a la captura número n;
    %bxy, donde x e y son dos caracteres diferentes; este elemento equivale a texto que comienzan con x, finalizan con y, estando equilibrados x e y. Esto significa que, iniciando un contador a 0, si se lee el texto de izquierda a derecha, sumando +1 por cada x que aparezca y -1 por cada y, el y final es el primero donde el contador alcanza 0. Por ejemplo, el elemento %b() equivale a una expresión con paréntesis emparejados.

Patrón

Un patrón es una secuencia de elementos de patrón. Un '^' al comienzo de un patrón ancla la búsqueda del patrón al comienzo del texto en el que se produce la búsqueda. Un '$' al final de un patrón ancla la búsqueda del patrón al final del texto en el que se produce la búsqueda. En otras posiciones '^' y '$' no poseen un significado especial y se representan a sí mismos.

Capturas

Un patrón puede contener sub patrones encerrados entre paréntesis que describen capturas. Cuando sucede una coincidencia entre un patrón y un texto dado, los sub textos que concuerdan con lo indicado entre paréntesis en el patrón, son almacenados (capturados) para uso futuro. Las capturas son numeradas de acuerdo a sus paréntesis izquierdos. Por ejemplo, en el patrón "(a*(.)%w(%s*))", la parte del texto que concuerda con "a*(.)%w(%s*)" se guarda en la primera captura (y por tanto tiene número 1); el carácter que concuerda con "." se captura con el número 2, y la parte que concuerda con "%s*" tiene el número 3.

Como caso especial, la captura vacía () retorna la posición actual en el texto (un número). Por ejemplo, si se aplica el patrón "()aa()" al texto "flaaap", dará dos capturas: 3 y 5.

Un patrón no puede contener caracteres cero. Úsese %z en su lugar.

• Biblioteca básica.
• Manejo de string.
• Manejo de tablas.
  • table.concat()
  • table.insert()
  • table.maxn()
  • table.remove()
  • table.sort()
• Funciones matemáticas.
• Entrada y salida(I/O)
• Sistema operativo.

Esta biblioteca proporciona funciones genéricas para manejo de tablas.

table.concat(tabla,separador,inicio,fin), dado a una tabla donde todos sus elementos son textos o números devuelve una concatenación de los elementos de la tabla, tabla[inicio]..separador..tabla[inicio+1] ··· separador..tabla[fin], el valor por defecto de separador es el texto vacío "", el valor por defecto de inicio es 1 y el valor por defecto de fin es la longitud de la tabla, si inicio es mayor que fin, la función devuelve un texto vacío.

tabla={"a","b","c","d","e","f","g"}
 
 
encadenacion_1=table.concat(tabla,"")
 
 
encadenacion_2=table.concat(tabla,"_")
 
 
--_"Resultado"_--
 
encadenacion_1="abcdefg"
 
 
encadenacion_2="a_b_c_d_e_f_g"

table.insert(tabla,posicion,valor), inserta un elemento en la posición dada en la tabla, desplazando hacia adelante los elementos desde la posicion para adelante, el valor por defecto de posición es la longitud de la tabla mas 1 , de tal manera que table.insert(tabla,x) inserta x al final de la tabla.

tabla_1={"manzana","platano","naranja","mandarina","melon","papaya","sandia"}
 
tabla_2{"1","2","3","4","5","6","7","8","9"}
 
 
 
table.insert(tabla_1,"pera")
 
 
table.insert(tabla_2,3,"10")
 
 
--_"Resultado"_--
 
 
tabla_1={"manzana","platano","naranja","mandarina","melon","papaya","sandia","pera"}
 
tabla_2={"1","2","10","3","4","5","6","7","8","9"}

en este ejemplo tengo dos tablas, en tabla_1 hemos insertado al final de la tabla un elemento, ya que por defecto la posición es el final de la tabla+1,  en la segunda tabla, tabla_2 insertamos un elemento en la posición 3 de la tabla, como pueden ver el elemento que antes estaba en la posición 3 de la tabla se desplazo hacia delante, quedando en la posición numero 4 de la tabla, el elemento que era 4 ahora esta en el 5 y así sucesivamente.

table.maxn(tabla), devuelve el mayor índice numérico positivo de una tabla o cero si la tabla no tiene índices numéricos positivos,(Para hacer su trabajo esta función realiza un barrido lineal de la tabla completa) si se desea obtener la longitud de la tabla úsese mejor # antes de la tabla ( #tabla ).

table.remove(tabla,posicion), elimina un elemento de la tabla situado en la posición dada, desplazando hacia atrás los elementos que están delante para cerrar espacio, si es necesario. Devuelve el valor del elemento eliminado. El valor por defecto de posición es #tabla, donde #tabla es la longitud de la tabla, por lo que la llamada table.remove(tabla) elimina el último elemento de la tabla.

table.sort(tabla,comparador), ordena los elementos de la tabla en un orden dado modificando la tabla, desde table[1] hasta table[n], donde n es la longitud de la tabla, si se proporciona el argumento comparador éste debe ser una función que recibe dos elementos de la tabla y devuelve verdadero cuando el primero es menor que el segundo (por lo que not comparador(a[i+1],a[i]) será verdadero después de la ordenación), si no se proporciona una función comparador entonces se usa el operador estándar < de Lua, el algoritmo de ordenación no es estable, esto es, los elementos considerados iguales por la ordenación dada pueden sufrir cambios de orden relativos después de la ordenación.

• Biblioteca básica.
• Manejo de string.
• Manejo de tablas.
• Funciones matemáticas.
  • math.abs()
  • math.acos()
  • math.asin()
  • math.atan()
  • math.atan2()
  • math.ceil()
  • math.cos()
  • math.cosh()
  • math.deg()
  • math.exp()
  • math.floor()
  • math.fmod()
  • math.frexp()
  • math.huge
  • math.ldexp()
  • math.log()
  • math.log10()
  • math.max()
  • math.min()
  • math.modf()
  • math.pi
  • math.pow()
  • math.rad()
  • math.random()
  • math.randomseed()
  • math.sin()
  • math.sinh()
  • math.sqrt
  • math.tan
  • math.tanh()
• Entrada y salida(I/O)
• Sistema operativo

Esta biblioteca es una interfaz a la biblioteca matemática estándar de C.

math.abs(x), devuelve el valor absoluto de x.

math.acos(x), devuelve el arco coseno de x (en radianes).

math.asin(x), devuelve el arco seno de x (en radianes).

math.atan(x), devuelve el arco tangente de x (en radianes).

math.atan2(y,x), devuelve el arco tangente de y/x (en radianes), pero usa los signos de ambos argumentos para determinar el cuadrante del resultado, (También maneja correctamente el caso en que x es cero).

math.ceil(x), devuelve el menor entero mayor o igual que x.

math.cos(x), devuelve el coseno de x (se asume que esta en radianes).

math.cosh(x), devuelve el coseno hiperbólico de x.

math.deg(x), devuelve en grados sexagesimales el valor de x (dado en radianes).

math.exp(x), devuelve el valor de ex.

math.floor(x), devuelve el mayor entero menor o igual que x.

math.fmod(x,y), devuelve el resto de la división de x por y.

math.frexp(x), Devuelve m y e tales que x = m 2e, e es un entero y el valor absoluto de m está en el intervalo [0.5, 1) (o cero cuando x es cero).

math.huge, el valor HUGE_VAL, un valor más grande o igual que otro valor numérico cualquiera.

math.ldexp(m,e), devuelve m 2e (e debe ser un entero).

math.log(x), devuelve el logaritmo natural de x.

math.log10(x), devuelve el logaritmo decimal (base 10) de x.

math.max(x, ... ), devuelve el mayor valor de entre sus argumentos.

math.min(x, ... ), devuelve el menor valor de entre sus argumentos.

math.modf(x), devuelve dos números, las partes entera y fraccional de x.

math.pi, el valor de pi.

math.pow(x,y), devuelve xy, (Se puede también usar la expresión x^y para calcular este valor.)

math.rad(x), devuelve en radianes el valor del ángulo x (dado en grados sexagesimales).

math.random(mínimo,máximo),  esta función es un interface a rand, generador simple de números pseudo-aleatorios proporcionado por el ANSI C, (Sin garantías de sus propiedades estadísticas), cuando se invoca sin argumentos devuelve un número pseudoaleatorio real uniforme en el rango [0,1). Cuando se invoca con un número entero mínimo, math.random devuelve un número pseudoaleatorio entero uniforme en el rango [1, mínimo]. Cuando se invoca con dos argumentos mínimo y máximo enteros, math.random devuelve un número pseudoaleatorio entero uniforme en el rango [mínimo, máximo].

math.randomseed(x), Establece x como "semilla" para el generador de números pseudoaleatorios, iguales semillas producen iguales secuencias de números.

math.sin(x), devuelve el seno de x (se asume que esta en radianes)

math.sinh(x), devuelve el seno hiperbólico de x.

math.sqrt(x), devuelve la raíz cuadrada de x, (Se puede usar también la expresión x^0.5 para calcular este valor.)

math.tan(x), devuelve la tangente de x (se asume que está en radianes).

math.tanh(x), devuelve la tangente hiperbólica de x.

• Biblioteca básica.
• Manejo de string.
• Manejo de tablas.
• Funciones matemáticas.
• Entrada y salida(I/O)
  • io.close()
  • io.flush()
  • io.input()
  • io.lines()
  • io.open()
  • io.output()
  • io.popen()
  • io.read()
  • io.write()
  • io.seek()
  • io.tmpfile()
  • io.type()
  • io.setvbuf()
• Sistema operativo.

La biblioteca de entrada/salida (I/O de sus siglas en inglés) proporciona dos estilos diferentes de manejo de ficheros, el primero de ellos usa descriptores de fichero implícitos, esto es, existen dos ficheros por defecto, uno de entrada y otro de salida, y las operaciones se realizan sobre éstos, el segundo estilo usa descriptores de fichero explícitos, cuando se usan descriptores implícitos todas las operaciones soportadas están en la tabla io. Cuando se usan descriptores explícitos, la operación io.open devuelve un descriptor de fichero y todas las operaciones se proporcionan como métodos asociados.

fichero=io.open("ruta_al_archivo")
 
fichero:read("")

la tabla io también proporciona tres descriptores de fichero predefinidos con sus significados usuales en C, io.stdin, io.stdout e io.stderr, la biblioteca de entrada/salida nunca cierra esos ficheros, a no ser que se especifique, todas las funciones de entrada/salida devuelven nil en caso de fallo (más un mensaje de error como segundo resultado y un código de error dependiente del sistema como un tercer resultado) y valores diferentes de nil si hay éxito.

Ejemplo de uso.

--_Primero hay que abrir el archivo en el modo que necesitemos_--
 
--_modo lectura_--
 
fichero = io.open("ruta_al_archivo")
 
--_para leer el archivo en el formato que necesitemos_--
 
texto = fichero:read("formato")
 
while true do
 
 
screen.print(100,50,texto)
 
 
screen.flip()
 
end
 
--_Modo escritura_--
 
fichero = io.open("ruta_al_archivo","w")
 
--_Para escribir un texto en el archivo_--
 
fichero:write("había una vez")
 
--_Para guardar lo que hemos escribido_--
 
fichero:flush()
 
--_Por si queremos cerrar el archivo_--
 
fichero:close()
 
--[[
recuerden que si cerramos el archivo ya no podemos escribir ni leer el archivo, si tenemos un archivo abierto, no podremos copiar ni mover el archivo primero hay que cerrarlo.
si se abre un archivo en modo escritura "w" si el archivo existe se borrara todo lo que tenga escrito, si no existe se creara uno, para escribir y leer sin que se borre hay que abrirlo con "r+", si quieren que se borre "w+".
]]--

io.close(), sin argumentos cierra el descriptor que esta por defecto, para cerrar un fichero en especifico úsese nombre_del_descriptor_de_fichero:close(), o también, io.close(nombre_del_descriptor_de_fichero).

io.flush(), guarda lo que se escrito, sin argumentos se aplica al descriptor que esta por defecto, para guardar un fichero en especifico úsese, nombre_del_descriptor_de_fichero:flush().

io.input([descriptor_de_fichero | nombre_de_fichero]), cuando se invoca con un nombre de fichero entonces lo abre (en modo texto), y establece su manejador de fichero como fichero de entrada por defecto, cuando se llama con un descriptor de fichero simplemente lo establece como manejador para el fichero de entrada por defecto, cuando se invoca sin argumento devuelve el fichero por defecto actual, en caso de errores esta función activa error en lugar de devolver un código de error

io.lines([nombre_de_fichero]), abre el fichero de nombre dado en modo lectura y devuelve una función iteradora que, cada vez que es invocada, devuelve una nueva línea del fichero, por tanto, la construcción.

for linea in io.lines(nombre_de_fichero) do 
bloque 
end

iterará sobre todas las líneas del fichero. Cuando la función iteradora detecta el final del fichero devuelve nil (para acabar el bucle) y cierra automáticamente el fichero, la llamada a io.lines() (sin nombre de fichero) equivale a io.input():lines(), esto es, itera sobre todas las líneas del fichero por defecto de entrada, en ese caso no cierra el fichero cuando acaba el bucle.

io.open(nombre_de_fichero,modo), Esta función abre un fichero, en el modo especificado en el texto modo, devuelve un descriptor de fichero, o en caso de error, nil además de un mensaje de error.

El texto que indica modo puede ser uno de los siguientes:
 
    "r": modo lectura (por defecto).
    "w": modo escritura.
    "a": modo adición.
    "r+": modo actualización, lectura/escritura, todos los datos preexistentes se mantienen.
    "w+": modo actualización,lectura/escritura, todos los datos preexistentes se borran.
    "a+": modo adición con actualización, todos los datos preexistentes se mantienen, y la escritura se permite sólo al final del fichero.

El texto que indica el modo puede contener también "b" al final, lo que es necesario en algunos sistemas para abrir el fichero en modo binario, este texto es exactamente el que se usa en la función estándar de C fopen.

io.output([descriptor_de_fichero | nombre_de_fichero]), similar a io.input, pero operando sobre el fichero por defecto de salida.

io.popen(prog [, modo]), comienza a ejecutar el programa prog en un proceso separado y retorna un descriptor de fichero que se puede usar para leer datos que escribe prog (si modo es "r", el valor por defecto), o (si modo es "w") para escribir datos que lee prog, esta función depende del sistema operativo y no está disponible en todas las plataformas.

io.read(formato), lee en el fichero dado, descriptor_de_fichero:read(formato), de acuerdo el formato proporcionado, el cual especifica qué leer, para cada formato, la función devuelve un texto (o un número) con los caracteres leídos, o nil si no pudo leer los datos con el formato especificado, cuando se invoca sin formato se usa uno por defecto que lee la próxima línea completa.

Los formatos disponibles son
 
    "*n": lee un número; éste es el único formato que devuelve un número en lugar de un texto.
    "*a": lee el resto del fichero completo, empezando en la posición actual, al final del fichero devuelve un texto vacío "".
    "*l": lee la próxima línea (saltándose el final de línea), retornando nil al final del fichero. Éste es el formato por defecto.
    un número: lee un texto como máximo este número de caracteres, devolviendo nil si se llega al final del fichero, si el número es cero no lee nada y devuelve un texto vacío, o nil si se alcanza el final del fichero. 

io.write(""), escribe en el descriptor de fichero dado, descriptor_de_fichero:write("abcd").

descriptor_de_fichero:seek([de_dónde] [, desplazamiento]), establece (o solicita) la posición actual (del puntero de lectura/escritura) en el descriptor_de_fichero, medida desde el principio del fichero, en la posición dada por desplazamiento más la base especificada por el texto dónde, como se especifica a continuación.

"set": sitúa la posición base en 0 (comienzo del fichero);
    "cur": sitúa la posición base en la actual;
    "end": sitúa la posición base al final del fichero.

en caso de éxito la función seek retorna la posición final (del puntero de lectura/escritura) en el fichero medida en bytes desde el principio del fichero, si la llamada falla retorna nil, más un texto describiendo el error, el valor por defecto de dónde es "cur", y para desplazamiento es 0. Por tanto, la llamada descriptor_de_fichero:seek() devuelve la posición actual, sin cambiarla, la llamada descriptor_de_fichero:seek("set") establece la posición al principio del fichero (y devuelve 0), y la llamada descriptor_de_fichero:seek("end") establece la posición al final del fichero y devuelve su tamaño.

io.tmpfile(), devuelve un descriptor de fichero para un fichero temporal, este se abre en modo actualización y se elimina automáticamente cuando acaba el programa.

io.type(objeto), verifica si objeto es un descriptor válido de fichero, devuelve el texto "file" si objeto es un descriptor de fichero abierto, "closed file" si objeto es un descriptor de fichero cerrado, o nil si objeto no es un descriptor de fichero.

file:setvbuf(modo [, tamaño]), establece un modo buffer para un fichero de salida, el argumento modo puede ser uno de estos tres.

 "no": sin buffer, el resultado de cualquier operación de salida se produce inmediatamente.
    "full": con buffer completo, la operación de salida se realiza sólo cuando el buffer está lleno o cuando se invoca explícitamente la función flush en el descriptor del fichero.
    "line": con buffer de línea, la salida se demora hasta que se produce una nueva línea en la salida o existe una entrada de algún fichero especial (como una terminal).

para los dos últimos casos, tamaño especifica el tamaño del buffer, en bytes, el valor por defecto es un tamaño adecuado.

• Biblioteca básica.
• Manejo de string.
• Manejo de tablas.
• Funciones matemáticas.
• Entrada y salida(I/O)
• Sistema operativo.
  • os.clock()
  • os.date()
  • os.difftime()
  • os.execute()
  • os.exit()
  • os.getenv()
  • os.remove()
  • os.rename()
  • os.setlocale()
  • os.time()
  • os.tmpname()

Esta biblioteca está implementada a través de la tabla os.

os.clock(), Devuelve una aproximación al total de segundos de CPU usados por el programa.

os.date([formato [, tiempo]]), devuelve un string o una tabla conteniendo la fecha y hora, formateada de acuerdo con el string dado en formato, si el argumento tiempo está presente entonces ese tiempo concreto es el que se formatea (véase la función os.time para una descripción de este valor), en caso contrario, date formatea el tiempo actual, si formato comienza con '!' entonces el tiempo se formatea de acuerdo al Tiempo Universal Coordinado, Después de este carácter opcional, si formato es *t entonces date devuelve una tabla con los siguientes campos: year (cuatro dígitos), month (1--12), day (1--31), hour (0--23), min (0--59), sec (0--61), wday (día de la semana, el domingo es 1), yday (día dentro del año), e isdst (booleano, verdadero si es horario de verano), Si formato no es *t entonces date devuelve el tiempo como un string, formateado de acuerdo con las mismas reglas que la función strftime de C, Cuando se invoca sin argumentos date devuelve una representación razonable de la fecha y la hora que depende de la máquina y del sistema local (esto es, os.date() equivale a os.date("%c")).

os.difftime(t2, t1), devuelve el número de segundos desde el instante t1 hasta el t2. En POSIX, Windows y algunos otros sistemas este valor es exactamente t2-t1.

os.execute([comando]), esta función equivale a la función system de C. Pasa la orden comando para que sea ejecutada en el intérprete de comandos del sistema operativo, devuelve un código de estatus, que es dependiente del sistema. Si el argumento comando está ausente devuelve un valor no cero si está disponible un intérprete de comandos y cero si no está disponible.

os.exit([código]), Invoca la función exit de C, con un código entero opcional, para terminar el programa anfitrión. El valor por defecto de código es el valor correspondiente a éxito.

os.getenv(variable), devuelve el valor asignado a la variable de entorno variable, o nil si la variable no está definida.

os.remove(nombre_de_fichero), Elimina el fichero o directorio dado. Los directorios deben estar vacíos para poder ser eliminados. Si la función falla retorna nil, más un string describiendo el error.

os.rename(nombre_viejo, nombre_nuevo), Renombra un fichero o directorio de nombre_viejo a nombre_nuevo. Si la función falla retorna nil, más un string describiendo el error.

os.setlocale(local [, categoría]), Establece valores en el sistema local del programa. local es un string que especifica un valor local; categoría es un string opcional que describe qué categoría cambiar: "all", "collate", "ctype", "monetary", "numeric", or "time"; la categoría por defecto es "all". Esta función retorna el nombre del nuevo local o nil si la petición no pudo ser aceptada. Si local es el string vacío, el local actual se establece como el local nativo (que depende de la implementación). Si local es el string "C", el local actual se establece en el local estándar de C. Cuando se invoca con nil como primer argumento, esta función retorna sólo el nombre del local actual en la categoría dada.

os.time([tabla]), Devuelve el tiempo actual cuando se llama sin argumentos, o un tiempo representando la fecha y hora especificadas en la tabla dada. Ésta debe tener los campos year, month y day, y puede tener los campos hour, min, sec e isdst (para una descripción de esos campos, véase la función os.date). El valor retornado es un número, cuyo significado depende del sistema. En POSIX, Windows y algunos otros sistemas este número cuenta el número de segundos desde alguna fecha inicial dada (la "época"). En otros sistemas el significado no está especificado, y el número retornado por time puede ser usado sólo como argumento de las funciones date y difftime.

os.tmpname(), Devuelve un string con un nombre de fichero que puede ser usado como fichero temporal. El fichero debe ser abierto explícitamente antes de su uso y también eliminado explícitamente cuando no se necesite más.