Anda di halaman 1dari 53

2008

Guía de Scripting en LUA


Programación en AutoPlay Media Studio
Lua es un lenguaje de programación extensible diseñado para una
programación procedimental general con utilidades para la descripción de
datos. También ofrece un buen soporte para la programación orientada a
objetos, programación funcional y programación orientada a datos. Se
pretende que Lua sea usado como un lenguaje de script potente y ligero para
cualquier programa que lo necesite. Lua está implementado como una
biblioteca escrita en C limpio (esto es, en el subconjunto común de ANSI C y
C++).

Henry Díaz Gutiérrez


2

CONTENIDO
AUTOPLAY MEDIA STUDIO 7.X.X ---------------------------------------------------------------------- 4

GUÍA DE SCRIPTING (CÓDIGO) ------------------------------------------------------------------------ 4

INTRODUCCIÓN ------------------------------------------------------------------------------------------------- 4

UN RÁPIDO EJEMPLO DE SCRIPT EN AUTOPLAY MEDIA STUDIO. ------------------------------ 4


IMPORTANTE CONCEPTOS DE SCRIPTING ------------------------------------------------------- 6

SCRIPT ES GLOBAL ----------------------------------------------------------------------- 6


EL SCRIPT ES SENSIBLE A MAYÚSCULAS Y MINÚSCULAS (CASE-SENSITIVE) ------------------- 6
COMENTARIOS --------------------------------------------------------------------------- 7
LA DELIMITACIÓN DE LAS DECLARACIONES ------------------------------------------------- 7
VARIABLES --------------------------------------------------------------------------------------------------------- 8

¿CUÁLES SON LAS VARIABLES?------------------------------------------------------------ 8


ÁMBITO DE APLICACIÓN VARIABLE --------------------------------------------------------- 9
Variables locales -------------------------------------------------------------------- 9
NOMBRES DE VARIABLES ----------------------------------------------------------------10
PALABRAS CLAVE (RESERVADAS) ---------------------------------------------------------11
TIPOS Y VALORES -----------------------------------------------------------------------11
Número (Number) -----------------------------------------------------------------12
Ninguna (Nil) ----------------------------------------------------------------------15
Boolean (Si o No) ------------------------------------------------------------------15
Función (Function) ----------------------------------------------------------------15
Arreglos (Table) -------------------------------------------------------------------16
Ejemplo 1: -------------------------------------------------------------------------------- 16
Ejemplo 2: -------------------------------------------------------------------------------- 16
ASIGNACIÓN A VARIABLE ----------------------------------------------------------------17
EXPRESIONES Y OPERADORES ----------------------------------------------------------------------- 18

OPERADORES ARITMÉTICOS --------------------------------------------------------------18


OPERADORES RELACIONALES-------------------------------------------------------------18
CONCATENACIÓN -----------------------------------------------------------------------20
PRECEDENCIAS DE LOS OPERADORES -----------------------------------------------------20
ESTRUCTURAS DE CONTROL --------------------------------------------------------------------------- 21

IF (SI) ---------------------------------------------------------------------------------21
WHILE (MIENTRAS) ---------------------------------------------------------------------22
REPEAT (REPITA) -----------------------------------------------------------------------23
FOR (PARA) ----------------------------------------------------------------------------23
TABLES (ARRAYS) | TABLAS (MATRICES) ----------------------------------------------------- 24

CÓMO CREAR TABLES --------------------------------------------------------------------24


ARRAYS NUMÉRICOS --------------------------------------------------------------------25
ARREGLOS ASOCIATIVOS ----------------------------------------------------------------26
USO DE FOR PARA ENUMERAR TABLAS ----------------------------------------------------27
COPIANDO TABLAS (ARRAYS) ------------------------------------------------------------28
FUNCIONES TABLE (TABLA) --------------------------------------------------------------30
3

FUNCIONES ------------------------------------------------------------------------------------------------------ 31

ARGUMENTOS DE UNA FUNCIÓN ----------------------------------------------------------32


VALORES DE RETORNO ------------------------------------------------------------------33
MÚLTIPLES VALORES DE RETORNO--------------------------------------------------------33
REDEFINICIÓN DE FUNCIONES ------------------------------------------------------------34
PONER FUNCIONES EN LAS TABLAS -------------------------------------------------------34
MANIPULACIÓN DE CADENAS ------------------------------------------------------------------------- 35

CONCATENAR CADENAS ------------------------------------------------------------------35


COMPARACIÓN DE CADENAS -------------------------------------------------------------36
CONTAR CARACTERES -------------------------------------------------------------------37
BUSCAR CADENAS-----------------------------------------------------------------------37
EXTRACCIÓN EN CADENAS ---------------------------------------------------------------38
CONVERSIÓN DE CADENAS NUMÉRICAS EN NÚMEROS ---------------------------------------39
OTRAS FUNCIONES PRE-CONSTRUIDAS INCORPORADAS ---------------------------- 41

SCRIPT DE FUNCIONES -----------------------------------------------------------------41


DOFILE ---------------------------------------------------------------------------------41
REQUIRE -------------------------------------------------------------------------------42
TYPE -----------------------------------------------------------------------------------42
ACCIONES ------------------------------------------------------------------------------43
LA DEPURACIÓN DE SUS SCRIPTS ----------------------------------------------------------------- 43

MANIPULACIÓN DE ERRORES -------------------------------------------------------------44


ERRORES DE SINTAXIS ------------------------------------------------------------------44
ERRORES FUNCIONALES -----------------------------------------------------------------45
LAS ACCIONES DE DEPURACIÓN ----------------------------------------------------------46
Application.GetLastError ----------------------------------------------------------46
Debug.ShowWindow --------------------------------------------------------------48
Debug.Print ------------------------------------------------------------------------48
Debug.SetTraceMode --------------------------------------------------------------49
Debug.GetEventContext ----------------------------------------------------------50
Dialog.Message --------------------------------------------------------------------51

CONSIDERACIONES FINALES-------------------------------------------------------------------------- 51

OTROS RECURSOS ----------------------------------------------------------------------51


ARCHIVOS DE AYUDA --------------------------------------------------------------------51
GUÍA DEL USUARIO----------------------------------------------------------------------51
SITIO WEB DE AUTOPLAY MEDIA STUDIO-------------------------------------------------52
INDIGO AUMENTÓ EL APOYO TÉCNICO -----------------------------------------------------52
EL SITIO WEB DE LUA -------------------------------------------------------------------52
4

AutoPlay Media Studio 7.X.X

Guía de Scripting (Código)


Introducción
Una de las potentes funciones de AutoPlay Media Studio es su motor de
scripting. Este documento le presentará el nuevo entorno del lenguaje de
programación.

El Scripting de AutoPlay es muy simple, con sólo un puñado de conceptos a


aprender. Esto es lo que parece:

a = 5;
if a <10 then
Dialog.Message ("¿Adivina qué?", "a es menor que 10");
end

(Nota: este script es sólo una demostración. No se preocupe si usted


no entiende todavía.)

El ejemplo anterior asigna un valor a una variable, verifica el contenido de


esa variable, y si el valor resulta ser inferior a 10, utiliza una acción de
AutoPlay llamada "Dialog.Message" para mostrar un mensaje para el
usuario.

Programadores nuevos y experimentados por igual se encuentran con que


AutoPlay Media Studio es un potente, flexible y simple medio para trabajar
Scripting.

Un rápido ejemplo de Script en AutoPlay Media Studio.


Aquí está un breve tutorial que muestra cómo introducir una secuencia de
comandos en AutoPlay Media Studio y vista previa de los resultados:

1. Inicie un nuevo proyecto.

2. Crear un nuevo objeto del tipo botón.

3. En la ventana de “Properties”(Propiedades), en la categoría


“Actions”(Acciones), diríjase al evento “On Clic”(Clic) del objeto botón y
selecciónelo. Al lado derecho se mostrara un pequeño botón de edición
junto a la palabra "-- None --"(Ninguno).

4. Haga clic en el botón Editar para abrir el Editor de Scripting. Tenga en


cuenta que se abre directamente en la ficha “On Clic”.
5

5. Escriba el texto siguiente:

Dialog.Message ("Título", "Hola Mundo en Lua");

Se debe tener este aspecto cuando haya terminado:

6. Haga clic en Aceptar para cerrar el Editor de secuencias de comandos


(Scripting).

7. Elija Publicar (Publish) > Vista previa (Preview) [F5] en la barra de


menú.

8. Una vez que se ejecuta la aplicación, haga clic en el botón que has
creado.

Esto hará que se ejecute el evento Clic del objeto botón, de modo que el
codigo (Script) que ha introducido se llevará a cabo. Deberías ver el
siguiente cuadro de diálogo al dar clic en el botón:
6

Felicidades! Usted acaba de hacer su primer script. Aunque se trata de un


simple ejemplo, que sólo le muestra lo fácil que es hacer que algo suceda
en su aplicación AutoPlay. Puede utilizar el método anterior para probar
cualquier script que desee en AutoPlay Media Studio.

Importante conceptos de Scripting


Hay algunas cosas importantes que usted debe saber acerca del lenguaje de
scripting en general de AutoPlay Media Studio antes de seguir adelante.

Script es Global
El motor de scripting es global para el entorno en tiempo de ejecución. Esto
significa que todos los eventos de su voluntad "saber" acerca de otras
variables y funciones declarados en el resto del producto. Por ejemplo, si
asigna "mivar = 10;" en el proyecto en el evento “On Startup”, “mivar”
será igual a 10, cuando el próximo evento es activado. Hay formas en torno
a esta naturaleza mundial, pero es generalmente cierto en el caso del motor
de scripting.

El Script es sensible a mayúsculas y minúsculas (Case-


sensitive)
El motor de scripting es sensible entre mayúsculas y minúsculas. Esto
significa que caracteres mayúsculas y minúsculas son importantes para
cosas como palabras clave, nombres de variables y nombres de las
funciones.

Por ejemplo:

ABC = 10;
aBC = 7;

En el script de arriba, ABC y aBC se refieren a dos diferentes variables, y


pueden tener diferentes valores. La minúscula "a" en "aBC" hace que sea
completamente diferente de "ABC" en la medida de que AutoPlay las invoca.

El mismo principio se aplica también a los nombres de las funciones. Por


ejemplo:

Dialog.Message ("Hola", "Hola mundo…");

... se refiere a una función construida para AutoPlay. Sin embargo,

DIALOG.Message ("Hola", "Hola mundo…");


7

... no será reconocido como una función construida, porque “DIALOG” y


“dialog” se consideran como dos nombres completamente diferentes.

Nota: Es totalmente posible tener dos funciones con la misma


ortografía, pero diferentes de capitalización - por ejemplo,
GreetUser y gREeTUSeR sería visto como dos funciones totalmente
diferentes. Aunque es definitivamente posible de esas funciones a
coexistir, generalmente es mejor dar nombres completamente
diferentes a funciones para evitar cualquier confusión.

Comentarios
Puede insertar comentarios no ejecutables en sus escrituras para explicar y
documentar el código. En un script, cualquier texto después de dos guiones
(--) en una línea será ignorado. Por ejemplo:

-- Asignar 10 a la variable abc


abc = 10;

... o:

abc = 10; -- Asignar 10 a abc

Los dos ejemplos anteriores hacen exactamente la misma cosa, los


comentarios no afectan a los script en modo alguno.

También puede crear multi-línea mediante el uso de comentarios -- [[ y ]] -


- a ambos lados del comentario:

-- [[Esto es
un comentario
multi-línea]] --
a = 10;

Usted debe usar los comentarios para explicar sus escrituras en la medida
de lo posible, a fin de que sean más fáciles de entender por usted mismo y
otros.

La delimitación de las declaraciones


Cada una única declaración puede ser en su propia línea y / o separados por
un punto y coma (;). Por ejemplo, todas de las siguientes secuencias de
comandos son válidas:

Script 1:

a = 10
Mivar = a

Script 2:

a = 10; mivar = a;
8

Script 3:

a = 10;
Mivar = a;

Sin embargo, le recomendamos que todas las declaraciones finalicen con un


punto y coma (como en los script 2 y 3).

Variables
¿Cuáles son las variables?
Las variables son muy importantes para los script en AutoPlay. Las variables
son, simplemente, "apodos" o "marcadores" de los valores que deben ser
modificados o reutilizados en el futuro. Por ejemplo, la siguiente secuencia
de comandos asigna el valor 10 a una variable llamada "cantidad".

cantidad = 10;

Nota: Nosotros decimos que los valores son "asignados a" o


"depositados en" variables. Si, una variable de la imagen de un
contenedor donde se puede almacenar un valor, asignando un valor
a una variable es como "depositamos" el valor en un contenedor.
Puede cambiar este valor en cualquier momento, al asignar un valor
diferente a la variable, el nuevo valor simplemente reemplaza al
antiguo. Esta capacidad de mantener la información cambiante es lo
que hace que las variables sean tan útiles.

Aquí hay un par de ejemplos que demuestran cómo se puede operar sobre
la variable "cantidad":

cantidad = 10;
cantidad = cantidad + 20;
Dialog.Message ("Valor", cantidad);

Esta expresión asigna 10 a la variable llamada cantidad, y luego añade 20


al valor que mantiene, y entonces finalmente muestra un mensaje donde el
valor actual de dicha variable será 30.

También puede asignar una variable a otro:

a = 10;
b = a;
Dialog.Message ("Valor", b);

Esto hará que aparezca un cuadro de mensaje con el número 10 en el


mismo. La línea "b = a;" asigna el valor de "a" (que es 10) a "b."
9

Ámbito de aplicación variable


Como se mencionó anteriormente en este documento, todas las variables
en AutoPlay Media Studio son globales por defecto. Esto significa que
existen en todo el proyecto, y mantienen sus valores para próximos script.
En otras palabras, si un valor es asignado a una variable en un script, la
variable todavía tiene su valor cuando el siguiente script es ejecutado.

Por ejemplo, si introduce este script:

foo = 10;

... en la página actual en el evento “On Open”, y a continuación escriba:

Dialog.Message ("El valor es:", foo);

... en un objeto botón en el evento “On Clic”, el segundo script utilizará el


valor que se asignó a "foo" en el primer script. Como resultado de ello,
cuando se hace clic en el objeto botón, un cuadro de mensaje aparecerá con
el número 10 en el mismo.

Tenga en cuenta que el orden de ejecución es importante... para que un


script pueda utilizar el valor que se asigna a la variable en otro script, este
otro script que tiene que ser ejecutado primero. En el ejemplo anterior, en
el evento de la pagina “On Open” es disparado antes del evento “On Click”
del botón, por lo que el valor 10 ya está asignado a “foo” cuando se ejecuta
el evento “On Click” en el script.

Variables locales
Por naturaleza global del motor de script, significa que una variable
conservará su valor en todo el proyecto. Sin embargo, puede hacer que las
variables no sean globales, utilizando las palabras clave "local." Poner la
palabra "local" en frente de una asignación a variable crea una variable
que es local a la actual función o script.

Por ejemplo, digamos que usted tiene los siguientes tres script en el mismo
proyecto:

Script 1:

-- Asignamos el valor 10 a x
x = 10;

Script 2:

local x = 500;
Dialog.Message ("El valor local de x es:", x);
x = 250; -- esto cambia a local a x, no es Global
Dialog.Message ("El valor local de x es:", x);

Script 3:
10

-- Mostrar el valor global de x


Dialog.Message ("El valor global de x es:", x);

Supongamos que estos tres script se realizan una tras otro. El primer script
da el valor 10 a x. Dado que todas las variables son globales por defecto, x
tendrá este valor dentro de todos los demás script también. El segundo
script hace una sesión local de x, dándole el valor de 500, pero sólo dentro
de ese script. Si cualquier otra cosa dentro de ese script quiere tener acceso
al valor de x, se vera el valor local en lugar del valor global. Esto sucede
porque la variable "x" ha sido sustituida temporalmente por otra variable
que se ve igual, pero tiene un valor diferente.

(Esto me recuerda a las películas Caper, donde en el banco, los ladrones


poner una foto delante de la cámaras de seguridad por lo que el guardia no
ver que la bóveda está vacía. Sólo en este caso, es como el banco robado,
crear una nueva bóveda de trabajo, al igual que el original, y a
continuación, la desmantelan cuando se van.)

Cuando le pide mostrar el contenido de x, la primera acción Dialog.Message


dentro del script # 2 mostrará 500, ya que es el valor local de x cuando la
acción se lleva a cabo. La siguiente línea asigna el valor local de 250 a x,
note que una vez que usted haga una variable local, esta reemplaza
completamente la variable global para el resto del script.

Por último, el tercer script muestra el valor global de x, que sigue siendo
10.

Nombres de Variables
Los nombres de variables pueden estar compuestos de cualquier
combinación de letras, dígitos y guión bajo (underscores), siempre que no
comiencen con un número y no entren en conflicto con palabras clave
(reservadas).

Ejemplos válidos de nombres de variables:

un
strNombre
_Mi_Variable
dato1
dato_1_23
Índice
bReset
nContar

Ejemplos no válidos de nombres de variables:

1
1dato
%% MiValor
$ strDato
11

para
local
_PrimNombre + Apellidos_
Nombre de usuario

Palabras clave (Reservadas)


Las siguientes palabras son reservadas y no se puede utilizar para nombrar
variables, constantes o las funciones:

and break do else elseif


end false for function if
in local nil not or
repeat return table then true
until while

Tipos y Valores
El lenguaje de scripting de AutoPlay es dinámicamente tipado. No hay
ningún tipo de definiciones - en lugar de ello, cada valor tiene su propio
tipo.

Lo que esto significa es que usted no tiene que declarar una variable a ser
de un determinado tipo antes de usarlo. Por ejemplo, en C++, si desea
utilizar un número, usted tiene que declarar primero el tipo de la variable y,
a continuación, asignar un valor a la misma:

int j;
j = 10;

El ejemplo de C++ declara a “j” como un entero, y a continuación, asigna


10 a la misma.

Como hemos visto, en AutoPlay sólo se puede asignar un valor a una


variable sin declarar su tipo. En realidad las variables no tienen tipos de
cambio, es dentro de los valores que se consideran los tipos, entre un tipo u
otro. Por ejemplo:

j = 10;

... esto crea automáticamente la variable llamada "j" y asigna el valor 10 a


la misma. Aunque este valor tiene un tipo (es un número), la variable es
todavía typeless. Esto significa que usted puede dar vuelta alrededor y
asignar un tipo diferente de valor a “j”, de este modo:

j = "Hola";

Esto sustituye al número 10 que se almacena en j con la cadena "Hola." El


hecho de que una cadena es un tipo diferente de dato no importa, la
variable j no le importa qué tipo de dato tiene, sólo le importa lo que puso
en él.

Hay seis tipos de datos básicos en AutoPlay: number, string, nil,


12

boolean, function y table. En las secciones siguientes se explicará cada


tipo de dato con más detalle.

Número (Number)
Un número es exactamente eso: un valor numérico. El número representa
el tipo de números reales, concretamente, valores de doble precisión de
punto flotante. No hay distinción entre enteros y números de punto flotante
(también conocidos como "fracciones ")... todos ellos son sólo" números”.
He aquí algunos ejemplos de números válidos:

4 4. .4 0.4 4.57e-3 0.3e12

Cadena de Caracteres (String)


Una cadena es simplemente una secuencia de caracteres. Por ejemplo,
"Joe2" es una cadena de cuatro caracteres, comenzando con la letra "J" y
termina con el número "2." Una cadena puede variar ampliamente en
longitud, una cadena puede contener una sola letra, ni una sola palabra, o
el contenido de un libro en su totalidad.

Las cadenas pueden contener espacios y aún más caracteres especiales,


tales como retornos de carro y saltos de línea. De hecho, las cadenas
pueden contener cualquier combinación válida de 8 bits de caracteres
ASCII, incluyendo los caracteres nulos ("\0"). AutoPlay gestiona
automáticamente string de memoria, de forma que nunca tenga que
preocuparse de la asignación o de la asignación de memoria para las
cadenas.

Las cadenas pueden ser bastante utilizadas intuitivas y naturales. Estas


deben ser delimitadas por comillas simples coincidentes o comillas dobles.
Aquí hay algunos ejemplos que utilizan las cadenas de caracteres:

Nombre = "Henry Díaz";


Dialog.Message ("Título", "Hola, ¿cómo estás?");
Apellido = ‘Díaz’;

Normalmente se utilizan comillas dobles para las cadenas, pero puede ser
útil usar comillas simples („), si usted tiene una cadena que contiene
comillas dobles dentro de dicho string. Cualquiera que sea el tipo de cita
que utilice, puede incluir el otro tipo de comillas dentro de la cadena, sin
escapar de ella. Por ejemplo:

comillasDobles = "¿Qué hay de nuevo?";


comillasSimples = 'Ella dijo "Hable con la mano", y yo era todo
como "Dude!"';

Si utiliza comillas dobles para delimitar el string y dentro de este también


las usara, el string debe quedar de la siguiente manera para que el motor
de script no finalice el string en la segunda comilla doble. Se vería así:

escapado = "Ella dijo \" Hable con la mano, \"y yo estaba con
todos los \" ¡Amigos! \"";
13

Normalmente, el motor de script ve comillas dobles como el marcador de


inicio o final de una cadena de caracteres. Con el fin de incluir comillas
dobles dentro de una cadena de caracteres encerrados en comillas dobles, y
que necesita para escapar de ellos con una barra invertida (\). Esto le dice
al motor de script que desee incluir una cita de carácter real en la cadena
de caracteres.

La barra invertida y la comilla doble (\") son conocidas como una secuencia
de escape. Una secuencia de escape es una secuencia especial de
caracteres que se convierten o "traducen" en otra cosa por el motor de
script. Las secuencias de escape le permiten incluir cosas que no pueden ser
escritas directamente en una cadena.

Las secuencias de escape que puede utilizarse en AutoPlay son:

\a - campana
\b - de retroceso
\f - salto de pagina
\n - nueva línea
\r - retorno de carro
\t - tabulación horizontal
\v - tabulación vertical
\\ - barra invertida
\" - comillas
\' - apóstrofe
\[ - corchete izquierdo
\] - corchete derecho

Así, por ejemplo, si desea mostrar tres líneas de texto en una única cadena,
haga lo siguiente:

Lineas = "Línea uno. \nLinea dos. \nLinea tres";


Dialog.Message ("Aquí se muestra un String", Lineas);

Este asigna una cadena a una variable denominada Líneas, y utiliza la


nueva secuencia de escape para iniciar una nueva línea después de cada
frase. La función Dialog.Message muestra el contenido de la variable Lineas
en un cuadro de mensaje, como este:

Otro ejemplo común es cuando se quiere representar una ruta de acceso a


un archivo, tales como C: \Mi Documentos\Mis Datos.txt. Sólo tiene que
recordar hacer una secuencia de escape de las barras, como en el siguiente
ejemplo:
MyPath = "C:\\Mis Documentos\\Mis Datos.txt";
14

Cada doble barra representa una única barra cuando se utiliza dentro de
una cadena.

Si conoce la tabla ASCII, puede utilizar una barra invertida seguida de un


número de hasta tres dígitos para representar el valor de cualquier carácter
ASCII. Por ejemplo, el valor ASCII de un carácter de nueva línea es de 10
(el valor de “a” minúscula en la tabla ASCII), por lo que las dos líneas
siguientes hacer exactamente lo mismo:

Lineas = "Línea uno. \nLinea dos. \nLinea tres";


Lineas = "Línea uno. \10Linea dos. \10Linea tres";

Sin embargo, usted no tendrá que utilizar este formato muy a menudo, o
nunca.

También se puede definir cadenas en varias líneas con/entre doble


corchetes ([[y]]). Una cadena entre doble corchetes no necesita ningún
carácter de escape. El estar entre doble corchetes le permite a la cadena
usar todo tipo de caracteres especiales como barras, saltos de línea y
comillas simples y dobles en la cadena de caracteres. Por ejemplo:

Lineas = [[Línea uno.


Línea dos.
Línea tres.]];

…es equivalente a:

Lineas = "Línea uno. \nLinea dos. \nLinea tres";

Esto puede ser útil si usted tiene pre-texto que desea utilizar como una
cadena, y no desea tener que convertir todos los caracteres especiales en
secuencias de escape.

La última cosa importante a saber acerca de las cadenas es que el motor de


scripting proporciona conversión automática entre números y cadenas de
caracteres en tiempo de ejecución. Cuando una operación numérica se
aplica a una cadena de caracteres, el motor intenta convertir la cadena a un
número para la operación. Por supuesto, esto sólo tendrá éxito si la cadena
contiene algo que puede interpretarse como un número.

Por ejemplo, las siguientes líneas son válidas:

a = "10" + 1; -- es de 11 Resultados
b = "33" * 2; -- es de 66 Resultados

Sin embargo, las siguientes líneas no le dan el mismo resultado de la


conversión:

a = "10 +1"; -- El resultado es la cadena "10 +1"


b = "hola" + 1; -- Error, no se puede transformar "hola" a un
número
15

Ninguna (Nil)
Ninguna es un tipo dato de valor ausente. Básicamente representa la
ausencia de cualquier otro tipo de valor.

Puede asignar cero a una variable, al igual que cualquier otro valor. Tenga
en cuenta que esto no es lo mismo que la asignación de las letras "cero" a
una variable, como en una cadena. Al igual que otras palabras clave, Nil
debe ser escrita al lado derecho de la variable con el fin de ser reconocidos
como un tipo de valor. También debe ser escrita en letras minúsculas.

Nil siempre se evalúa como falsas cuando se utiliza en una condición:

a = nil;
if a then
-- Ingrese acá todas las líneas
-- Esta expresión no se ejecutará
end

También puede ser utilizado para "eliminar" el valor de una variable:

y = "Henry Diaz";
y = nil;

En el ejemplo anterior, "y" ya no contienen un valor después de la segunda


línea.

Boolean (Si o No)


Las variables de tipo Boolean puede tomar uno de dos valores: cierto o
falso, si o no, true o false. Se pueden utilizar en condiciones y llevar a
cabo operaciones de lógica booleana. Por ejemplo:

boolybooly = true;
if boolybooly then
-- Cualquier script de aquí será ejecutado.
end

Esto establece una variable llamada boolybooly en verdadera, y a


continuación, ejecuta una declaración en base al valor devuelto. Del mismo
modo:

a = true;
b = false;
if (A y B) then
-- Cualquier script de aquí no se ejecutará porque
-- verdadero y falso es falso.
end

Esta vez, si la declaración de necesidades, tanto "a" y "b" para ser verdad
para las líneas dentro de él a ser ejecutado. En este caso, que no va a
ocurrir porque "b" se ha establecido en falso.

Función (Function)
16

El motor de scripts le permite definir sus propias funciones (o "sub-


rutinas"), que son esencialmente pequeños pedazos de script que puede ser
ejecutado en la demanda. Cada función tiene un nombre que se utiliza para
identificar la función. Usted puede utilizar el nombre de la función como un
valor de tipo especial, con el fin de almacenar una "referencia" para esa
función en una variable, o pasar a otra función. Este tipo de referencia es el
valor del tipo function (función).

Arreglos (Table)
Las tablas o arreglos son una forma muy poderosa para almacenar listas de
valores indexados bajo un nombre. Las tablas son en realidad arrays
asociativos, es decir, que son arreglos que pueden ser indexados, no sólo
con números, sino con cualquier tipo de valor (incluyendo cadenas).

He aquí algunos ejemplos rápidos.

Ejemplo 1:
nombres = {"Henry", "Evert", "Paguada"};
Dialog.Message ("Segundo nombre en la lista", nombres[2]);

Esto mostrará un cuadro de mensaje con la palabra "Everth" en el.

Ejemplo 2:
t = {};
t.Nombre = "Henry";
t.Apellido = "Díaz";
t.Ocupacion = "Programador";
Dialog.Message(t.Nombre, t.Ocupacion);

Esto mostrará el mensaje siguiente cuadro:

Se pueden asignar tablas con otras variables como así. Por ejemplo:

arreglo_uno = {};
arreglo_uno.Nombre = "Henry";
arreglo_uno.Apellido = "Díaz";
arreglo_uno.Ocupacion = "Programador";
arreglo_dos = arreglo_uno;
ocupacion = arreglo_dos.Ocupacion;
Dialog.Message(b.Nombre, ocupacion);

Los arreglos se pueden indexar utilizando notación matriz (mi_arreglo [1]),


17

o por la notación punto en vez de indexados por números


(mi_arreglo.Apellido).

Tenga en cuenta que al asignar un arreglo a otro, como en la línea


siguiente:

arreglo_dos = arreglo_uno;

... esto en realidad no copia arreglo_dos en arreglo_uno. En lugar de ello,


arreglo_dos y arreglo_uno ambos se refieren al mismo arreglo.

Esto se debe a que el nombre de un arreglo en realidad se refiere a una


dirección en la memoria donde los datos dentro del arreglo se almacenan.
Así que cuando le puede asignar el contenido de la variable arreglo_uno a la
variable arreglo_dos, estás copiando la dirección, y no los datos reales.
Usted está vinculando esencialmente las dos variables al mismo "punto"
donde se encuentran los datos del arreglo.

Con el fin de copiar el contenido de un arreglo, lo que necesitas para crear


un nuevo arreglo y, a continuación, copia todos los datos sobre un tema en
un momento.

Asignación a variable
Las variables pueden tener los nuevos valores asignados a ellos mediante el
operador de asignación (=). Esto incluye copiar el valor de una variable en
otra. Por ejemplo:

a = 10;
b = "Soy feliz";
c = b;

Es interesante observar que el motor de scripts soporta múltiples tareas de


asignación:

a, b = 1, 2;

Después del script, la variable "a" contiene el número 1 y la variable "b"


contiene el número 2.

Los arreglos y las funciones son parte de un caso especial: cuando se utiliza
el operador de asignación sobre una arreglo o función, se crea un alias que
apunta al mismo arreglo o función, es cuando la variable comienza a
"copiarse". Muchos programadores llaman a este modo “Por Referencia”
que es distinto al otro método de copiado llamado “Por Valor”.
18

Expresiones y operadores
Una expresión es todo lo que se evalúa como un valor. Esto puede incluir un
único valor, como "6" o un valor complejo construido con los operadores
tales como "1 + 3". Puede utilizar paréntesis para "agrupar" las expresiones
y control del orden en el que se evalúan las expresiones con sus
operadores. Por ejemplo, las siguientes líneas al ser evaluadas, todas
devuelven el mismo valor:

a = 10;
a = (5 * 1) * 2;
a = 100 / 10;
a = 100 / (2 * 5);

Operadores aritméticos
Operadores aritméticos se utilizan para realizar operaciones matemáticas
sobre los números. Los siguientes son los operadores matemáticos
soportados:

+ (Adición)
- (Resta)
* (Multiplicación)
/ (División)
unario - (negación)

He aquí algunos ejemplos:

a = 5 + 2;
b = a * 100;
veintitresPorciento = 23 / 100;
nega = -29;
posi = -nega;

Operadores relacionales
Operadores relacionales le permiten comparar cómo se relaciona un valor a
otro. Los siguientes operadores relacionales son compatibles:

> (Mayor que)


< (Menor que)
<= (Menor que o igual a)
>= (Mayor o igual a)
~= (Desigual)
== (Igualdad)

Todos los operadores relacionales pueden aplicarse a cualquiera de estos


dos tipos de valores, números o cadenas. Todos los demás valores sólo
puede usar el operador == para ver si son iguales.

Los operadores relacionales retornan valores booleanos, (verdadero o


falso). Por ejemplo:

10 > 20; -- se devuelve falso


19

a = 10;
a > 300; -- falso

(3 * 200) > 500; -- verdadero


"Brett" ~= "Lorne" –- verdadero

Un punto importante a mencionar es que los operadores == y ~= al


completar la prueba de igualdad, son case-sensitive, lo que significa que en
cualquier cadena, al hacer comparaciones con los operadores, distinguen
entre mayúsculas y minúsculas. Por ejemplo:

"Jojoba" == "Jojoba"; -- verdadero


"Salvajes" == "salvajes" -- falso
"Me gusta mucho" == "me gusta MUCHO" -- falso

"feliz" ~= "FeLIz"; -- verdadero

Operadores lógicos
Operadores lógicos se utilizan para realizar operaciones booleanas sobre los
valores booleanos. Los siguientes operadores lógicos son compatibles:

and (devuelve verdadero si ambos valores son verdaderos)


or (devuelve verdadero si 1 de los 2 son verdaderos)
not (devuelve el contrario del valor)

Por ejemplo:

a = true;
b = false;
c = A and B; - falso
d = cero and nil; - falso
e = not b; - verdadero

Tenga en cuenta que sólo los valores nulos y falsos se consideran falsas, y
todos los demás valores son verdaderos.

Por ejemplo:

soyinvisible = nil;
if soyinvisible then
-- Las líneas de aquí no va a ocurrir
-- Porque soyinvisible se considera falsa
Dialog.Message ("Usted no puede verme!", "Yo soy invisible
!!!!");
end

if "Brett" then
-- Las líneas de aquí se ejecutaran, porque Brett no es
negativa, ni falsa
-- Se consideran falsas ... cualquier otra cosa,
incluyendo cadenas,
-- se consideran verdaderas.
Dialog.Message ("¿Qué pasa con las cadenas?", "Las cadenas
20

son verdaderas.");
end
Concatenación
En los script de AutoPlay, el operador de concatenación es de dos períodos
(..). Se utiliza para combinar (unir) dos o más cadenas de caracteres. Usted
no tiene que poner espacios antes y después de los períodos, pero se puede
si lo desea.

Por ejemplo:

name = "Henry".."Diaz"; --asigna "Henry Diaz" a la variable name


b = name .." es número" .. 1; --asigna "Henry Diaz es el número
1" a b

Precedencias de los operadores


Se dice que los operadores tendrán preferencia (precedencia), que es una
manera de describir las normas o reglas que determinan que operación en
una expresión se realiza en primer lugar. Un simple ejemplo sería la
expresión 1 + 2 * 3. La operador (*) multiplicación tiene mayor precedencia
que el operador (+) suma, por lo que esta expresión es equivalente a 1 +
(2 * 3). En otras palabras, la expresión 2 * 3 se realiza en primer lugar, y
entonces 1 + 6 se lleva a cabo, por lo que el valor final es 7.

Puede invalidar el orden natural de precedencia mediante el uso de


paréntesis. Por ejemplo, la expresión (1 + 2) * 3 devuelve 9. El paréntesis
crea del conjunto una sub-expresión "1 + 2" la izquierda el valor del
operador (*) multiplicar. Esencialmente, la sub-expresión 1 + 2 se evalúa
en primer lugar, y el resultado es entonces utilizado en la expresión 3 * 3.

Precedencias de los operadores sigue el siguiente orden, de menor a mayor


prioridad:

and or
< > <= >= ~= ==
..
+ --
* /
not - (unario)
^

Los operadores también tienen asociatividad, que es una manera de


describir las expresiones que se realizan en primer lugar cuando los
operadores tengan igualdad de precedencia. En el motor de scripting, todos
los operadores binarios son asociativos a izquierda, lo que significa que
cada vez que dos operadores tienen la misma prioridad, la operación de la
izquierda se lleva a cabo en primer lugar. La excepción es el operador de
exponenciación (^), que es asociativo derecho.

En caso de duda, siempre puedes utilizar paréntesis explícitos de control de


precedencia. Por ejemplo:

a + 1 < b/2 + 1
21

... es el mismo:

(a + 1) < ((b/2) + 1)

... y puede utilizar paréntesis para cambiar el orden de los cálculos,


también:

a + 1 < b/(2 + 1)

En este último ejemplo, en lugar del 1 que se añade a la mitad de B, B se


divide por 3.

Estructuras de control
El motor de scripts soporta las siguientes estructuras de control: if, while,
repeat y for

If (Si)
Una declaración if evalúa su condición y a continuación, sólo ejecuta parte
del código después de “then” si la condición es verdadera. Una declaración
“if” es terminada por la palabra clave “end”. La sintaxis básica es la
siguiente:

if condición then
hacer algo aquí
end

Por ejemplo:

x = 50;
if x > 10 then
Dialog.Message ("resultado", "x es mayor que 10");
end

y = 3;
if ((35 * y) < 100) then
Dialog.Message ( "", "y es 35 veces inferior a 100");
end

En el script de arriba, sólo el primer mensaje de diálogo que aparezca,


porque si la segunda condición no es verdadero... 35 veces 3 es 105, y 105
no es inferior a 100.

También puede utilizar else y elseif para añadir más posibles retornos a la
declaración if:

x = 5;
if x > 10 then
Dialog.Message ("", "x es mayor que 10");
else
Dialog.Message ("", "x es igual o inferior a 10");
end
22

En el ejemplo anterior, el segundo mensaje es el que se muestra, ya que 5


no es superior a 10.

x = 5;
if x == 10 then
Dialog.Message ( "", "x es exactamente igual a 10");
elseif x == 11 then
Dialog.Message ( "", "x es exactamente igual a 11");
elseif x == 12 then
Dialog.Message ( "", "x es exactamente igual a12");
else
Dialog.Message ( "", "x no es igual a 10, 11 o 12");
end

En este ejemplo, el último mensaje de diálogo se muestra, ya que x no es


igual a 10, o 11, o 12.

While (Mientras)
La declaración While se utiliza para ejecutar el mismo "bloque" del script
una y otra vez hasta que se cumple una condición. Al igual que la
declaración “if”, la declaración “while” se finaliza con la palabra clave “end”.
La sintaxis básica es la siguiente:

while condición do
hacer algo aquí
end

El resultado de la declaración while debe ser verdadero para que se


ejecuten las acciones que se encuentran en el interior (el "hacer algo aquí"
en la parte superior) para ser realizadas. La declaración while seguirá el
bucle siempre cuando esta condición es verdadera. Así es como funciona:

Si la condición es verdadera, todas las acciones entre el "mientras" y el


correspondiente "fin" se llevarán a cabo. Cuando el "fin" se alcanza, la
condición será reevaluado y, si es cierto, las acciones entre el "mientras" y
el "fin" se llevarán a cabo de nuevo. Las acciones seguirán como este bucle
hasta que la condición se evalúa como falsa.

Por ejemplo:

a = 1;
while a < 10 do
a = a + 1;
end

En el ejemplo anterior, el "a = a + 1;" la línea se llevará a cabo a 9 veces.

Usted puede salir de un bucle while en cualquier momento utilizando la


palabra clave "break". Por ejemplo:

contador = 1;
while contador < 100 do
contador = contador + 1;
23

if contador == 50 then
break;
end
end

Aunque la declaración while que está dispuesta a contar del 1 al 99, la


declaración if causa que este bucle termine tan pronto como llegue a contar
con 50.

Repeat (Repita)
La declaración Repeat es similar a la declaración while, salvo que la
condición se comprueba al final de la estructura en lugar de al principio. La
sintaxis básica es la siguiente:

repeat
hacer algo aquí
until condición

Por ejemplo:

i = 1;
repeat
i = i + 1;
until i > 10

Esto es similar a uno de los anteriores bucles while, pero esta vez, el bucle
se realiza 10 veces. La expresión "i = i + 1; es ejecutado antes de que la
condición determina que 1 es ahora mayor que 10.

Usted puede salir de un bucle de repetición en cualquier momento utilizando


la palabra clave "break". Por ejemplo:

contador = 1;
repeat
contador = contador + 1;
if contador == 50 then
break;
end
until contador > 100

Una vez más, lo que provoca la salida del bucle es tan pronto como es
evaluado que contador es igual a 50.

For (Para)
La declaración For es usado para repetir un bloque de script de un número
específico de veces. La sintaxis básica es la siguiente:

for variable = inicio, fin, steep do


hacer algo aquí
end
24

La variable usada en la declaracion For puede llevar cualquier nombre, o el


que desee. Se utiliza una variable, en este caso “contador” para "contar" el
número de vueltas que debe procesar el bucle for. Se inicia en el parámetro
que va después del signo igual, con el valor que usted especifique y a
continuación, los cambios en el importe en el paso después de cada viaje a
través del bucle. En otras palabras, el paso se añade al valor en la variable
después de las líneas entre el final y se llevan a cabo. Si el resultado es
menor que o igual al valor final, el bucle sigue desde el principio.

Por ejemplo:

- Este bucle cuenta de 1 hasta 10:


for x = 1, 10 do
Dialog.Message ("Número", x);
end

El ejemplo anterior muestra 10 mensajes de diálogo en una fila, contando


del 1 al 10.
Tenga en cuenta que el paso es opcional, si no se declara un valor para el
paso, por defecto el valor sera1.

He aquí un ejemplo que utiliza el paso de un "-1" para hacer el bucle para
contar hacia atrás:

- Este bucle cuenta a partir del 10 hasta 1:


for x = 10, 1, -1 do
Dialog.Message ("Número", x);
end

Ese ejemplo se muestra 10 mensajes de diálogo en una fila, contando a


partir del 10 de vuelta y va todo el camino a 1.

Usted puede salir de un bucle para en cualquier momento utilizando la


palabras clave "break". Por ejemplo:

for i = 1, 100 do
if contar == 50 then
break;
end
end

Una vez más, lo que la salida del bucle tan pronto como fue igual a 50.

También hay una variación en el bucle para que funcione en los cuadros.

Tables (Arrays) | Tablas (Matrices)


Las tablas o matrices son muy útiles. Se pueden utilizar para almacenar
cualquier tipo de valor, incluidas las funciones o incluso otras tablas.

Cómo crear tables


En general, existen dos formas de crear una tabla a partir de cero. El
primero utiliza llaves para especificar una lista de valores:
25

mi_tabla = {"manzana", "naranja", "melocotón"};

asociar_tabla = {fruta ="manzana", vegetal ="zanahoria"}

La segunda forma es crear un cuadro en blanco y, a continuación, agregar


los valores uno a la vez:

mi_tabla = {};
mi_tabla [1] = "manzana";
mi_tabla [2] = "naranja";
mi_tabla [3] = "melocotón";

asociar_tabla = {};
asociar_tabla.fruta = "manzana";
asociar_tabla.vegetal = "zanahoria";

Accediendo a los elementos de la Tabla.


Cada "registro" de la información almacenada en una tabla es conocido
como un elemento. Cada elemento consta de una clave, que sirve de índice
en la tabla, y un valor que está asociado con esa clave.

En general, existen dos formas de acceder a un elemento: puede usar la


notación matriz, o punto de notación. La Notación de Matriz se suele utilizar
con arrays numéricos, que son simplemente el que todos los cuadros de las
claves son los números. La Notación de Punto se suele utilizar con arrays
asociativos, que son los cuadros donde las llaves son cadenas.

Aquí está un ejemplo de Notación de Matriz:

t = {"uno", "dos", "tres"};


Dialog.Message ("El elemento uno contiene:", t[1]);

Aquí está un ejemplo de Notación de Punto:

t = {primero ="uno", segundo ="dos", tercero ="tres"};


Dialog.Message ("Elemento ‘primero’ contiene:", t.primero);

Arrays numéricos
Uno de los usos más comunes de las tablas es como Matrices. Una Matriz es
una colección de valores que están indexados por llaves numéricas. En el
motor de scripting, las matrices numéricas son basadas en uno. Es decir,
que comienzan en el índice 1.

He aquí algunos ejemplos numéricos utilizando matrices:

Ejemplo 1:

miMatriz ={255,0,255};
Dialog.Message ("Primer Número", miMatriz[1]);

Esto mostrará un mensaje de diálogo que contiene el número "255."


26

Ejemplo 2:

alfabeto = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
"k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w",
"x","y","z"};
Dialog.Message ("Séptima Carta", alfabeto[7]);

Esto mostrará un mensaje de diálogo que contiene la letra "g"

Ejemplo 3:

miMatriz = {};
miMatriz [1] = "Opción Uno";
miMatriz [2] = "Opción Dos";
miMatriz [3] = "Opción Tres";

Este es exactamente el mismo que el texto siguiente:

miMatriz = {"Opción Uno", "Opción Dos", "Opción Tres"};

Arreglos asociativos
Arreglos asociativos son los mismos que los arreglos numéricos, salvo que
los índices pueden ser números, cadenas o incluso funciones.

Aquí está un ejemplo de una matriz asociativa que utiliza un apellido como
un índice y un nombre como el valor:

matNombres = {Diaz =”Henry”,


Sanabria ="Everth",
Lemus ="Edwin",
Paguada ="Henry",
Hitchcock = "Alfred"};
Dialog.Message ("Díaz, Nombre", matNombres.Diaz);

El mensaje de diálogo resultante se vería así:

Aquí está un ejemplo de un simple empleado de la base de datos que


realiza un seguimiento del empleado nombres y fechas de nacimiento
indexados por número de empleados:

Empleados = {}; --Construir una tabla vacía para el número de


empleados

-- Almacenando la información del empleado en su propio tabla.


27

Empleado1 = {Nombre ="Henry Díaz", Cumpleanos ="21/08/82"};


Empleado2 = {Nombre ="Everth Sanabria", Cumpleanos ="28/05/85"};

-- Almacenando información de cada empleado de la tabla


-- En el número apropiado de la tabla Empleados
Empleados[100099] = Empleado1;
Empleados[137637] = Empleado2;

-- Ahora a escribir "Empleado [100099]" es lo mismo que escribir


"Employee1"
Dialog.Message ( "Cumpleaños", Empleados[100099].Cumpleanos);

El mensaje de diálogo resultante se vería así:

Uso de For para enumerar tablas


Hay una versión especial de la declaración de que le permite rápida y
fácilmente enumerar el contenido de una matriz. La sintaxis es la siguiente:

for indice,valor in tabla do


--operar en el índice y el valor
end

Por ejemplo:

miTabla = {"Uno", "Dos", "Tres"};

-- Mostrar un mensaje para cada elemento del array


for j,k in miTabla do
Dialog.Message ("Item del Arreglo", j .. "=" .. k);
end

El resultado sería de tres mensajes de diálogo en fila, una para cada uno de
los elementos en el arreglo miTabla, así:
28

Recuerde hacer la declaración encima, porque es una manera rápida y fácil


de inspeccionar los valores en una tabla. Si sólo quieres los índices de una
tabla, puede dejar de lado la parte del valor de la declaración:

a = {Uno=1,Dos=2,Tres=3};

for k in a do
Dialog.Message("Índice de la Tabla", k);
final

El script de arriba mostrará tres mensajes del array en una fila, con el texto
"Uno", "Tres", y a continuación, "Dos".

Espera, pues, por qué no son elementos de la tabla en orden? La razón de


esto es que internamente el motor de scripting no almacena tablas como
matrices, pero en una super-eficiente estructura conocida como una tabla
hash. (No te preocupes, me confunde sobre tablas hash demasiado.) Lo
importante a saber es que cuando se define los elementos de la tabla, que
no necesariamente son almacenados en el orden que usted defina o agrege,
a menos que usted use una matriz numérica (es decir, una tabla indexada
con los números del 1 al cualquiera que sea).

Copiando Tablas (Arrays)


Copiar Tabla es un poco diferente de la copia de otros tipos de valores. A
diferencia de las variables, no puedes utilizar el operador de asignación para
copiar el contenido de un cuadro a otro. Esto se debe a que el nombre de
una tabla en realidad se refiere a una dirección en la memoria donde los
datos dentro de la tabla se almacenan. Si intenta copiar una tabla a otra
utilizando el operador de asignación, te acaba copiando la dirección, y no
los datos reales.

Por ejemplo, si usted quería copiar una tabla y a continuación, modificar la


copia, puede ser que usted intente algo como esto:
29

tabla_uno = {estado="Happy", temperatura="Caliente"};

-- Crear una copia


tabla_dos = tabla_uno;

-- Modificar la copia
tabla_dos.temperatura = "fría";

Dialog.Message("Tabla 1, temperatura es:",


tabla_uno.temperatura);
Dialog.Message("Tabla 2, temperatura es:",
tabla_dos.temperatura);

Si ejecutó este script, usted vera los dos siguientes diálogos:

Espera un minuto... cambiar la "temperatura" del elemento en tabla_dos


cambiado también en tabla_uno. ¿Por qué cambio tanto?

La respuesta es simplemente porque los dos son, en realidad, la misma


tabla.

Internamente, el nombre de una tabla sólo hace referencia a una ubicación


de memoria. Cuando se crea tabla_uno, una porción de memoria se reserva
para almacenar su contenido. La ubicación (o "dirección"), de esta memoria
es lo que se asigna a la variable denominada tabla_uno.

La asignación de tabla_uno a tabla_dos esta solo copia la dirección de


memoria - no la propia memoria.

Es como escribir la dirección de una biblioteca en un pedazo de papel y, a


continuación, entregar ese documento a su amigo. Usted no ha de entregar
toda la biblioteca, más estantes de libros y de todos... sólo el lugar donde
se encuentra.

Si realmente quería copiar la biblioteca, usted tendría que crear un nuevo


30

edificio, fotocopia individualmente cada uno de los libros y, a continuación,


guardar las fotocopias en la nueva ubicación.

Eso es más o menos cómo es con tablas, también. Con el fin de crear una
copia completa de una tabla, todos los contenidos y, lo que necesitas para
crear una nueva tabla y luego copiar todos los elementos, un elemento a la
vez.

Afortunadamente, para la declaración hace muy fácil de hacer. Por ejemplo,


aquí una versión modificada de nuestro ejemplo anterior, que crea una
"verdadera" copia de tabla_uno.

tabla_uno = {estado="Feliz", temperatura="Caliente"};

-- Crear una copia


tabla_dos = {};
for indice, valor in tabla_uno do
tabla_dos[indice] =valor;
end

-- Modificar la copia
tabla_dos.temperatura = "Fría";

Dialog.Message ( "Tabla 1, temperatura es:",


tabla_uno.temperatura);
Dialog.Message ( "Tabla 2, temperatura es:",
tabla_dos.temperatura);

Esta vez, los diálogos muestran que la modificación de tabla_dos no afecta


a todos los tabla_uno:

Funciones Table (Tabla)


Hay una serie de funciones Table (Tabla) incorporadas a su disposición, que
puede utilizar para hacer cosas tales como la inserción de elementos en una
tabla, la eliminación de elementos de una tabla, y contando el número de
elementos en una tabla. Para obtener más información sobre estas
31

funciones de tabla, por favor, véase el Programa de Referencia / Acciones /


Tabla en la ayuda en línea.

Funciones
Una de las principales y más poderosas de las características del motor de
scripting son las funciones. Usted ya ha visto una gran cantidad de
funciones utilizadas a lo largo de este documento, tales como
"Dialog.Message." Las Funciones son simplemente trozos de código en el
script que puede definir, darle un nombre y a continuación, llamar desde
cualquier otro lugar.

A pesar de que hay un montón de funciones incorpordas en AutoPlay,


también puede hacer sus propias funciones personalizadas que se adapte a
sus necesidades específicas. En general, las funciones se definen de la
siguiente manera:

function nombre_de_funcion (argumentos)


codigo de la funcion aquí
return valor_retorno;
end

La primera parte es la palabra clave "function". Esto le dice al motor de


scripting que lo que sigue es la definición de una función. El
nombre_de_funcion es simplemente un nombre único para su función. Los
argumentos son los parámetros (o valores) que se pasan a la función cada
vez que se llama. Una función puede recibir cualquier número de
argumentos de 0 a infinito (bueno, no infinito, pero no se técnicamente
cuantos). La palabra clave “return” le dice a la función que debe de volver
uno o más valores al trozo de código (script) que lo llamó.

La forma más sencilla de aprender acerca de las funciones es trabajar en


algunos ejemplos. En este primer ejemplo, vamos a hacer una simple
función que muestra un cuadro de mensaje. No tiene ningún argumento y
no devuelve nada.

function HolaMundo ()
Dialog.Message ( "Bienvenido", "Hola Mundo");
end

Observe que si usted escribe en un evento la función y ejecuta la vista


previa de su aplicación, no pasa nada. Bueno, eso es cierto y no es cierto.
Es cierto que nada de lo que ocurre visible, pero la magia está en lo que no
se ve. Cuando el evento se disparó y el script de la función se ejecuta, la
función llamada "HolaMundo" se convierte en parte del motor de scripting.
Esto significa que está ahora disponible para el resto de la aplicación y
atender la solicitud en cualquier otro script.

Esto trae a colación un punto importante acerca de secuencias de comandos


en AutoPlay Media Studio. Al realizar una función, la función no se
"interpreta" en el motor hasta que el script se ejecuta. Esto significa que si
32

defines HolaMundo() en el evento On Click de un boton, pero este evento


nunca es invocado (porque el usuario no haga clic en el botón), la función
HolaMundo() nunca existira. Es decir, no se le puede llamar desde cualquier
otro lugar.

Es por ello que, en general, es mejor definir sus funciones globales en el


script global del proyecto. (Para acceder al script, seleccione Proyecto>
Global Functions en el menú.)

Ahora, de regreso a las buenas cosas. Vamos a añadir una línea a la


realidad, llamar a la función:

function HolaMundo()
Dialog.Message ( "Bienvenido", "Hola Mundo");
final

HolaMundo();

La linea "HolaMundo();" le dice al motor de scrpting "ir a realizar la función


llamada HolaMundo." Cuando esa línea es ejecutada, debe ver un mensaje
de bienvenida con el texto "Hola Mundo" en ella.

Argumentos de una Función


Vamos a aprovechar esto un poco más y decirle al cuadro de mensaje, que
el texto para mostrar sera mediante la adición de un argumento a la
función.

function HolaMundo(Mensaje)
Dialog.Message ("Bienvenido", Mensaje);
end

HolaMundo("Este es un argumento");

Ahora el cuadro de mensaje muestra el texto que fue "pasado" a la función.

En la definición de la función, "Mensaje" es una variable que recibirá


automáticamente cualquier argumento pasado a la función. En la llamada a
la función, pasamos la cadena "Este es un argumento" como el primer (y
único) argumento para la función de HolaMundo.

Aquí está un ejemplo de la utilización de múltiples argumentos.

function HolaMundo(Titulo, Mensaje)


Dialog.Message(Titulo, Mensaje);
end

HolaMundo("Este es argumento uno", "Este es argumento dos");


HolaMundo("Bienvenido", "Hola");

Esta vez, la definición de la función utiliza dos variables, una para cada uno
33

de sus dos argumentos... y cada llamada a la función, pasa dos cadenas a


la función HolaMundo.

Tenga en cuenta que cambiando el contenido de esas cadenas, puede


enviar diferentes argumentos a la función, y lograr resultados diferentes.

Valores de Retorno
El siguiente paso es hacer la función de valores de retorno de vuelta al ser
llamada por el script. Aquí esta una función que acepta un número como su
único argumento y a continuación, devuelve una cadena que contenga
todos los números de uno a ese número.

function Contador(n)

-- Se empezará a cabo con una cadena de retorno en blanco


CadenaRetorno = "";

for num = 1,n do


-- Agregar el número actual (NUM) a la final de la cadena
de retorno
CadenaRetorno = CadenaRetorno..num;

-- Si este no es el último número, a continuación, agregue


una coma y un espacio para separar los números un poco en la
cadena de retorno
if (num ~= n) then
CadenaRetorno = CadenaRetorno..", ";
end
end

-- Devolver la cadena que hemos construido


return CadenaRetorno;
end

CadenaContador = Contador(10);
Dialog.Message ( "Contador", CadenaContador);

Las dos últimas líneas del script de arriba utilizan la función Contador para
construir una cadena a partir de 1 a 10, lo almacena en una variable
llamada CadenaContador y a continuación, muestra el contenido de esa
variable en un diálogo cuadro de mensaje.

Múltiples valores de Retorno


Puede devolver múltiples valores en funciones, como por ejemplo:

function NumerosCortos(Numero1, Numero2)


if Numero1 <= Numero2 then
return Numero1, Numero2
else
return Numero2, Numero1
34

end
end

PriNum, SegNum = NumerosCortos(102, 100);


Dialog.Message("Clasificación", PriNum ..", ".. SegNum);

El script de arriba crea una función llamada NumerosCortos que toma dos
argumentos y devuelve dos valores. El primer valor devuelto es el número
más pequeño, y el segundo valor devuelto es el más grande. Tenga en
cuenta que se especifican dos variables para recibir los valores de retorno
de la función llamada en la segunda última línea. La última línea del script
muestra los dos números en el orden en que fueron ordenados por la
función.

Redefinición de funciones
Otra cosa interesante acerca de las funciones es que se puede anular una
definición de función anterior simplemente por volver a definirla.

function HolaMundo()
Dialog.Message("Mensaje", "Hola Mundo");
end

function HolaMundo()
Dialog.Message("Mensaje", "Hola Tierra");
end

HolaMundo();

El script de arriba muestra un cuadro de mensaje que dice "Hola Tierra," y


no "Hola Mundo". Esto se debe a que la segunda versión de la HolaMundo()
función anula la primera.

Poner funciones en las Tablas


Una cosa muy poderosa acerca de las tablas es que pueden ser utilizados
para celebrar funciones, así como otros valores. Esto es importante porque
le permite asegurarse de que su única funciones y nombres son lógicamente
agrupados. (Así es como todas las funciones de AutoPlay Media Studio son
implementadas.) Aquí está un ejemplo:

-- Realizar las funciones:


function HolaTierra()
Dialog.Message ("Mensaje", "Hola Tierra");
end

function HolaLuna()
Dialog.Message ("Mensaje", "Hola Luna");
end

-- Definir una tabla vacía:


Hola = {};
35

-- Asignar las funciones a la tabla:


Hola.Tierra = HolaTierra;
Hola.Luna = HolaLuna;

-- Tiene la palabra las funciones:


Hola.Tierra ();
Hola.Luna ();

También es interesante notar que puede definir funciones de derechas en su


definición de tabla:

Hola = {
Tierra = function() Dialog.Message("Mensaje", "Hola Tierra")
end,
Luna = function() Dialog.Message("Mensaje", "Hola Luna") end
};

-- Ahora llamamos las funciones:


Hello.Earth ();
Hello.Moon ();

Manipulación de cadenas
En esta sección vamos a cubrir brevemente algunas de las más comunes
técnicas de manipulación de cadenas, como la concatenación de cadenas y
comparaciones.

(Para obtener más información sobre las funciones de cadena que tiene a su
disposición en AutoPlay Media Studio, véase el Programa de Referencia /
Acciones / cadena en la ayuda en línea.)

Concatenar cadenas
Ya hemos cubierto la concatenación de cadenas, pero esta así vale la pena
repetir. El operador de concatenación de cadenas es de dos períodos en una
fila (..). Por ejemplo:

NombreCompleto = "Díaz".." Henry";


-- NombreCompleto es ahora "Díaz Henry"

-- También puede concatenar números en cadenas.


DiasDelAño = 365;
CadenaAño = "Hay "..DiasDelAño.." días en un año".

Tenga en cuenta que usted puede poner espacios a ambos lados de los
puntos, o por un lado, o no poner ningún espacio en absoluto. Por ejemplo,
las siguientes cuatro líneas logran la misma cosa:

foo = "Hola " .. usuario;


foo = "Hola ".. usuario;
36

foo = "Hola " ..usuario;


foo = "Hola "..usuario;

Comparación de Cadenas
Junto a la concatenación, una de las cosas más comunes que se quiere
hacer con las cadenas es comparar una cadena a otra. Dependiendo de lo
que constituye un "match", esta puede ser muy simple, o simplemente un
poco difícil.

Si desea realizar una distinción entre mayúsculas y minúsculas


comparación, entonces todo lo que tienes que hacer es utilizar el operador
igual (==). Por ejemplo:

strUno = "Guatemala";
strDos = "Guatemala";

if strUno == strDos then


Dialog.Message("¿Adivina qué?", "Las dos cadenas son
iguales!");
else
Dialog.Message("Hmmm", "Las dos cadenas son diferentes.");
end

Dado que el operador == realiza una distinción entre mayúsculas y


minúsculas comparación cuando se aplica a cadenas de texto, el script de
arriba mostrará un cuadro de mensaje que proclama que las dos cadenas
son iguales.

Si desea realizar una comparación entre mayúsculas y minúsculas, entonces


usted necesita tomar ventaja de cualquiera de las funciones String.Upper o
String.Lower, a fin de asegurar que ambas cadenas tienen el mismo caso
antes de compararlos. La función String.Upper devuelve todo en
mayúsculas de la cadena que se da, y la función String.Lower devuelve toda
la cadena en minúsculas. Tenga en cuenta que no importa la función que
utiliza en su comparación, siempre y cuando se utiliza la misma función en
ambos lados del operador == en su declaración if.

Por ejemplo:

strUno = "GUatEmaLa";
strDos = "Guatemala";

if String.Upper(strUno) == String.Upper(strDos) then


Dialog.Message("¿Adivina qué?", "Las dos cadenas son
iguales!");
else
Dialog.Message("Hmmm", "Las dos cadenas son diferentes.");
end

En el ejemplo anterior, la función String.Upper convierte strUno a


"GUATEMALA" y strDos a "GUATEMALA" y a continuación, la declaración if
37

compara los resultados. (Nota: las dos cadenas originales siguen siendo lo
mismo.) De esta forma, no importa lo que en las cadenas originales tenían;
todo lo que importa es si las letras son las mismas.

Contar caracteres
Si alguna vez ha querido saber cuán larga es una cadena, se puede contar
el número de caracteres que contiene. Basta con utilizar la función
String.Length, así:

trabalenguas = "Si un plato de madera, podría plato de madera,


¿cuánto sería...um...";
num_caracteres = String.Length (trabalenguas);
Dialog.Message ( "Cuanto mide el Trabalengua", núm_caracteres ..
" caracteres!");

... que se produce el siguiente cuadro de diálogo mensaje:

Buscar cadenas
Otra cosa que usted quiere hacer con las cadenas es buscar una cadena
dentro de otra. Esto es muy simple al hacer uso de la función String.Find.

Por ejemplo:

strBuscarEn = "¿No es un día maravilloso fuera?";


strBuscarPara = "maravillo";

-- Búsqueda de strBuscarEn dentro strBuscarPara


nEncuentraPos = String.Find (strBuscarEn, strBuscarPara);

if nEncuentraPos ~= nil then


-- Encontré!
Dialog.Message("Resultados de la búsqueda","\""..
strBuscarPara .."\""..
" se encuentra en la posición " ..
nEncuentraPos);
else
-- Mala suerte
Dialog.Message("Resultados de la búsqueda", strBuscarPara
.. " no se ha encontrado!");
end

... podría causar el siguiente mensaje que se mostrará:


38

Consejo: Trate de experimentar con diferentes valores para strBuscarPara


y strBuscarEn.

Reemplazar en Cadenas
Una de las cosas más poderosas que usted puede hacer con las cadenas es
llevar a cabo una operación para búsqueda y reemplazo sobre ellas. El
siguiente ejemplo muestra cómo puede utilizar la acción String.Replace para
sustituir a cada ocurrencia de una cadena con otro objetivo dentro de una
cadena.

strContiene = "Lua el mejor. Dentro de los lenguajes script!";


strBuscarPara = "mejor";
strReemplazarCon = "Profesional";
strNuevaCadena = String.Replace(strContiene, strBuscarPara,
strReemplazarCon);
Dialog.Message("Después de buscar y reemplazar",
strNuevaCadena);

-- Crear una copia de la cadena sin espacios en esta.


strNoEspacios = String.Replace(strContiene, " ", "");
Dialog.Message("Después de remover los espacios:",
strNoEspacios);

El ejemplo anterior se muestra la siguiente dos mensajes:

Extracción en Cadenas
Hay tres funciones de cadena que le permiten "extraer" una parte de una
cadena, en lugar de copiar toda la cadena de sí mismo. Estas funciones son
String.Left, String.Right, y String.Mid.
39

String.Left copias un número de caracteres desde el comienzo de la cadena.


String.Right hace lo mismo, pero contando desde el extremo derecho del
lugar de la cadena. String.Mid le permite copiar un número de caracteres a
partir de cualquier posición en la cadena.

Puede utilizar estas funciones para llevar a cabo todo tipo de operaciones
avanzadas en cadenas.

He aquí un ejemplo básico que muestra cómo funcionan:

strOriginal = "Es realmente bueno verte de nuevo"

-- Copia las primeras 13 caracteres en strIzquierda.


strIzquierda = String.Left (strOriginal, 13);

-- Copia los últimos 18 caracteres en strDerecha.


strDerecha = String.Right (strOriginal, 20);

-- Crear una nueva cadena con los dos pedazos.


strClon = strIzquierda .. "re" .. strDerecha .. "te.";

-- Copia la palabra "bueno" en strCualquiera.


strCualquiera = String.Mid(strOriginal, 14, 6);

--Mostramos los resultados en un cuadro de mensaje.


Dialog.Message("Extraer en Cadenas", strOriginal .. "\n" ..
strIzquierda .. "\n" .. strDerecha .. "\n" .. strClon .. "\n" ..
strCualquiera);

El ejemplo anterior muestra el siguiente cuadro de mensaje:

Conversión de cadenas numéricas en números


Puede haber ocasiones en las que tienen una cadena numérica, y que usted
necesita para convertir a un número.

Por ejemplo, si usted tiene un campo de entrada donde el usuario puede


entrar en su edad, y leer el texto que escribió, puede obtener un valor como
"31". Debido a que en el escrito, sin embargo, este valor es en realidad una
cadena compuesta de los caracteres "3" y "1".
40

Si se trató de comparar este valor con un número, usted obtendría un error


de sintaxis que sí se trató de comparar un número con una cadena.

Por ejemplo, el siguiente script:

edad = "31";
if edad > 18 then
Dialog.Message("", "Eres mayor de 18 años.");
end

... se produce el siguiente mensaje de error:

El problema en este caso es la línea que compara el contenido de la variable


"edad" con el número 18:

if edad > 18 then

Esto genera un error porque la edad contiene una cadena, y no un número.


El motor de script no le permite comparar los números con las cadenas de
esta manera. No tiene manera de saber si quería tratar de edad como un
número o el tratamiento de 18 años como una cadena.

La solución es simplemente convertir el valor de la variable “edad” a un


número antes de comparar. Hay dos maneras de hacer esto. Una forma es
utilizar la función String.ToNumber.

La función String.ToNumber traduce una cadena numérica en el número


equivalente, por lo que se puede utilizar en una comparación numérica.

edad = "31";
if String.ToNumber(edad) > 18 then
Dialog.Message("", "Eres mayores de 18 años.");
end

La otra forma de aprovecha el motor de scripting en la capacidad para


convertir números en cadenas cuando se sabe lo que son sus intenciones.
Por ejemplo, si usted realiza una operación aritmética (por ejemplo, la
adición de dos números), el motor convierte automáticamente cualquier
cadena numérica en números para usted:

edad = "26" + 5; --El resultado es un valor numérico

El ejemplo anterior no generar ningún error, porque el motor de scripting


entiende que la única forma en que la declaración tiene sentido, si se
41

pretende utilizar la cadena numérica, es como un número. Como resultado


de ello, el motor convierte automáticamente la cadena numérica a un
número para que pueda realizar el cálculo.

Sabiendo esto, podemos convertir una cadena numérica a un número sin


cambiar su valor, simplemente por la adición de 0 a él, de este modo:

edad = "31";
if (edad + 0) > 18 then
Dialog.Message("", "Eres mayor de 18 años.");
end

En el ejemplo anterior, al agregar cero a la variable, le pide al motor para


convertir el valor a un número, y a continuación el resultado es comparado
con 18. No más error.

Otras Funciones Pre-Construidas incorporadas


Script de Funciones
Hay otras tres funciones incorporadas que puedan resultar de utilidad:
dofile, require, y type.

dofile
Carga y ejecuta un archivo de script. El contenido del archivo será
ejecutado como si fuera escrito directamente en el area de scripting. La
sintaxis es la siguiente:

dofile(direxion_archivo);

Por ejemplo, escriba el siguiente script en un archivo llamado miScript.lua


(sólo un archivo de texto que contiene este script, creado con el Bloc de
notas u otro editor de texto):

Dialog.Message("Hola", "Mundo");

Ahora arrastrar y soltar el archivo en la carpeta principal de AutoPlay Media


Studio. (Esto copia el archivo en la carpeta del proyecto llamada “Scripts”.)
Aparecerá un diálogo que le preguntará si queremos añadir nuestro script.
Haga clic en "No" por ahora. Vamos a explicar los requisitos declaración
más tarde.

Ahora, añada dondequiera la siguiente línea de script, pero en un evento:

dofile (_SourceFolder.."\\AutoPlay\\Scripts\\MiScript.lua");

... este archivo de script será leído y ejecutado de inmediato. En este caso,
usted vería un cuadro de mensaje con el titulo "Hola” y el mensaje
“Mundo".
42

Sugerencia: Utilice la función dofile para salvarse de tener que volver a


escribir o volver a pegar un script en sus proyectos una y otra vez.

require
Carga y ejecuta un archivo de script en el motor de scripting. Es similar a
dofile la salvedad de que sólo se carga un archivo de una vez por período de
sesiones, mientras que dofile volverá a la carga y volver a ejecutar el
archivo cada vez que se utiliza. La sintaxis es la siguiente:

require(direxion_archivo);

Así, por ejemplo, incluso si requiere hacer dos en una fila:

require("foo.lua");
require("foo.lua"); -- esta línea no hace nada

...sólo el primero de ellos se ejecuta. Después de eso, el motor de scripting


sabe que el archivo ha sido cargado y luego ejecutado, y las futuras
convocatorias para exigir el archivo, no tendrá ningún efecto.

Tenga en cuenta que el archivo .lua debe estar en la carpeta Scripts de su


proyecto, que ni siquiera tiene que proporcionar una ruta completa al
archivo. Por ejemplo:

require("MiScript.lua");

...es el mismo:

require(_SourceFolder.."\\AutoPlay\\Scripts\\MiScript.lua");

Dado que sólo requieren una determinada carga de archivo de script una
vez por período de sesiones, que es el más adecuado para la carga de
scripts que contienen sólo las variables y funciones. Dado que las variables
y funciones son globales por defecto, sólo tendrá que "cargar" una vez, en
repetidas ocasiones la carga de la misma definición de función termina en
una pérdida de tiempo.

Esto hace que la función requiera una buena forma de cargar script de
bibliotecas externas. Cada script que necesita una función de un archivo
externo puede exigir condiciones de seguridad con require(), y el archivo en
realidad sólo se carga la primera vez que se necesita.

type
Esta función le dirá el tipo de valor que figura en una variable. Esta
devuelve una cadena con el nombre del tipo de variable. Los valores validos
de retorno son "nil", "number", "string", "boolean", "table" o "function". Por
ejemplo:
43

a = 989;
strTipo = type(a); --establece strType a "número"

a = "Hola";
strTipo = type(a); -- establece strType a la "cadena"

El tipo de función es especialmente útil al escribir sus propias funciones que


necesitan determinados tipos de datos para operar. Por ejemplo, el
siguiente script usa la función type() para asegurarse de que sus dos
argumentos son números:

-- Encontrar el máximo de dos números


function Max(Num1, Num2)

-- Asegúrese de que ambos argumentos son numéricos


if (type(Num1) ~= "número") or (type(Num2) ~= "número") then
Dialog.Message("Error", "Por favor, introduzca un número");
return nil –- Indica que estamos usando valores nulos.
else
if Num1 >= Num2 then
return Num1;
else
return Num2;
end
end
end

Acciones
AutoPlay Media Studio viene con un gran número de funciones
incorporadas. En la interfaz del programa, estas funciones incorporadas son
comúnmente denominadas acciones. Para efectos de scripting, acciones y
funciones son esencialmente los mismos, sin embargo, el término
"acciones" es generalmente reservado para las funciones que se construyen
en el programa y se incluyen en la lista por orden alfabético de las acciones
en la ayuda en línea. Al referirse a las funciones que han sido creados por
otros usuarios o usted mismo, el término "funciones" se prefiere.

La depuración de sus Scripts


Scripting (o cualquier tipo de programación) es relativamente fácil una vez
que te acostumbras a ella. Sin embargo, incluso los mejores programadores
pueden cometer errores, y necesita proteger de errores ocasionales a su
código. Ser bueno en la depuración de scripts reducirá el tiempo de salida al
mercado para sus proyectos y aumentar la cantidad de sueño que podemos
encontrar en la noche. Por favor, lea esta sección de consejos sobre el uso
inteligentemente y eficazmente de AutoPlay Media Studio como sea posible!

En esta sección se explicará los métodos de manipulación de errores de


AutoPlay Media Studio, así como cubrir una serie de técnicas de depuración.
44

Manipulación de Errores
Todas las acciones incorpordas de AutoPlay Media Studio utilizan las mismas
técnicas de manipulación de errores. Sin embargo, esto no es
necesariamente cierto en el caso de cualquier función, módulo, o scripts,
incluso scripts desarrollados por Indigo Rose Corporation que no están
construidas en el producto. Aunque estos scripts desarrollados
externamente pueden hacer uso de AutoPlay y manipular errores del
sistema, puede que no necesariamente deba hacerlo. Por lo tanto, usted
siempre debe consultar a un scripts o autor de modulo o la documentación
con el fin de averiguar cómo es el manejo de errores, y así manipulados.

Existen dos tipos de errores que puede tener en sus escrituras cuando se
llama a las acciones de AutoPlay Media Studio: errores de sintaxis, los
errores y funcional.

Errores de sintaxis
Los errores de sintaxis se producen cuando la sintaxis (o "gramática") de un
script es incorrecta, o una función recibe argumentos que no son
apropiadas. Algunos errores de sintaxis son capturados por AutoPlay Media
Studio cuando usted compile o de vista previa de su aplicación.

Por ejemplo, considere el siguiente script:

foo =

Esto es incorrecto porque no hemos asignado nada a la variable foo -el


script esta incompleto. Esto es bastante obvio un error de sintaxis, y sería
capturado por el motor de script en tiempo de ejecución (cuando compile y
ejecute el proyecto).

Otro tipo de error de sintaxis es cuando no se pase el tipo o el número de


argumentos a una función. Por ejemplo, si usted intenta ejecutar este
script:

Dialog.Message("Hola");

...el proyecto mientras se compila será multado, debido a que no hay


evidentes errores de sintaxis en el script. En lo que respecta al motor de
scripting puede decir, la llamada a la función está bien formada. El nombre
es válido, abierto y cerrado partido entre paréntesis, las comillas están en
los lugares correctos, y hay incluso poner fin a una punto y coma al final.
Parece bueno!

Sin embargo, en tiempo de ejecución es que se vea algo como lo siguiente:


45

Parece que no era tan bueno después de todo. Tenga en cuenta que el
mensaje dice que dos argumentos son necesarios para la función
Dialog.Message. Ah. Nuestro script sólo tiene un argumento.

De acuerdo a la función prototipo de Dialog.Message, parece que la función


puede aceptar hasta cinco argumentos:

Mirando de cerca la función prototipo, vemos que los tres últimos


argumentos tienen valores por defecto que se utilizará si los argumentos se
omiten en la llamada a la función. Los dos primeros argumentos el título
(Title) y el texto (Text) -no tienen valores por defecto, por lo que no puede
ser omitido sin generar un error. Para hacer un largo cuento, algo corto,
está bien llamar a la acción Dialog.Message con cualquier del 2do. al 5to.
argumentos... pero 1 argumento no es suficiente.

Afortunadamente, errores de sintaxis como estas son suelen ser capturados


en el tiempo de ejecución o de prueba de su aplicación. Los mensajes de
error suelen ser muy claro, por lo que es fácil para usted para localizar e
identificar el problema.

Errores funcionales
Los errores funcionales son aquellos que se producen debido a la
funcionalidad si la acción propia falla. Ellos se producen cuando a una acción
se da información incorrecta, como la ruta de acceso a un archivo que no
existe. Por ejemplo, el siguiente código producirá un error funcional:

filecontents = TextFile.ReadToString("this_file_don't
exist.txt");

Si pone este script en un evento ahora mismo y lo prueba, verá que nada
parece suceder. Esto se debe a que en AutoPlay Media Studio los errores
funcionales no se muestran automáticamente como se muestran los errores
de sintaxis. Dejamos a ustedes para manejar (o a no manejar), tales
errores funcionales.

La razón de esto es que puede haber momentos en que no le importa si una


función falla. De hecho, puede que se espera. Por ejemplo, el siguiente
código intenta eliminar una carpeta llamada C:\Mi carpeta Temp:

Folder.Delete("C:\\Mi carpeta Temp");

Sin embargo, en este caso no le importa si realmente se elimina, o si la


carpeta no existe en primer lugar. Usted sólo quiere asegurarse de que si
esa carpeta existe, será eliminado. Si la carpeta no existe, la acción
Folder.Delete causa un error funcional, porque no puede encontrar la
46

carpeta que le dijo que eliminara... pero ya que el resultado final es


exactamente lo que quería, no es necesario a hacer nada al respecto. Y
desde luego no queremos que el usuario vea los mensajes de error.

Por el contrario, puede haber ocasiones en las que es muy importante para
usted saber si una acción falla. Si, por ejemplo, usted desea copiar un
archivo muy importante:

File.Copy("C:\\Temp\\Mi Archivo.dat","C:\\Temp\\Mi
Archivo.bak");

En este caso, usted realmente quiere saber si falla y pueden querer incluso
salir del programa o informar al usuario. Aquí es donde las acciones de
depuración entran en escena.

Las acciones de depuración


AutoPlay Media Studio viene con algunas funciones muy útiles para depurar
sus aplicaciones. En esta sección se verá una serie de ellas.

Application.GetLastError
Esta es la acción más importante a utilizar cuando se trata de averiguar si
un problema se ha producido. En tiempo de ejecución siempre hay un valor
interno que almacena el estado de la última acción que fue ejecutada. En el
inicio de una acción, este valor se establece en 0 (el número cero). Esto
significa que todo está bien. Si un error se produce funcional dentro de la
acción, el valor se cambia a algunos no cero.

A este último valor de error se puede acceder en cualquier momento


utilizando la acción Application.GetLastError.

La sintaxis es la siguiente:

ultimo_codigo_error=Application.GetLastError();

Aquí un ejemplo que utiliza esta acción:

File.Copy("C:\\Temp\\Mi Archivo.dat", "C:\\Temp\\Mi


Archivo.bak");

codigo_error = Application.GetLastError ();


if (codigo_error ~= 0) then
-- Algún tipo de error ha ocurrido!
Dialog.Message("Error", "Error al copiar
archivo:"..codigo_error);
Application.Exit ();
end

El script de arriba informará al usuario que se ha producido un error y luego


saldrá de la aplicación. Esto no es necesariamente la manera en que todos
47

los errores deben ser manejados, pero ilustra el punto. Usted puede hacer
lo que quieras cuando se produce un error, al igual que se pide una función
diferente o cualquier cosa que usted puede soñar.

El script de arriba tiene un posible problema. Imagine al usuario ver un


mensaje como este:

Sería mucho mejor que en realidad se ofrezca información al usuario sobre


el problema exacto. Bueno, usted está de suerte! En tiempo de ejecución
existe una tabla llamada _tblErrorMessages que contiene todos los posibles
mensajes de error, indexado por los códigos de error. Usted puede utilizar
fácilmente el último número de error para obtener un mensaje de error que
dará más sentido para el usuario, gracias al número de error como "1182".

Por ejemplo, aquí hay un script modificado para mostrar la cadena de error:

File.Copy("C:\\Temp\\Mi Archivo.dat", "C:\\Temp\\Mi


Archivo.bak");

codigo_error = Application.GetLastError();
if (codigo_error ~= 0) then
-- Algún tipo de error ha ocurrido!
Dialog.Message("Error", "Error al copiar archivo:\n" ..
_tblErrorMessages[codigo_error]);
Application.Exit ();
end

Ahora la ejecución produce el siguiente mensaje de error:

Mucha y mejor información!

Sólo recuerde que el valor del último error se restablece cada vez que una
acción es ejecutada. Por ejemplo, la siguiente secuencia de comandos no
produce un mensaje de error:

File.Copy("C:\\Temp\\Mi Archivo.dat",
48

"C:\\Temp\\Mi Archivo.bak");

-- En este punto Application.GetLastError() podría ser no cero,


pero...

Dialog.Message("Hola", "Hola Mundo");

-- Vaya, ahora el último número de error se toma de la acción


-- Dialog.Message, y no de la acción File.Copy. La acción
-- Dialog.Message restablecer el último número de error a 0,
-- y las siguientes líneas de captura no cualquier
-- Error que ocurrió en la acción File.Copy.

codigo_error = Application.GetLastError();

if (codigo_error ~= 0) then
-- Algún tipo de error ha ocurrido!
Dialog.Message("Error",
"Error al copiar archivo:"..
_tblErrorMessages [codigo_error]);
Application.Exit ();
end

Debug.ShowWindow
AutoPlay Media Studio en tiempo de ejecución tiene la capacidad de mostrar
una ventana de depuración que se pueden utilizar para mostrar mensajes
de depuración. Esta ventana existe en toda la ejecución de su solicitud,
pero sólo es visible cuando usted le dice que sea.

La sintaxis es la siguiente:

Debug.ShowWindow(show_window);

...donde show_window es un valor booleano. Si es verdadero, la ventana de


depuración se muestra, si es falsa, la ventana se oculta. Por ejemplo:

-- Mostrar la ventana de depuración


Debug.ShowWindow(true);

Si llama a este script, la ventana de depuración aparecerá en la parte


superior de su aplicación, pero nada más llega realmente a suceder. Ahí es
donde las siguientes acciones de depuración entran en escena.

Debug.Print
Esta acción imprime el texto de su elección en la ventana de depuración.
Por ejemplo, pruebe el siguiente script:

Debug.ShowWindow(true);

for i = 1, 10 do
49

Debug.Print("i = " .. i .. "\r\n");


end

El "\r\n" es en realidad dos secuencias de escape que se utilizan para iniciar


una nueva línea. (Esto es técnicamente llamado "retorno de carro/nueva
línea" par.) Usted puede usar \r\n en la ventana de depuración cada vez
que desee insertar una nueva línea.

El script de arriba producirá la siguiente salida en la ventana de depuración:

Puede utilizar este método para imprimir todo tipo de información en la


ventana de depuración. Algunos usos son típicos para imprimir el contenido
de una variable para que puedas ver lo que contiene en tiempo de
ejecución, o para imprimir sus propios mensajes de depuración como
"dentro de exterior para bucle" o "iniciar la función foo()." Estos mensajes
forman un sendero como migas de pan que se puede rastrear con el fin de
entender lo que está sucediendo detrás de las escenas en su proyecto.
Pueden ser muy valiosos cuando se trata de depurar sus scripts o su más
reciente prueba de algoritmo.

Debug.SetTraceMode
AutoPlay Media Studio puede ejecutar un modo especial de "rastrear" en
tiempo de ejecución que se imprimirá la información sobre cada línea del
script que es ejecutado a la ventana de depuración, incluyendo el valor de
Application.GetLastError() si la línea implica llamar a una acción incorporda.
Usted puede rastrear a su vez, este modo de encendido o apagado
mediante el uso de la acción Debug.SetTraceMode:

Debug.SetTraceMode(turn_on);

...donde turn_on es un valor booleano que indica si el programa a su vez,


traza el modo de encendido o apagado.

Aquí está un ejemplo:

Debug.ShowWindow(true);
50

Debug.SetTraceMode(true);

for i = 1, 3 do
Dialog.Message ( "Número ", i);
end

File.Copy("C:\\fake_file.ext", "C:\\fake_file.bak");

La ejecución de este script produce la siguiente salida en la ventana de


depuración:

Observe que cada línea producida por la función de rastreo se inicia con el
modo de "Trace:" Esto es lo que les puedo decir aparte de todas las líneas
que va a enviar la ventana de depuración con Debug.Print. El número
después de la "Trace:" es el número de línea que está siendo ejecutado en
el script.

Volviendo sobre el modo de rastrear es algo que usted probablemente no


quiere hacer en su final, a distribuir la aplicación, pero puede realmente
ayudar a encontrar problemas durante el desarrollo. De hecho, hay una
opción en AutoPlay Media Studio compilar preferencias que le permite
activar automáticamente el modo de rastreo cada vez que se de la vista
previa. (Seleccione Herramientas (Tools)>Preferencias (Preferences) y haga
clic en la categoría Construir (Build). En la sección Vista Preliminar
(Preview), a su vez activar la opción llamada "Mostrar ventana de
depuración.") Sin embargo, incluso con esta opción habilitada, traza el
modo de no ser activada en la versión que se construyó cuando publique su
proyecto, a menos que usted lo especifiqué a su vez que en su secuencia de
comandos (script).

Debug.GetEventContext
Esta acción se utiliza para obtener una cadena descriptiva sobre el evento
que está siendo ejecutado. Esto puede ser útil si se define una función en
51

un solo lugar, pero lo llaman en algún otro lugar, y que desea estar en
condiciones de decir que la función se llama desde en un momento dado.
Por ejemplo, si se ejecuta este script de un botón en el evento Click sobre
Página1:

Dialog.Message("Contexto del evento", Debug.GetEventContext());

... verás algo como esto:

Dialog.Message
Esto nos lleva a una buena ole' Dialog.Message. Ustedes han visto esta
acción utiliza en este documento, y por una buena razón. Esta es una gran
acción de utilizar a lo largo de su código cuando se está tratando de
localizar un problema.

Consideraciones finales
Esperemos que este documento ha ayudado a comprender la programación
de scripting en AutoPlay Media Studio. Una vez que se cuelgue de la misma,
es una muy divertida y potente forma de hacer las cosas.

Otros recursos
Aquí está una lista de otros lugares que usted puede acudir para obtener
ayuda con scripting en AutoPlay Media Studio.

Archivos de ayuda
El archivo de ayuda de AutoPlay Media Studio está lleno de buenos
materiales de referencia para todos los eventos y acciones apoyadas por
AutoPlay Media Studio, y para el entorno de diseño propio. Puede acceder al
archivo de ayuda en cualquier momento seleccionando Ayuda> Ayuda de
AutoPlay Media Studio, en el menú Ayuda.

Otro consejo útil: si se encuentra en el Editor de secuencias de comandos y


desea obtener más información acerca de una acción, simplemente haga
clic en la acción y pulse la tecla F1 en su teclado.

Guía del usuario


La guía del usuario es una fantástica manera de empezar con AutoPlay
Media Studio. Está escrito en una forma fácil de seguir formato de tutorial,
52

le enseña acerca de los eventos, acciones y secuencias de comandos. Se le


despegue y el funcionamiento en ninguna hora! Puede acceder a la guía del
usuario seleccionando Ayuda> de AutoPlay Media Studio Guía del Usuario
en el menú.

Sitio Web de AutoPlay Media Studio


El sitio web de AutoPlay Media Studio se encuentra en
http://www.indigorose.com. Asegúrese de verificar los foros de usuarios
donde se pueden leer las preguntas y respuestas de los usuarios y los
compañeros de Indigo Rose, así como hacer preguntas de su propia cuenta.

Una manera rápida de acceder a los foros en línea es elegir Ayuda> Foros
de usuarios de AutoPlay Media Studio en el menú Ayuda.

Indigo aumentó el apoyo técnico


Si necesita ayuda con cualquier secuencia de comandos o conceptos tienen
un bloqueo mental a través de empujar, no dude en visitar
http://support.indigorose.com. Aunque no podemos escribir scripts para
usted o para depurar sus scripts, estaremos encantados de responder
cualquier pregunta general de secuencias de comandos que tenga.

El sitio Web de Lua


El motor de scripting de AutoPlay se basa en un popular lenguaje de
scripting llamado Lua. Lua se ha diseñado y ejecutado por un equipo de
Tecgraf, The Computer Graphics Technology Group de la PUC-Rio (la
Pontificia Universidad Católica de Río de Janeiro en Brasil). Puede obtener
más información sobre Lua y su historia oficial en el sitio web de Lua:

http://www.lua.org

Esto también es donde usted puede encontrar la documentación más


reciente sobre el lenguaje Lua, junto con tutoriales y una realmente amistad
de la comunidad de desarrolladores de Lua.

Tenga en cuenta que puede haber otras funciones incorporadas que existen
en Lua y en AutoPlay Media Studio que no están soportadas de forma
oficial. Estas funciones, en su caso, están documentadas en el Lua 5.0
Manual de Referencia.

Sólo las funciones enumeradas en la ayuda en línea cuentan con el apoyo


de Indigo Rose Software. Cualquier otra función "indocumentada" que usted
puede encontrar en la documentación de Lua no son compatibles. Aunque
estas funciones pueden trabajar, usted debe utilizar por completo por su
cuenta.
53