Introducción Una de las más potentes características de AutoPlay Media Studio es su motor de Script. Este documento te introducirá en el nuevo ambiente y lenguaje de Script. El Script de AutoPlay es muy simple, con sólo un puñado de conceptos por aprender. Así es como se mira: 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 te preocupes si aún no entiendes nada.) El ejemplo anterior le asigna un valor a una variable, prueba el contenido de esa variable y si el valor resulta que es menor de 10, utiliza una acción de AutoPlay llamada “Dialog.Message” para mostrarle un mensaje al usuario. Los programadores novatos así como los codificadores experimentados encontrarán que el AutoPlay Media Studio tiene un poderoso, flexible y sencillo ambiente de Script en el que pueden introducirse.
Un ejemplo Rápido de Script en AutoPlay Media Studio Aquí está un corto tutorial que te muestra cómo introducir un Script en AutoPlay Media Studio y previsualizar los resultados: 1. Inicia un nuevo proyecto. 2. Crea un objeto de botón nuevo. 3. En la categoría Actions del panel Propiedades, haz click en el evento On Click. Un pequeño botón de edición con tres puntos deberá aparecer enseguida de la palabra “-- None --” a la derecha.
4. Haz click en el botón de edición para abrir el editor de Script. Date cuenta que éste se abre directamente en la pestaña On Click.
1
5. Escribe el siguiente texto: Dialog.Message("Title", "Hello World"); Se deberá ver así cuando hayas terminado:
6. Haz click en OK para cerrar el editor de Script. 7.
Elige el menú Publish > Preview.
8. Una vez que la aplicación se esté ejecutando, haz click en el botón que creaste. Esto activará el evento On Click del botón, así que el Script que tu introduciste será ejecutado. Se deberá ver el siguiente cuadro de diálogo aparecer:
Felicidades: Acabas de hacer tu primer Script. Aunque este es un ejemplo muy sencillo, muestra lo fácil que es hacer que algo suceda en tu aplicación AutoPlay. Puedes usar el método arriba descrito para probar cualquier Script que quieras en AutoPlay Media Studio.
2
Conceptos Importantes de un Script Hay algunas cosas importantes que en general deberás saber acerca del Script de AutoPlay Media Studio antes de comenzar.
El Script es Global El motor de Script es global en el ambiente de tiempo de ejecución. Esto significa que todos los eventos “sabrán” acerca de otras variables y funciones declaradas en alguna otra parte del producto. Por ejemplo, si asignas “myvar = 10;” en el evento On Startup del proyecto, myvar aún será igual a 10 cuando el próximo evento dé inicio. Hay métodos en torno a esta modalidad global (ver Variable Scope), pero están por lo general alineados al motor del Script.
El Script es Sensible a las Mayúsculas-Minúsculas El motor de Script es sensible a las mayúsculas-minúsculas. Esto significa que los caracteres en mayúscula y minúscula son importantes para tópicos como contraseñas, nombres de variables y nombres de funciones. Por ejemplo: ABC = 10; aBC = 7; En el script de arriba, ABC y aBC se refieren a dos variables distintas, y pueden tener diferentes valores. La letra minúscula “a” en “aBC” la hace completamente diferente de “ABC” en cuanto a lo que AutoPlay le concierne. El mismo principio también se aplica a los nombres de función. Por ejemplo: Dialog.Message("Qué tal", "Hola Mundo"); ...se refiere a una función integrada en AutoPlay. Sin embargo, DIALOG.Message("Qué tal", "Hola Mundo "); ...no será reconocida como una función integrada, debido a que DIALOG y Dialog son vistos como dos nombres completamente diferentes. Nota: Es completamente posible tener dos funciones con las mismas letras pero diferentes en mayúsculas-minúsculas; por ejemplo: GreetUser y gREeTUSeR serán vistas como dos funciones totalmente diferentes. Aunque es absolutamente posible que tales funciones coexistan, generalmente es mejor darle a las funciones nombres completamente diferentes para evitar cualquier confusión.
3
Comentarios Se pueden insertar comentarios no ejecutables dentro de tus scripts para explicar y documentar tu 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 de arriba hacen exactamente la misma cosa, los comentarios no afectan al script de ningún modo. También puedes crear comentarios multilínea usando --[[ and ]]—al inicio y al final del comentario: --[[ Este es un comentario multilínea ]]-a = 10; Te sugerimos usar comentarios para explicar tus scripts tanto como sea posible para hacerlos más fáciles de entender por ti mismo y por otros.
Delimitando Oraciones Cada única oración puede estar ya sea en su propia línea y/o separada por un punto y coma (;). Por ejemplo, todos los scripts siguientes son válidos: Script 1:
a = 10 MyVar = a Script 2:
a = 10; MyVar = a; Script 3:
a = 10; MyVar = a; Sin embargo, te recomendamos que finalices todas las oraciones con un punto y coma (como en los scripts 2 y 3 de arriba).
4
Variables ¿Qué son las Variables? Las variables son muy importantes en el Script de Autoplay. Las variables son simplemente “apodos” o “contenedores” para valores que podrían necesitar modificarse o reutilizarse después. Por ejemplo, el siguiente script asigna el valor 10 a la variable llamada “cantidad” cantidad = 10; Nota: Decimos que los valores son “asignados a” o “almacenados en” variables. Si describes una variable como un contenedor que contiene un valor, asignar un valor a una variable es como “colocar” ese valor dentro del contenedor. Puedes cambiar este valor en cualquier momento asignándole un valor diferente a la variable; el nuevo valor simplemente reemplazará al anterior. Esta habilidad para contener información cambiable es lo que hace a las variables tan útiles.
Aquí te proporcionamos un par de ejemplos demostrando cómo puedes operar sobre la variable “cantidad” cantidad = 10; cantidad = cantidad + 20; Dialog.Message("Valor", cantidad); Esto almacena 10 en la variable llamada “cantidad”, luego añade 20 a ese valor, y finalmente hace que un cuadro de diálogo aparezca con el valor actual (el cual es ahora el número 30) en él. También puedes asignar una variable a otra: a = 10; b = a; Dialog.Message("Valor", b); Esto hará que un cuadro de diálogo aparezca con el número 10 en él. La línea “b = a;” le asigna el valor de “a” (el cual es 10) a “b”.
Campo de Acción de las Variables Como se había mencionado antes, todas las variables en AutoPlay Media Studio son globales por defecto. Esto significa justamente que existen en todo el proyecto, y mantienen sus valores desde un script al siguiente. En otras palabras, si un valor es asignado a una variable en un script, la variable mantendrá aún ese valor cuando el siguiente script sea ejecutado. Por ejemplo, si introduces el siguiente script:
5
foo = 10; … dentro del evento On Open de la página actual, y luego introduces: Dialog.Message("El valor es:", foo); … dentro del evento On Click de un objeto de botón, el segundo script utilizará el valor que le fue asignado a “foo” en el primer script. Como resultado, cuando el objeto de botón es clickeado, un cuadro de diálogo aparecerá con el número 10 en él. Date cuenta que el orden de ejecución es importante… para que un script sea capaz de usar el valor que le fue asignado a la variable en otro script, ese otro script tiene que ser ejecutado primero. En el ejemplo de arriba, el evento On Open de la página es accionado antes que el evento On Click del botón, así que el valor 10 ya está asignado a “foo” cuando el script del evento On Click es ejecutado.
Variables Locales La naturaleza global del motor del Script significa que una variable retiene su valor a lo largo y ancho de todo tu proyecto. Puedes, sin embargo, hacer variables que sean noglobales usando la palabra clave especial “local”. Poner la palabra “local” antes de una variable asignada crea una variable que es local en el script o función actual. Por ejemplo, digamos que tienes los siguientes tres scripts en el mismo proyecto: Script 1:
-- asigna 10 a x x = 10; Script 2:
local x = 500; Dialog.Message("El valor local de x es:", x); x = 250; -- esto cambia la x local, no la global Dialog.Message("El valor local de x es:", x); Script 3:
-- muestra el valor global de x Dialog.Message("El valor global de x es:", x); Asumamos que estos tres scripts son ejecutados uno después de otro. El primer script le da a x el valor de 10. Puesto que todas las variables son globales por defecto, x tendrá este valor dentro de todos los otros scripts también. El segundo script hace una asignación local para x, dándole el valor de 500 (pero sólo dentro de ese script). Si alguna otra cosa dentro de ese script quiere acceder al valor de x, verá el valor local en lugar del global. Es como si la variable “x” fuera temporalmente reemplazada por otra variable que luce como ésta, pero tiene un valor distinto.
6
(Esto nos recuerda aquellas películas donde los ladrones del banco ponen una fotografía enfrente de las cámaras de seguridad de modo que los guardias no vean que la bóveda está siendo vaciada. Sólo en este caso, es como los ladrones del banco crean una intacta bóveda nueva en operación, como la original, y entonces la desmantelan y luego huyen tranquilamente)
Cuando se manda mostrar el contenido de x, la primera acción interna Dialog.Message del script #2 mostrará 500, puesto que es el valor local de x cuando la acción es ejecutada. La próxima línea le asigna 250 al valor local de x (date cuenta que una vez que haces una variable local, ésta reemplaza completamente a la variable global por el resto del script). Finalmente, la tercera parte del script muestra el valor global de x, el cual es aún 10. (Nota: Para que se muestren los cuadros de diálogo como se describe arriba, deberás introducir el Script #3 en un evento diferente al del Script #2)
Nominación de Variables Los nombres de las variables pueden ser inventados de cualquier combinación de letras, dígitos y subrayados, siempre y cuando no comiencen con un número y no entren en conflicto con palabras clave reservadas. Ejemplos válidos para nombres de variables: a strName _My_Variable data1 data_1_23 index bReset nCount Ejemplos no válidos para nombres de variables: 1 1data %MyValue% $strData for local _FirstName+LastName_ User Name Cálido (no son válidas palabras con acento, diéresis, ni caracteres especiales)
Palabras Clave Reservadas Las siguientes palabras están reservadas y no pueden ser utilizadas para nombres de variables o de funciones:
7
and end in repeat until
break false local return while
do for nil table
else function not then
elseif if or true
Tipos y Valores El lenguaje de Script de Autoplay es dinámicamente escrito. No hay definiciones de tipo (más bien, cada valor lleva su propio tipo). Esto significa que no tienes que declarar que una variable sea de cierto tipo antes de usarla. Por ejemplo, en C++, si quieres usar un número, primero tienes que declarar el tipo de variable y luego asignarle un valor: int j; j = 10; El ejemplo C++ de arriba declara a j como un entero, y luego le asigna un valor de 10. Como hemos visto, en AutoPlay puedes simplemente asignarle un valor a una variable sin declarar su tipo. Las variables realmente no tienen tipos; por el contrario, es el valor interno de ellas lo que hace que sean consideradas un tipo u otro. Por ejemplo: j = 10; … esto crea automáticamente la variable llamada “j” y le asigna el valor de 10. Aunque este valor tiene un tipo (un número), la variable en sí misma es aún sin tipo. Esto significa que puedes regresar y asignarle un tipo diferente de valor a “j”, como esto: j = "Hello"; Esto reemplaza al número 10 que es almacenado en “j” con la cadena “Hello”. El hecho de que una cadena sea un tipo diferente de valor no importa; a la variable “j” no le importa qué tipo de valor soporta, ella sólo almacena lo que tú le asignas. Hay seis tipos básicos de datos en Autoplay: number (número), string (cadena), nil (nulo), boolean (booleano), function (función) y table (tabla). Las secciones de abajo te explicarán cada tipo de datos con más detalle.
Number (Número) Un número es exactamente eso: un valor numérico. El tipo de número representa números reales, especialmente valores de punto flotante de doble precisión. No hay distinción entre números enteros y de punto flotante (también conocidos como “fracciones”)… todos ellos son sólo “números”. Aquí tenemos algunos ejemplos válidos de números: 4
4.
.4
0.4
4.57e-3
8
0.3e12
String (Cadena) Una cadena es simplemente una secuencia de caracteres. Por ejemplo, “Joe2” es una cadena de cuatro caracteres, comenzando con una mayúscula “J” y terminando con el número “2”. Las cadenas pueden variar completamente en longitud; una cadena puede contener una sola letra, una sola palabra o el contenido de un libro entero. Las cadenas pueden contener espacios e incluso caracteres exóticos, tales como símbolos de cambios de línea (retornos de carro) y símbolos de saltos de línea. De hecho, las cadenas pueden contener una combinación de caracteres ASCII 8.bit válidos, incluyendo caracteres invalidados (“\0”). AutoPlay automáticamente maneja la memoria de la cadena, de modo que nunca te preocuparás por memoria no localizada o deslocalizada por las cadenas. Las cadenas pueden ser utilizadas de lo más intuitiva y naturalmente. Deberán ser delimitadas por comillas simples o dobles. Estos son unos ejemplos del uso de cadenas: Name = "Joe Blow"; Dialog.Message("Título", "Hola, cómo estás?"); LastName = 'Blow'; Normalmente las comillas dobles se usan en cadenas, pero las comillas simples pueden ser útiles si tienes una cadena que contiene comillas dobles. Para cualquier tipo de comillas que uses puedes incluirle el otro tipo en su interior de la cadena sin que afecte. Por ejemplo: dobles = "How's that again?"; simples = 'She said "Talk to the hand," and I was all like "Dude!"'; Si usamos comillas dobles para la segunda línea, deberá verse así: evadidas = "She said \"Talk to the hand,\" and I was all like \"Dude!\""; Normalmente, el motor de Script interpreta las comillas dobles como una marca del inicio o fin de una cadena. Para incluir comillas dobles dentro de una cadena con comillas dobles, necesitas escabullirlas con barras inversas. Esto le indica al motor de Script que quieres incluir un carácter de cita literal en la cadena. La barra inversa y comilla (\") es conocida como una escape sequence (secuencia de escape). Una secuencia de escape es una secuencia especial de caracteres que son convertidos o “traducidos” en algo más por el motor de Script. Las secuencias de escape te permiten incluir cosas que no pueden escribirse directamente dentro de una cadena. Las secuencias de escape que puedes usar incluyen: \a \b \f \n \r
-
bell backspace (retroceder un espacio) form feed (avance de página) newline (nueva línea) carriage return (retorno de línea)
9
\t \v \\ \" \' \[ \]
-
horizontal tab (tabulador horizontal) vertical tab (tabulador vertical) backslash (barra inversa) quotation mark (marca de cita literal) apostrophe (apóstrofe) left square bracket (corchete izquierdo) right square bracket (corchete derecho)
Así, por ejemplo, si quieres representar tres líneas de texto en una sola cadena, deberás utilizar lo siguiente: Lineas = "Línea uno.\nLínea dos.\nLínea tres"; Dialog.Message("Aquí está la cadena ", Lineas); Esto le asigna una cadena a la variable nombrada Lineas, y utiliza la secuencia de escape de “nueva línea” para iniciar un nuevo renglón después de cada oración. La función Dialog.Message despliega el contenido de la variable Lineas en un cuadro de diálogo, como éste:
Nota: Si eres muy observador, habrás notado que el nombre de la variable “Lineas” no tiene acento en la letra “i”, en cambio en el contenido de la variable si estamos acentuando todas las palabras “Línea”. Recuerda que el nombre de una variable no deberá estar acentuado porque de lo contrario marcará un error de Script debido a que lo interpreta como una variable no válida; por otro lado el contenido de las cadenas puede incluir cualquier carácter por muy especial que éste sea.
Otro ejemplo común es cuando quieres representar una ruta de archivo tal como C:\Mi Carpeta\Mis Datos.txt. Sólo necesitas acordarte de la secuencia de escape de barra inversa: MiRuta = "C:\\Mi Carpeta\\Mis Datos.txt"; Cada barra inversa doble representa una barra inversa simple cuando es utilizada dentro de una cadena.
10
Si conoces el código ASCII, puedes usar un carácter de barra inversa seguido por un número de hasta tres dígitos para representar cualquier carácter por su valor ASCII. Por ejemplo, el valor ASCII para un carácter de nueva línea es 10, así que las dos líneas mostradas a continuación hacen exactamente la misma cosa: Lineas = "Línea uno.\nLínea dos.\nLínea tres"; Lineas = "Línea uno.\10Línea dos.\10Línea tres"; Sin embargo, no necesitarás usar este formato con mucha frecuencia, si acaso alguna vez. Puedes también definir cadenas en líneas múltiples usando corchetes dobles ([[ and ]]). Una cadena entre corchetes dobles no necesita ningún carácter de secuencia de escape. Los corchetes dobles te permiten introducir caracteres especiales como barras inversas, comillas y nuevas líneas directamente en el interior de la cadena. Por ejemplo: Lineas = [[Línea uno. Línea dos. Línea tres.]]; es equivalente a: Lineas = "Línea uno.\nLínea dos.\nLínea tres"; Esto puede ser útil si has pre-formateado texto que quieras usar como una cadena, y no quieres tener que convertir todos los caracteres especiales en secuencias de escape La última cosa importante que hay que saber acerca de las cadenas, es que el motor de Script proporciona conversión automática entre números y cadenas en tiempo de ejecución. Si una operación numérica es aplicada a una cadena, el motor trata de convertir la cadena a un número para la operación. Por supuesto, esto sólo tendrá éxito si la cadena contiene algo que pueda ser interpretado como un número. Por ejemplo, las siguientes dos líneas son válidas: a = "10" + 1; -- El resultado es 11 b = "33" * 2; -- El resultado es 66 Sin embargo, las siguientes dos líneas no te darían la misma conversión en el resultado: a = "10+1"; -- El resultado es la cadena "10+1" b = "hola" + 1; -- ERROR, no se puede convertir "hola" en un número Para más información del trabajo con cadenas, dirígete al tema “Manipulación de Cadenas”.
Nil (Nulo) Nil es un tipo especial de valor. Básicamente representa la ausencia de cualquier otro tipo de valor.
11
Puedes asignar nil a una variable sólo como cualquier otro valor. Date cuenta que esto no es lo mismo que asignar las letras “nil” a una variable, como en una cadena. Al igual que otras palabras clave, nil debe ser dejada sin comillas para que sea reconocida. También deberá ser introducida con todas las letras en minúscula. Nil siempre evaluará como falso cuando sea usada en una condición b = nil; if b then -- Cualquier línea de script aquí -- no será ejecutada end También puede ser usada para “borrar” una variable y = "Joe Blow"; y = nil; En el ejemplo de arriba, “y” no contendrá por más tiempo un valor después de la segunda línea.
Boolean (Booleano) Los tipos de variables Boolean (o Booleanas) pueden tener uno de estos dos valores; true (verdadero) o false (falso). Pueden ser usadas en condiciones y para ejecutar operaciones lógicas Booleanas. Por ejemplo: boolybooly = true; if boolybooly then -- Cualquier script aquí será ejecutado end Esto establece una variable nombrada “boolybooly” como true (verdadera), y entonces la utiliza en una declaración if. Similarmente: a = true; b = false; if (a y b) then -- Cualquier script aquí no será ejecutado porque -- true y false es false. end Esta vez, la declaración if necesita que tanto “a” como “b” sean true (verdaderas) para que las líneas dentro de ella sean ejecutadas. En este caso, eso no sucederá porque “b” ha sido establecido como false (falso).
Function (Función) El motor de Script te permite definir tus propias funciones (o sub-rutinas), las cuales esencialmente son pequeñas piezas de script que pueden ser ejecutadas a petición. Cada
12
función tiene un nombre, el cual es utilizado para identificar la función. De hecho puedes usar el nombre de esa función como un tipo especial de valor para almacenar una “referencia” a esa función en una variable, o pasarla a otra función. Esta clase de referencia es del tipo function. Para más información sobre funciones, revisa el tema Funciones.
Table (Tabla) Las tablas son un método muy poderoso para almacenar listas de valores indexados bajo un nombre. Las tablas son de hecho arreglos conectivos, es decir, son arreglos que pueden ser indexados no sólo con números, sino con cualquier tipo de valor (incluyendo cadenas). Aquí están unos cuantos ejemplos (se analizan con más detalle las tablas en el tema Tablas ): Ejemplo 1:
muchachos = {"Adán", "Bruno", "Daniel"}; Dialog.Message("Segundo nombre en la lista", muchachos[2]); Esto mostrará un cuadro de diálogo con la palabra “Bruno” en él. Ejemplo 2:
t = {}; t.Nombre = "Miguel"; t.Apellido = "Ramírez"; t.Ocupacion = "Electricista"; Dialog.Message(t.Nombre, t.Ocupacion); Esto mostrará el siguiente cuadro de diálogo:
13
También puedes asignar tablas a otras variables. Por ejemplo: tabla_uno = {}; tabla_uno.Nombre = "Miguel"; tabla_uno.Apellido = "Ramírez"; tabla_uno.Ocupacion = "Electricista"; tabla_dos = tabla_uno; ocupacion = tabla_dos.Ocupacion; Dialog.Message(b.Nombre, ocupacion); Las tablas pueden ser indexadas usando notación de arreglo (mi_tabla[1]), o por notación de punto si no se indexó por números (mi_tabla.Apellido). Date cuenta que cuando le asignas una tabla a otra, como en la siguiente línea: tabla_dos = tabla_uno; … de hecho esto no copia la tabla_uno dentro de la tabla_dos. Más bien la tabla_dos y la tabla_uno se refieren ambas a la misma tabla. Esto es porque el nombre de una tabla en realidad se refiere a una dirección en memoria donde los datos dentro de la tabla son almacenados. Así, cuando asignas el contenido de la variable tabla_uno a la variable tabla_dos, estás copiando la dirección, y no los datos actuales. Esencialmente estás haciendo que las dos variables se “enfoquen” a la misma tabla de datos. Para copiar el contenido de una tabla, necesitas crear una nueva tabla y entonces copiar todos los datos sobre un elemento a la vez. Para más información del copiado de tablas, dirígete al tema Tablas )
Variable de Asignación Las variables pueden tener nuevos valores asignados a ellas usando el operador de asignación (=). Esto incluye el copiar el valor de una variable dentro de otra. Por ejemplo: a = 10; b = "Estoy feliz"; c = b; Es interesante notar que el motor de Script soporta asignación múltiple: a, b = 1, 2; Dentro del script de arriba, la variable “a” contiene el número 1 y la variable “b” contiene el número 2. Las tablas y las funciones son algo así como un caso especial: cuando usas el operador de asignación (=) en una tabla o función, creas un “sobrenombre” que se refiere a la
14
misma tabla o función de la variable que está siendo “copiada”. Los programadores le llaman a este copiado by reference (por referencia) , opuesto al copiado by value (por valor) .
15
Expresiones y Operadores Una expresión es cualquier cosa que evalúe a un valor. Esta puede incluir un valor simple tal como “6” o un valor compuesto construido con operadores tal como “1 + 3”. Puedes usar paréntesis para “agrupar” expresiones y controlar el orden en el cual serán evaluadas. Por ejemplo, todas las siguientes líneas evaluarán el mismo valor: a = 10; a = (5 * 1) * 2; a = 100 / 10; a = 100 / (2 * 5);
Operadores Aritméticos Los Operadores Aritméticos son utilizados para ejecutar operaciones matemáticas en números. Los siguientes operadores matemáticos son soportados: + * / unary -
(adición) (substracción) (multiplicación) (división) (negativo)
Aquí tienes algunos ejemplos: a = 5 + 2; b = a * 100; veintitrés por ciento = 23 / 100; neg = -29; pos = -neg;
Operadores de Relación Los Operadores de Relación te permiten comparar la manera en que un valor se relaciona con otro. Los siguientes operadores de relación son soportados: > < <= >= ~= ==
(mayor que) (menor que) (menor o igual que) (mayor o igual que) (no es igual a) (igual a)
Todos los operadores de relación pueden ser aplicados a cualquier par de números o par de cadenas. Todos los demás valores sólo pueden usar el operador == para comparar si son iguales.
16
Los operadores de relación regresan valores Booleanos (true (verdadero) o false (falso)). Por ejemplo: 10 > 20; -- da como resultado un false a = 10; a > 300; -- false (3 * 200) > 500; -- true "Brett" ~= "Lorne" -- true Un punto importante a mencionar es que los operadores == y ~= hacen una prueba de igualdad completa, lo cual significa que cualquier comparación de cadena hecha con dichos operadores es un caso sensible a mayúsculas-minúsculas. Por ejemplo: "Jojoba" == "Jojoba"; -- true "Gato" == "gato"; -- false "Me gusta mucho" == "Me gusta MUCHO"; -- false "feliz" ~= "FeLiZ"; -- true
Operadores Lógicos Los Operadores Lógicos son utilizados para ejecutar operaciones Booleanas en valores Booleanos. Los siguientes operadores lógicos son soportados: and or not
(solo es true ambos valores son true) (true si cualquiera de los valores es true) (regresa lo opuesto del valor)
Por ejemplo: a = true; b = false; c = a y b; -- false d = a y nil; -- false e = not b; -- true Date cuenta que solamente nil y false son consideramos como false, y todos los demás valores son true. Por ejemplo: soyinvisible = nil; if soyinvisible then -- cualquier código puesto aquí no se ejecutará -- porque soyinvisible es considerado false Dialog.Message("No puedes verme!", "Soy invisible!!!!"); end
17
if "Brett" then -- cualquier código puesto aquí sí se ejecutará, porque sólo nil y false -- son considerados false...cualquier otra cosa, incluyendo cadenas, -- es considerada true Dialog.Message("¿Y las cadenas?", "Las cadenas son true."); end
Encadenamiento En el script de AutoPlay, el operador de encadenamiento es dos puntos (..). Este es usado para combinar dos o más cadenas juntas. No tienes que poner espacios antes y después de los dos puntos, pero puedes hacerlo si quieres. Por ejemplo: nombre = "José".." Bonilla"; -- asigna "José Bonilla" a nombre b = nombre .. " es número " .. 1; -- asigna " José Bonilla es número 1" a b
Prioridad de Operadores Se dice que los operadores tienen prioridad , lo cual es una forma de describir las reglas que determinan cuáles operadores se ejecutan primero en una serie de expresiones. Un simple ejemplo sería la expresión 1 + 2 * 3. El operador de multiplicación (*) tiene prioridad más alta que el operador de adición (+), de modo que esta expresión es equivalente a 1 + (2 * 3). En otras palabras, la expresión 2 * 3 es ejecutada primero, y luego 1 + 6 se ejecuta, resultando un valor final de 7. Se puede pasar por alto el orden natural de prioridad con el uso de paréntesis. Por ejemplo, la expresión (1 + 2) * 3 da como resultado el 9. Los paréntesis hacen que la sub-expresión entera (1 + 2) sea el valor izquierdo del operador de multiplicación (*). Esencialmente, la sub-expresión 1 + 2 es evaluada primero, y el resultado es luego usado en la expresión 3 * 3. La prioridad de operadores tiene el siguiente orden, partiendo de la prioridad más baja a la más alta: and
or
<
>
.. + * not ^
/ - (unary)
<=
>=
~=
==
Se dice también que los operadores tienen asociatividad , que es una forma de describir cuáles expresiones son ejecutadas primero cuando los operadores tienen igual prioridad. En el motor de Script, todos los operadores binarios son asociativos izquierdos, esto quiere decir que cuando dos operadores tienen la misma prioridad, la operación de la
18
izquierda se ejecuta primero. La excepción es el operador de exponenciación (^), el cual es asociativo derecho Cuando tengas dudas, siempre puedes usar paréntesis explícitos para controlar la prioridad. Por ejemplo: a + 1 < b/2 + 1 ...es lo mismo que: (a + 1) < ((b/2) + 1) ...igualmente, puedes usar paréntesis para cambiar el orden de los cálculos: a + 1 < b/(2 + 1) En este último ejemplo, en vez de que 1 sea añadido a la mitad de b, b es dividido entre 3.
19
Estructuras de Control El motor de Script soporta las siguientes estructuras de control: if, while, repeat y for.
If Una declaración if evalúa su condición y entonces ejecuta la parte “then” sólo si la condición es true. Una declaración if es finalizada por la palabra clave “end”. La sintaxis básica es: if condicion then haz algo aquí end Por ejemplo: x = 50; if x > 10 then Dialog.Message("resultado", "x es más grande que 10"); end y = 3; if ((35 * y) < 100) then Dialog.Message("", "y veces 35 es menor que 100"); end En el script de arriba, solamente el primer cuadro de diálogo será mostrado, porque la segunda condición if no es true… 35 veces 3 es 105, pero 105 no es menor que 100. También puedes usar else y elseif para añadir más “ramificaciones” a la declaración if : x = 5; if x > 10 then Dialog.Message("", "x es mayor que 10"); else Dialog.Message("", "x es menor o igual a 10"); end En este ejemplo, el segundo cuadro de diálogo deberá mostrarse porque 5 no es mayor que 10. Veamos un último ejemplo: x = 5; if x == 10 then Dialog.Message("", "x is exactamente 10"); elseif x == 11 then Dialog.Message("", "x is exactamente 11");
20
elseif x == 12 then Dialog.Message("", "x is exactamente 12"); else Dialog.Message("", "x no es 10, 11 o 12"); end En este ejemplo, el último cuadro de diálogo será mostrado debido a que x no es igual a 10, 11 o 12.
While La declaración while es utilizada para ejecutar el mismo “paquete” de script una y otra vez hasta que una condición sea encontrada. Al igual que las declaraciones if , las declaraciones while son finalizadas con la palabra clave “end”. La sintaxis básica es: while condicion do haz algo aquí end La condición debe ser true para que las acciones dentro de la declaración while (la parte “haz algo aquí”) sea ejecutada. La declaración while continuará repitiéndose hasta que esta condición sea true. Así es como trabaja: Si la condición es true, todas las acciones entre el “while” y su correspondiente “end” serán ejecutadas. Cuando el “end” es alcanzado, la condición será reevaluada, y si ésta aún es true, las acciones entre “while” y “end” serán ejecutadas de nuevo. Las acciones continuarán en ciclo hasta que la condición sea evaluada como false. Por ejemplo: a = 1; while a < 10 do a = a + 1; end En el ejemplo de arriba, la línea “a = a + 1;” será ejecutada 9 veces. Puedes romper un ciclo while en el momento que quieras usando la palabra clave “break”. Por ejemplo: count = 1; while count < 100 do count = count + 1; if count == 50 then break; end end Aunque la declaración while está dispuesta a contar de 1 a 99, la declaración if causará que este ciclo termine en el momento que la cuenta alcance 50
21
Repeat La declaración repeat es similar a la declaración while, excepto que la condición es comprobada al final de la estructura en lugar de verificarse al inicio. La sintaxis básica es: repeat haz algo aquí until condicion Por ejemplo: i = 1; repeat i = i + 1; until i > 10 Esto es similar a uno de los ciclos while que se explicó arriba, pero esta vez, el ciclo es ejecutado 10 veces. La parte “i = i + 1;” es ejecutada antes de que la condición determine que i es ahora más grande que 10. Puedes interrumpir este ciclo en el momento que quieras usando la palabra clave “break”. Por ejemplo: count = 1; repeat count = count + 1; if count == 50 then break; end until count > 100 Una vez más, esto detendrá el ciclo en el momento en que la cuenta sea igual a 50.
For La declaración for es utilizada para repetir un bloque de script un determinado número de veces. La sintaxis básica es: for variable = start ,end ,step do do something here end La variable puede ser nombrada como desees. Esta declaración for es utilizada para “contar” el número de paseos a lo largo del ciclo for . Comienza en el valor start que especifiques, y luego cambia por la cantidad en step después de cada paseo a través del ciclo. En otras palabras, el step es añadido al valor en la variable después de que las líneas entre for y end son ejecutadas. Si el resultado es menor o igual a el valor end , el ciclo continúa desde el principio.
22
Por ejemplo: -- Este ciclo cuenta de 1 a 10: for x = 1, 10 do Dialog.Message("Number", x); end El ejemplo anterior despliega 10 mensajes de diálogo en fila, contando de 1 a 10. Date cuenta que el step es opcional (si no proporcionas un valor para el step, por defecto es 1). Aquí ponemos un ejemplo que utiliza un step de “-1” para hacer que el ciclo for cuente hacia atrás: -- Este ciclo cuenta de 10 a 1: for x = 10, 1, -1 do Dialog.Message("Número", x); end Este ejemplo mostrará 10 mensajes de diálogo en fila, contando hacia atrás desde 10 y retrocediendo hasta 1. Puedes interrumpir un ciclo for en el momento que quieras usando la palabra clave “break” for i = 1, 100 do if count == 50 then break; end end De nuevo, esto finalizará el ciclo en el momento que la cuenta sea igual a 50. Hay también una variación en el ciclo for que opera en tablas. Para más información sobre esto, ve a la sección El Uso de For para Enumerar Tablas.
23
Tablas (Arreglos) Las tablas son muy útiles. Pueden ser utilizadas para almacenar cualquier tipo de valor, incluyendo funciones o incluso otras tablas.
Creación de Tablas Generalmente hay dos formas de crear una tabla desde cero. El primer método utiliza llaves para especificar una lista de valores: mi_tabla = {"manzana","naranja","durazno"}; tabla_asociativa = {fruta="manzana", vegetal="zanahoria"} El segundo método es crear una tabla en blanco y luego añadir los valores uno por uno: mi_tabla = {}; mi_tabla[1] = "manzana"; mi_tabla[2] = "naranja"; mi_tabla[3] = "durazno"; tabla_asociativa = {}; tabla_asociativa.fruta = "manzana"; tabla_asociativa.vegetal = "zanahoria";
Acceso a los Elementos de la Tabla Cada “registro” de información almacenado en una tabla es conocido con un elemento . Cada elemento consta de una clave, la cual sirve como el índice dentro de la tabla, y un valor que es asociado con la clave Generalmente, hay dos formas de accesar un elemento: puedes usar notación de arreglo o notación de punto. La notación de arreglo es utilizada típicamente con arreglos numéricos, los cuales son simplemente tablas donde todas las claves son números. La notación de punto es usada normalmente con arreglos asociativos, los cuales son tablas donde las claves son cadenas. Aquí te mostramos un ejemplo de notación de arreglo: t = { "uno", "dos", "tres"}; Dialog.Message("El elemento uno contiene:", t[1]); Y aquí un ejemplo de notación de punto: t = { first="uno", second="dos", third="tres"}; Dialog.Message("El elemento 'first' contiene:", t.first);
24
Arreglos Numéricos: Uno de los usos más comunes en las tablas son los arreglos. Un arreglo es una colección de valores que están indexados por claves numéricas. En el motor de Script, los arreglos numéricos están basados en 1. Es decir, que comienzan a indexarse en 1. Aquí están algunos ejemplos del uso de Arreglos Numéricos: Ejemplo 1:
miArreglo = {255,0,255}; Dialog.Message("Primer Número", miArreglo [1]); Esto desplegará un mensaje de diálogo conteniendo el número “255”. 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 Letra", alfabeto[7]); Esto desplegará un mensaje de diálogo conteniendo la letra “g.” Ejemplo 3:
miArreglo = {}; miArreglo[1] = "Opción Uno"; miArreglo[2] = "Opción Dos"; miArreglo[3] = "Opción Tres"; Esto es exactamente lo mismo que lo siguiente: miArreglo = {"Opción Uno", " Opción Dos", " Opción Tres"};
Arreglos Asociativos Los Arreglos Asociativos son lo mismo que los Arreglos Numéricos, excepto que en los primeros los parámetros pueden ser números, cadenas o incluso funciones. Aquí está un ejemplo de un arreglo asociativo que usa un apellido como un parámetro, y un nombre como el valor arrNombres = {Cuevas="Juan", Cardona="Rogelio", Contreras="José", Herrera="Christian", Hitchcock="Alfredo"}; Dialog.Message("El nombre de Cuevas", arrNombres.Cuevas);
25
El mensaje de diálogo resultante será como éste:
Aquí está un ejemplo de una simple base de datos de empleados que sigue la pista de los nombres y fechas de nacimiento de empleados, indexados por número de empleado: Empleados = {}; -- Construye una tabla vacía para los números de empleado -- almacena información de cada empleado en su propia tabla Empleado1 = {Nombre="Juan Cuevas", Nacimiento="07/02/82"}; Empleado2 = {Nombre="Rogelio Cardona", Nacimiento="12/25/79"}; -- almacena la tabla de información de cada empleado -- en el número apropiado de la tabla de empleados Empleados[100099] = Empleado1; Empleados[137637] = Empleado2; -- ahora la escritura "Empleados[100099]" es lo mismo que la escritura "Empleado1" Dialog.Message("Fecha de Nacimiento",Empleados[100099].Nacimiento); El mensaje de diálogo resultante tendrá este aspecto:
El Uso de For para Enumerar Tablas Hay una versión especial de la declaración for que te permite enumerar el contenido de un arreglo rápida y fácilmente. La sintaxis es:
26
for index,value in table do operate on index and value end Por ejemplo: mitabla = {"Uno","Dos","Tres"}; -- despliega un mensaje para cada artículo de la tabla for j,k in mitabla do Dialog.Message("Artículo", j .. "=" .. k); end El resultado serán tres mensajes de diálogo en fila, uno por cada elemento en mitabla, como estos:
Acuérdate de la declaración for de arriba, porque es una manera rápida y fácil de inspeccionar los valores en una tabla. Si sólo quieres los parámetros de una tabla, puedes omitir la parte value de la declaración for : a = {Uno=1,Dos=2,Tres=3}; for k in a do Dialog.Message("Indice de Tabla",k); end El script de arriba mostrará tres mensajes de diálogo en fila, con el texto “Uno”, “Tres”, y luego “Dos”. ¿Cómo? ¿Por qué los elementos de la tabla no están es orden? La razón de esto es que internamente el motor de Script no almacena tablas como arreglos, sino en una estructura super-eficiente conocida como una tabla chapuza. (No te preocupes, al principio muchos se confunden con las tablas chapuza). La cosa importante a saber es que cuando defines elementos de tabla, éstos no son almacenados necesariamente de manera que los definas o los añadas, a menos que uses un arreglo numérico (por ejemplo una tabla indexada con números del 1 al que quieras).
27
Copiar Tablas Copiar tablas es un poco diferente a copiar otro tipo de valores. A diferencia de las variables, tú no puedes usar el operador de asignación para copiar el contenido de una tabla dentro de otra. Esto es porque el nombre de la tabla de hecho se refiere a una dirección en memoria donde los datos dentro de la tabla son almacenados. Si tratas de copiar una tabla en otra usando el operador de asignación, acabarás copiando la dirección, y no los datos actuales. Por ejemplo, si quisieras copiar una tabla, y luego modificar la copia, tendrías que intentar algo como esto: tabla_uno = { color="Rojo", temperatura="Caliente" }; -- crear una copia tabla_dos = tabla_uno; -- modificar la copia tabla_dos.temperatura = "Fría"; Dialog.Message("Temperatura Tabla Uno:", tabla_uno.temperatura); Dialog.Message("Temperatura Tabla Dos:", tabla_dos.temperatura); Si ejecutas este script, verás los siguientes dos diálogos:
Espera un minuto… el cambio del elemento “temperatura” en tabla_dos también lo cambió en tabla_uno. ¿Por qué cambiaron ambos? La respuesta es simple: porque las dos son de hecho la misma tabla. Internamente, el nombre de una tabla sólo se refiere a una ubicación en memoria. Cuando tabla_uno es creada, una porción de memoria es dejada aparte para mantener su contenido. La ubicación (o “dirección”) de esta memoria es la que es asignada a la variable llamada tabla_uno. Asignar tabla_uno a tabla_dos sólo copia la dirección de memoria, no la memoria actual en sí misma.
28
Es como anotar el domicilio de una biblioteca en un pedazo de papel, y luego darle ese papel a tu amigo. Tú no estás dándole la biblioteca entera, con estantes de libros y todo… sólo le proporcionaste la ubicación donde pueda ser encontrada. Si quisieras actualizar una copia de la biblioteca, tendrías que crear un nuevo edificio, fotocopiar cada libro individualmente, y luego almacenar las fotocopias en la nueva ubicación. Eso es demasiado, como lo es con tablas también. Para crear una copia completa de una tabla, con su contenido y todo, necesitas crear una nueva tabla y luego copiar todos los elementos de uno en uno. Afortunadamente, la declaración for hace esto realmente fácil de hacer. Por ejemplo, aquí está una versión modificada de nuestro más reciente ejemplo, que crea una copia “verdadera” de tabla_uno. tabla_uno = { color="Rojo", temperatura="Caliente" }; -- crear una copia tabla_dos = {}; for index, value in tabla_uno do tabla_dos [index] = value; end -- modificar la copia tabla_dos.temperatura = "Fría"; Dialog.Message("Temperatura Tabla Uno:", tabla_uno.temperatura); Dialog.Message("Temperatura Tabla Dos:", tabla_dos.temperatura); Esta vez, los diálogos muestran que la modificación de tabla_dos no afecta para nada a tabla_uno:
Funciones en Tablas Hay un buen número de Funciones de Tabla integradas a tu disposición, las cuales puedes utilizar para hacer tales cosas como insertar, remover y cuantificar elementos dentro de una tabla. Para más información sobre las Funciones de Tabla, por favor dirígete a Program Reference / Actions / Table en la Ayuda en Línea.
29
Funciones Por mucho, la más estupenda y poderosa característica del motor de Script son las Funciones. Ya has visto muchas de ellas utilizadas a lo largo de este documento, tales como “Dialog.Message.”. Las Funciones simplemente son porciones de script que puedes definir, nombrar y luego llamar desde donde quieras. Aunque hay muchas funciones integradas en AutoPlay, puedes tener las tuyas propias que se ajusten a la medida de tus necesidades. En general, las funciones están definidas como sigue: function function_name (arguments) function script here return return_value ; end La primera parte es la palabra clave “function”. Esta le dice al motor de Script que lo que sigue es una definición de función. La function_name es simplemente un nombre único para tu función. Los arguments son parámetros (o valores) que serán transferidos a la función cada vez que sea llamada. Una función puede recibir cualquier número de argumentos desde 0 a infinito (bueno, no hasta infinito, pero casi). La palabra clave “return” le dice a la función que devuelva uno o más valores al script que la llamó. La forma más fácil de aprender acerca de las funciones es mirar algunos ejemplos. En este primer ejemplo, haremos una simple función que muestre un cuadro de mensaje. Esta no toma ningún argumento y no devuelve nada. function HelloWorld() Dialog.Message("Bienvenido","Hola Mundo"); end Date cuenta que si pones el script de arriba dentro de un evento y lo previsualizas en tu aplicación, nada sucede. Bueno, esto es verdad y no lo es. Es verdad que nada visible sucede pero lo mágico es que tú no puedes verlo. Cuando el evento es lanzado y el script function es ejecutado, la función llamada “HelloWorld” viene a ser parte del motor de Script. Esto significa que está ahora disponible para el resto de la aplicación en cualquier otro script. Esto plantea un punto importante acerca del Script en AutoPlay Media Studio. Cuando se construye una función, la función no se “adentra” en el motor sino hasta que el script es ejecutado. Lo cual significa que si defines HelloWorld() en el evento On Click de un botón, pero ese evento nunca es activado (debido a que el usuario no hace click sobre el botón), entonces la función HelloWorld() nunca existirá. Es decir, no serás capaz de llamarla desde alguna otra parte. Esto es porque, en general, es lo mejor para definir tus funciones globales en el script global del proyecto. (Para acceder al script global, elige el menú Project > Global Functions).
30
Ahora, regresemos a cosas buenas. Añadamos una línea para llamar a la función verdaderamente: function HelloWorld() Dialog.Message("Bienvenido","Hola Mundo"); end HelloWorld(); La línea “HelloWorld();” le avisa al motor de Script para que “ejecute la función llamada HelloWorld”. Cuando esa línea sea ejecutada, verás un mensaje de bienvenida con el texto “Hola Mundo” en él.
Argumentos de Función Llevemos esto un poco más allá y digámosle al cuadro de diálogo cuál texto mostrar al añadir un argumento a la función function HelloWorld(Mensaje) Dialog.Message("Bienvenido", Mensaje); end HelloWorld("Esto es un argumento"); Ahora el cuadro de diálogo muestra el texto que fue “pasado” a la función. En la definición de función, “Mensaje” es una variable que automáticamente recibe cualquier argumento que sea pasado a la función. En la llamada de función, pasamos la cadena "Esto es un argumento" como el primer (y único) argumento para la función HelloWorld. Aquí está un ejemplo del uso de argumentos múltiples: function HelloWorld(Titulo, Mensaje) Dialog.Message(Titulo, Mensaje); end HelloWorld("Este es el argumento uno", "Este es el argumento dos"); HelloWorld("Bienvenido", "Hola"); Esta vez, la definición de función utiliza dos variables, una para cada uno de sus argumentos… y cada llamada de función le pasa dos cadenas a la función HelloWorld Nota que cambiando el contenido de esas cadenas, puedes mandar argumentos diferentes a la función, y lograr distintos resultados.
31
Valores Devueltos (o de Retorno) El siguiente paso es hacer que la función devuelva valores al llamado del script. He aquí una función que acepta un número como su único argumento, y luego devuelve una cadena conteniendo todos los números desde el uno hasta ese número. function Count(n) -- comenzar con una cadena de retorno en blanco ReturnString = ""; for num = 1,n do -- añadir el número actual (num) al final de la cadena de retorno ReturnString = ReturnString..num; -- si éste no es el ultimo número, entonces añadir una coma y un espacio -- para separar los números un poco en la cadena de retorno if (num ~= n) then ReturnString = ReturnString..", "; end end -- devolver la cadena que fue construida return ReturnString; end CountString = Count(10); Dialog.Message("Conteo", CountString); Las últimas dos líneas del script de arriba utilizan la función Count para construir una cadena contando del 1 al 10, la almacenan en una variable llamada CountString, y luego muestran el contenido de la variable en un mensaje de diálogo.
Valores Múltiples Devueltos Adicionalmente, puedes devolver valores múltiples de funciones: function SortNumbers(Number1, Number2) if Number1 <= Number2 then return Number1, Number2 else return Number2, Number1 end end firstNum, secondNum = SortNumbers(102, 100); Dialog.Message("Ordenados", firstNum ..", ".. secondNum);
32
El script anterior crea una función llamada SortNumbers que toma dos argumentos y luego 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. Date cuenta que especificamos dos variables para recibir los valores devueltos de la llamada de función en la penúltima línea. La última línea del script muestra los dos números en el orden que fueron clasificados por la función.
Redefiniendo Funciones Otra cosa interesante acerca de las funciones es que puedes “ignorar” (pasar por alto) una previa definición de función simplemente redefiniéndola. function HelloWorld() Dialog.Message("Mensaje","Hola Mundo"); end function HelloWorld() Dialog.Message("Mensaje ","Hola Tierra"); end HelloWorld(); El script de arriba mostrará un cuadro de diálogo que diga “Hola Tierra” y no “Hola Mundo”. Esto es porque la segunda versión de la función HelloWorld() hace que la primera sea ignorada.
Poniendo Funciones en Tablas Una cosa realmente poderosa acerca de las tablas es que éstas pueden ser usadas para contener funciones también como otros valores. Esto es importante porque te permite estar seguro que tus funciones tienen nombres únicos y están agrupadas lógicamente. (Así es como todas funciones de AutoPlay Media Studio están implementadas). Aquí tenemos un ejemplo: -- Hace las funciones: function HelloEarth() Dialog.Message("Message","Hello Earth"); end function HelloMoon() Dialog.Message("Message","Hello Moon"); end -- Define una tabla vacía: Hello = {}; -- Asigna las funciones a la tabla: Hello.Earth = HelloEarth; Hello.Moon = HelloMoon;
33
-- Ahora llama a las funciones: Hello.Earth(); Hello.Moon(); También es interesante notar que puedes definir funciones directamente en tu definición de tabla: Hello = { Earth = function () Dialog.Message("Message","Hello Earth") end, Moon = function () Dialog.Message("Message","Hello Moon") end }; -- Ahora llama a las funciones: Hello.Earth(); Hello.Moon();
34
Manipulación de Cadenas (Ligaduras) En esta sección cubriremos brevemente algunas de las técnicas más comunes de manipulación de cadenas o ligaduras, tales como conexión y comparación de cadenas. (Para más información sobre las funciones de cadena disponibles para ti en AutoPlay Media Studio, ve al tema Program Reference / Actions / String de la ayuda en línea).
Conexión de Cadenas Ya hemos cubierto el tema de conexión de cadenas, pero vale la pena profundizar sobre él. El operador para la conexión de cadenas es dos puntos en fila (..). Por ejemplo: NombreCompleto = "Luis".."Cardona"; -- NombreCompleto es ahora "Luis Cardona" -- También puedes conectar números dentro de cadenas DiasDelAño = 365; AñoCadena = "Hay ".. DiasDelAño.." días en un año."; Observa que puedes poner espacios en ambos lados de los puntos, o en un solo lado, o no poner ningún espacio. Por ejemplo, las siguientes cuatro líneas lograrán el mismo resultado: foo = "Hello " .. user_name; foo = "Hello ".. user_name; foo = "Hello " ..user_name; foo = "Hello "..user_name;
Comparación de Cadenas Después de la conexión, una de las cosas más comunes que querrás hacer con las cadenas es comparar una cadena con otra. Dependiendo de qué constituye una “comparación”, ésta puede ser muy simple o sólo un poco mañosa. Si quieres ejecutar una comparación sensible a diferencia entre mayúsculas y minúsculas, entonces todo lo que tienes que hacer es usar el operador (==). Por ejemplo: strOne = "Strongbad"; strTwo = "Strongbad"; if strOne == strTwo then Dialog.Message("¿Adivina qué?", "¡Las dos cadenas son iguales!"); else Dialog.Message("Hmmm", "Las dos cadenas son diferentes."); end
35
Puesto que el operador == ejecuta una comparación sensible a diferencia entre mayúsculas y minúsculas cuando es aplicado a cadenas, el script de arriba mostrará un mensaje de diálogo proclamando que las dos cadenas son iguales. Si quieres ejecutar una comparación no sensible a diferencia entre mayúsculas y minúsculas, entonces necesitas echar mano de las funciones String.Upper o String.Lower, para asegurar que ambas cadenas tienen la misma escritura antes de que las compares. La función String.Upper devuelve una versión “todas mayúsculas” de la cadena dada, y la función String.Lower devuelve una versión “todas minúsculas”. Date cuenta que no importa cuál función emplees en tu comparación, siempre y cuando utilices la misma función a ambos lados del operador == en tu declaración. Por ejemplo: strOne = "Mooohahahaha"; strTwo = "MOOohaHAHAha"; if String.Upper(strOne) == String.Upper(strTwo) 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 strOne a “MOOOHAHAHAHA” y strTwo a “MOOOHAHAHAHA” y luego la declaración if compara los resultados. (Nota: Las dos cadenas originales permanecen sin cambio). De esta manera, no importa cuáles mayúsculas o minúsculas tenían las cadenas originales; todo lo que importa es si las letras son las mismas.
Conteo de Caracteres Si alguna vez quieres saber qué tan larga es una cadena, puedes contar fácilmente el número de caracteres que contiene. Sólo utiliza la función String.Length, como en este ejemplo: trabador = "Tres tristes tigres tragaban trigo en tres trises trastos sentados en un trigal..."; num_carac = String.Length(trabador); Dialog.Message("¡Este trabalenguas tiene:", num_carac .. " caracteres!"); … lo cual producirá el siguiente mensaje de diálogo:
36
Encontrando Cadenas Otra cosa común que querrás hacer con cadenas es buscar una cadena dentro de otra. Esto es muy simple de hacer usando la acción String.Find. Por ejemplo: strSearchIn = "¿Verdad que es un día para maravillarse?"; strSearchFor = "maravilla"; -- busca strSearchIn en el interior de strSearchFor nFoundPos = String.Find(strSearchIn, strSearchFor); if nFoundPos ~= nil then -- encuéntralo! Dialog.Message("Resultado de la Búsqueda", strSearchFor .. " fue encontrado en la posición " .. nFoundPos); else -- no hubo suerte Dialog.Message("Resultado de la Búsqueda ", strSearchFor .. " ¡no fue encontrado!"); end ...causaría que el siguiente mensaje fuera mostrado:
Consejo: Prueba experimentando con diferentes valores para strSearchFor y strSearchIn.
Reemplazando Cadenas Una de las cosas más poderosas que puedes hacer con las cadenas es ejecutar una búsqueda y reemplazar la operación en ellas. El siguiente ejemplo muestra cómo puedes usar la acción String.Replace para sustituir cada evento de una cadena con otra dentro de una cadena objetivo. strTarget = "¡Puede haber solo una. Sólo una es permitida!"; strSearchFor = "una"; strReplaceWith = "una docena"; strNewString = String.Replace(strTarget, strSearchFor, strReplaceWith); Dialog.Message("Después de la búsqueda y el reemplazo:", strNewString);
37
-- crea una copia de la cadena objetivo sin espacios en ella strNoSpaces = String.Replace(strTarget, " ", ""); Dialog.Message("Después de eliminar espacios:", strNoSpaces); El ejemplo anterior mostrará los dos mensajes siguientes:
Extrayendo Cadenas Hay tres funciones de cadena que te permiten “extraer” una porción de una cadena, en vez de copiar la misma cadena entera. Estas funciones son String.Left, String.Right y String.Mid. String.Left copia un número de caracteres desde el comienzo de la cadena. String.Right hace lo mismo, pero contando desde el extremo derecho de la cadena. String.Mid te permite copiar un número de caracteres comenzando desde cualquier posición en la cadena. Puedes usar estas funciones para ejecutar todo tipo de operaciones avanzadas en cadenas Aquí está un ejemplo básico mostrando cómo trabajan estas funciones: strOriginal = "De verdad me da gusto verte de nuevo."; -- copia los primeros 22 caracteres dentro de strLeft strLeft = String.Left(strOriginal, 22); -- copia los últimos 15 caracteres dentro de strRight strRight = String.Right(strOriginal, 15); -- crea una nueva cadena con las dos piezas strNeo = String.Left .. "estupendo" .. strRight .. " Detente.";
38
-- copia la palabra "gusto" dentro de strMiddle strMiddle = String.Mid(strOriginal, 22, 5);
Convirtiendo Cadenas Numéricas a Números Puede haber ocasiones en que tengas una cadena numérica y necesites convertirla a un número. Por ejemplo, si tienes un campo de entrada donde el usuario pueda introducir su edad, y tú lees en el texto lo que él ha tecleado, podrías obtener un valor como “31”, puesto que el lo escribió. Aunque este valor es realmente una cadena que consta de los caracteres “3” y “1”. Si trataras de comparar este valor con un número, obtendrías un error de sintaxis diciendo que intentaste comparar un número con una cadena. Por ejemplo, si le asignaras el siguiente script al evento OnClick de un botón: edad = "31"; if edad > 18 then Dialog.Message("", "Eres mayor de 18."); end ...se produciría el siguiente mensaje de error:
El problema en este caso es que la línea dos del script compara el contenido de la variable “edad” con el número 18: if age > 18 then Esto genera un error porque edad contiene una cadena y no un número. El motor de script no te permite comparar números con cadenas de esta manera. No hay forma de saber si querías tratar age como un número, o tratar 18 como una cadena. La solución es simplemente convertir el valor de edad a un número antes de compararlo. Hay dos formas de hacer esto. Una forma es usar la función String.ToNumber. La función String.ToNumber convierte una cadena numérica a el número equivalente, de tal modo que pueda ser usado en una comparación numérica.
39
edad = "31"; if String.ToNumber(edad) > 18 then Dialog.Message("", "Tú eres mayor de 18."); end Lo que produciría un mensaje de diálogo como el siguiente:
La otra forma saca ventaja de la habilidad del motor de script para convertir números en cadenas cuando sabe cuáles son sus intenciones. Por ejemplo, si estás ejecutando una operación aritmética (tal como la suma de dos números), el motor automáticamente convertirá por ti cualquier cadena numérica a números: edad = "26" + 5; -- el resultado será un valor numérico El ejemplo anterior no generará ningún error porque el motor de script entiende que la única forma de que la declaración tenga sentido es que diste a entender que se usara la cadena numérica como un número. Como resultado, el motor automáticamente convierte la cadena numérica a un número de modo que se pueda ejecutar el cálculo. Sabiendo esto, podemos convertir una cadena numérica en un número sin cambiar su valor simplemente añadiendo un 0 en ella, tal como se muestra a continuación: edad = "31"; if (edad + 0) > 18 then Dialog.Message("", "Tú eres mayor de 18."); end En el ejemplo de anterior, el añadirle 0 a una variable, consigue que el motor convierta el valor a un número, y que el resultado luego sea comparado con 18. ¡Ya no habrá error!
40
Otras Funciones Incorporadas Funciones de Script Hay tres funciones incorporadas que te pueden ser de utilidad: dofile , require , y type.
dofile Carga y ejecuta un archivo de script. El contenido del archivo será ejecutado como si éste fuera escrito directamente dentro del script. La sintaxis es: dofile( file_path); Por ejemplo, digamos que escribimos el siguiente script dentro de un archivo llamado MyScript.lua (justamente un archivo de texto conteniendo este script, creado con el Wordpad de Windows o algún otro editor de texto). Es indispensable que guardes este archivo con la opción “Guardar como” de tu editor de texto y debes guardarlo como tipo “Texto sin Formato” o con la opción “Todos los archivos”, es decir, no lo guardes como .txt. Dialog.Message("Hola", "Mundo"); Ahora arrastramos y soltamos el archivo dentro de la ventana principal de AutoPlay Media Studio. (Esto copiará el archivo dentro de la carpeta Scripts de nuestro proyecto). Aparecerá un diálogo que pregunta si queremos añadir una línea require a nuestro script global. Por ahora haz click en “No”. Explicaremos la declaración require más tarde.
Ahora, donde sea que agreguemos la siguiente línea de script para un evento: dofile(_SourceFolder.."\\AutoPlay\\Scripts\\MyScript.lua"); … ese archivo de script será leido y ejecutado inmediatamente. En este caso, deberás ver un mensaje de diálogo con el mensaje amigable “Hola Mundo”.
41
Consejo: Utiliza la función dofile para ahorrarte tú mismo el tener que volver a escribir o volver a pegar un script dentro de tu proyecto una y otra vez.
require Carga y ejecuta un archivo de script dentro del motor de programación. Esta función es similar a la dofile , excepto que cargará un archivo dado una vez por sesión, mientras que dofile vuelve a cargar y vuelve a ejecutar el archivo cada vez que es usado. La sintaxis es: require( file_path); Así, por ejemplo, incluso si haces dos requerimientos en fila: require("foo.lua"); require("foo.lua"); -- esta línea no hará nada …sólo la primera línea será siempre ejecutada. Después de eso, el motor de programación sabe que el archivo ha sido cargado y ejecutado, y en el futuro llama para requerir que el archivo no tenga efecto. Date cuenta que siempre y cuando pongas el archivo .lua dentro de la carpeta Scripts de tu proyecto, ya no tienes que proporcionar una ruta completa del archivo. Por ejemplo: require("MyScript.lua"); ...es lo mismo que: require(_SourceFolder.."\\AutoPlay\\Scripts\\MyScript.lua"); Debido a que require solo cargará un archivo de script dado una vez por sesión, esto es lo más apropiado para cargar scripts que contienen sólo variables y funciones. Puesto que las variables y las funciones son globales por defecto, tú solamente necesitas “cargarlas” una vez; cargar reiteradas veces la misma definición de función sólo sería una pérdida de tiempo. Esto hace a la función require una gran forma de cargar librerías de script externas. Cada script que necesite una función desde un archivo externo puede con toda seguridad acudir a la función require , y el archivo realmente será cargado sólo la primera vez que sea necesitado.
type Esta function te dirá el tipo de valor contenido en una variable. Esta devuelve el nombre de la cadena del tipo de variable. Los valores válidos devueltos son “nil,” “number,” “string,” “boolean,” “table,” o “function”. Por ejemplo:
42
a = 989; strType = type(a); -- establece strType como "number" a = "Hola"; strType = type(a); -- establece strType como "string" El tipo de función es especialmente útil cuando escribes tus propias funciones que necesitan ciertos tipos de datos para poder operar. Por ejemplo, la siguiente función utiliza type() para asegurar que ambos de sus argumentos son números: -- encuentra el máximo de dos números function Max(Number1, Number2) -- asegura que ambos argumentos son numéricos if (type(Number1) ~= "number") or (type(Number2) ~= "number") then Dialog.Message("Error", "Please enter numbers"); return nil – estamos usando nil para indicar un error de condición else if Number1 >= Number2 then return Number1; else return Number2; end end end
Acciones AutoPlay Media Studio viene con un gran número de funciones incorporadas. En la interface del programa, estas funciones incorporadas son comúnmente referidas como actions (acciones) . Para propósitos de programación, acciones y funciones son esencialmente lo mismo; sin embargo, el término “acciones” está reservado generalmente para aquellas funciones que ye vienen incorporadas en el programa y son incluidas en la lista alfabética de acciones en la ayuda en línea. Cuando nos referimos a funciones que han sido creadas por otros usuarios o por ti mismo, el término “funciones” es preferido.
43
Depurando Tus Scripts El Scripting de Autoplay (o cualquier tipo de programación) es relativamente fácil una vez que te familiarices con él. Sin embargo, incluso los mejores programadores cometen errores, y necesitan “darle una planchadita” a las “arrugas ocasionales” de su código. El ser bueno para depurar scripts reducirá el tiempo para lanzar al mercado tus proyectos e incrementar la cantidad de tiempo de descanso. Por favor lee esta sección para obtener consejos en el uso de Auto Play Media Studio tan habilidosa y eficazmente como sea posible. Esta sección explicará los métodos de manipulación de errores, así como también cubrirá un buen número de técnicas de depuramiento.
Manipulación de Errores Todas las acciones incorporadas en AutoPlay Media Studio utilizan las mismas técnicas básicas de manipulación de errores. Sin embargo, esto no es necesariamente cierto para cualquier función, módulo o script hechos por terceros (incluso los scripts desarrollados por Indigo Rose Corporation que no están incorporados dentro del producto). Aunque estos scripts desarrollados externamente desde luego pueden hacer uso del sistema de manejo de errores del Autoplay, pueden necesariamente no hacerlo. Por consiguiente, deberías consultar siempre al autor o la documentación del script o del módulo para encontrar cómo se manipulan los errores. Hay dos tipos de errores que puedes tener en tus scripts cuando las acciones de AutoPlay Media Studio son llamadas: errores de sintaxis y errores operativos o funcionales.
Errores de Sintaxis Los errores de sintaxis ocurren cuando la sintaxis (o “gramática”) de un script es incorrecta, o una función recibe argumentos que no son apropiados. Algunos errores de sintaxis son detectados por AutoPlay Media Studio cuando construyes o previsualizas tu aplicación. Por ejemplo, considera el siguiente script: foo = Esto es incorrecto porque no hemos asignado nada a la variable foo (el script está incompleto). Este es un error de sintaxis bastante obvio, por lo que deberá ser detectado por el motor de programación en tiempo de construcción (cuando construyas tu proyecto). Otro tipo de error de sintaxis es cuando no le pasas el tipo o número correcto de argumentos a una función. Por ejemplo, si pruebas y ejecutas este script: Dialog.Message("Hola");
44
…el proyecto se construirá bien, debido a que no hay errores de sintaxis obvios en el script. Hasta donde el motor de programación pueda decir, la llamada de la función está bien formada. El nombre es válido, los paréntesis de abertura y cierre concuerdan, las comillas están en la posición correcta, e incluso hay un punto y coma de finalización de la línea. Todo se ve en orden. Sin embargo, en tiempo de ejecución verás algo como lo siguiente:
¡No se mira tan bien después de todo!, ¿verdad? Date cuenta que el mensaje dice que dos argumentos son requeridos por la función Dialog.Message. Ah, nuestro script sólo proporcionó un argumento. De acuerdo al prototipo de función para Dialog.Message, parece que la función puede incluso aceptar más de cinco argumentos:
Observando con atención el prototipo de función, vemos que los últimos tres argumentos tienen valores por defecto, los cuales serán utilizados si esos argumentos son omitidos de la llamada de función. Los primeros dos argumentos (Title y Text) no tienen valores por defecto, así que no pueden ser omitidos sin generar un error. Para no hacer larga la historia, está bien llamar la acción Dialog.Message con cualquiera de 2 a 5 argumentos… pero 1 argumento no es suficiente. Entonces, una sintaxis correcta podría ser: Dialog.Message("Hola", "Bienvenido"); Lo que tendría que mostrar un mensaje de diálogo como el que sigue:
45
Afortunadamente, errores de sintaxis como éste son usualmente detectados en tiempo de construcción o cuando pruebas tu aplicación. Usualmente los mensajes de error son bastante claros, haciendo fácil para ti localizar e identificar el problema
Errores Funcionales Los errores funcionales son aquellos que ocurren debido a que la funcionalidad de la acción en sí misma falla. Estos ocurren cuando a una acción se le da información incorrecta, tal como la ruta de 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 colocas ese script ahora mismo dentro de un evento y lo pruebas, verás que nada parece suceder. Esto se debe a que los errores funcionales de AutoPlay Media Studio no son automáticamente mostrados de la misma forma que los errores de sintaxis. Te dejamos a tu elección manipular (o el dejarlos así) estos errores funcionales. La razón de esto es que puede haber ocasiones en que no te importa si una función falla. De hecho, podría esperarse así. Por ejemplo, el siguiente código intenta eliminar una carpeta llamada C:\Mi Carpeta Temporal: Folder.Delete("C:\\ Mi Carpeta Temporal "); Sin embargo, en este caso no te importa si realmente se consigue borrarla, o si, en primer lugar, la carpeta ni existía. Tú solamente quieres asegurarte que si esa carpeta en particular existe, será borrada. Si la carpeta no existía, la acción Folder.Delete causa un error funcional debido a que no puedes encontrar la carpeta que tú le dijiste que borrara… pero puesto que el resultado final es exactamente lo que tú querías, no necesitas hacer nada al respecto. Y ciertamente no quieres que el usuario vea ningún mensaje de error. Contrariamente, puede haber ocasiones en que es muy importante para ti saber si una acción falla. Dicho por ejemplo que quieres copiar un archivo muy importante: File.Copy("C:\\Temp\\Mi Archivo.dat","C:\\Temp\\Mi Archivo.bak"); En este caso, realmente quieres saber si esto falla y poder incluso cerrar el programa o informarle al usuario. Aquí es donde las acciones de depuración te echan una mano. Continúa leyendo sobre Acciones de Depuración en la siguiente página…
46
Acciones de Depuración AutoPlay Media Studio viene con algunas funciones muy útiles para depurar tus aplicaciones. En esta sección les echaremos un vistazo a algunas de ellas.
Application.GetLastError Esta es la acción más importante a usar cuando se trata de averiguar si ha ocurrido un problema. En tiempo de ejecución siempre hay un valor interno que almacena el estado de la última acción que fue ejecutada. Al inicio de una acción, este valor es fijado en 0 (el número cero). Esto significa que todo está bien. Si un error funcional ocurre dentro de la acción, el valor es cambiado a algún valor distinto de cero. A este último valor de error se puede acceder en cualquier momento utilizando la acción Application.GetLastError. La sintaxis es: last_error_code = Application.GetLastError();
Aquí está un ejemplo que utiliza esta acción: File.Copy("C:\\Temp\\Mi Archivo.dat","C:\\Temp\\Mi Archivo.bak"); error_code = Application.GetLastError(); if (error_code ~= 0) then -- ¡algún tipo de error ha ocurrido! Dialog.Message("Error", "Error en copia de archivo: "..error_code); Application.Exit(); end El ejemplo anterior informará al usuario que un error ha ocurrido y luego cerrará la aplicación. Esta no es necesariamente la forma en que todos los errores serán manejados, pero ilustra el punto. Puedes hacer lo que quieras cuando un error ocurra, como llamar una función diferente o cualquier otra cosa que puedas idear. El ejemplo anterior tiene un posible problema. Imagina que el usuario ve un mensaje como éste:
Para el usuario sería mucho más agradable que se mostrara alguna información acerca del problema exacto. Bueno, estás de suerte. En tiempo de ejecución hay una tabla
47
llamada _tblErrorMessages que contiene todos los posibles mensajes de error, indexada por los códigos de error. Puedes utilizar fácilmente el último número de error para obtener un mensaje de error actual que le dará más sentido al usuario del que le da un número como “1021”. Por ejemplo, aquí tenemos un script modificado para mostrar la cadena de error actual: File.Copy("C:\\Temp\\Mi Archivo.dat","C:\\Temp\\Mi Archivo.bak"); error_code = Application.GetLastError(); if (error_code ~= 0) then -- ¡algún tipo de error ha ocurrido! Dialog.Message("Error", "Error en copia de archivo: " .. _tblErrorMessages[error_code]); Application.Exit(); end Ahora el script producirá el siguiente mensaje de error:
¡La información es mucho más clara ahora! Sólo recuerda que el valor del último error se reanuda cada vez que una acción es ejecutada. Por ejemplo, el siguiente script no producirá un mensaje de error: File.Copy("C:\\Temp\\Mi Archivo.dat","C:\\Temp\\Mi Archivo.bak"); -- En este punto Application.GetLastError() podría no ser cero, pero... Dialog.Message("Qué tal","Hola Mundo"); -- Ups, ahora el número del último error será para la acción Dialog.Message, -- y no para la acción File.Copy. La acción Dialog.Message reajustará el -- número del último error a 0, y las siguientes líneas no percibirán ningún -- error que haya sucedido en la acción File.Copy. error_code = Application.GetLastError(); if (error_code ~= 0) then -- ¡Algún tipo de error ha ocurrido! Dialog.Message("Error", "Error en copia de archivo: ".. _tblErrorMessages[error_code]);
48
Application.Exit(); end
Debug.ShowWindow El tiempo de ejecución en AutoPlay Media Studio tiene la habilidad de mostrar una ventana de depuración que puede ser utilizada para mostrar mensajes depurados. Esta ventana existe durante toda la ejecución de tu aplicación, pero estará sólo visible cuando tú le indiques. La sintaxis es: Debug.ShowWindow(show_window); ...donde show_window es un valor Booleano. Si es true, la ventana de depuración es mostrada, y si es false, la ventana se ocultará. Por ejemplo: -- muestra la ventana de depuración Debug.ShowWindow(true); Si llamas este script, la ventana de depuración aparecerá encima de tu aplicación, pero ninguna otra cosa realmente sucederá. Aquí es donde las siguientes acciones Debug vienen.
Debug.Print Esta acción muestra el texto de tu elección en la ventana de depuración. Por ejemplo, prueba el siguiente script: Debug.ShowWindow(true); for i = 1, 10 do Debug.Print("i = " .. i .. "\r\n"); end La parte “\r\n” es, de hecho, dos secuencias de escape que están siendo utilizadas para iniciar una nueva línea. (Esto es técnicamente llamado un par “cambio de línea/alimentación de línea”). Puedes usar \r\n en la ventana de depuración en el momento que desees insertar una nueva línea. El script anterior producirá la siguiente salida en la ventana de depuración:
49
Puedes usar este método para mostrar todo tipo de información en la ventana de depuración. Algunos usos típicos son mostrar el contenido de una variable de modo que puedas ver qué contiene en tiempo de ejecución, o mostrar tus propios mensajes de depuración como “inside outer for loop” (“interno externo para bucle”) o “foo() function started” (“foo() función iniciada”). Tales mensajes crean un rastro como migajas de pan que puedes rastrear para entender qué está sucediendo detrás de las escenas de tu proyecto. Estos pueden ser invaluables a la hora de depurar tus scripts o probar tu último algoritmo.
Debug.SetTraceMode AutoPlay Media Studio puede correr en un modo especial “trace” en tiempo de ejecución que mostrará información acerca de cada línea de script que es ejecutada en la ventana de depuración, incluyendo el valor de Application.GetLastError() si la línea implica el llamado de una acción incorporada. Puedes activar o desactivar este modo “trace” usando la acción Debug.SetTraceMode. Debug.SetTraceMode(turn_on); ...donde turn_on es un valor Booleano que le dice al programa que apague o encienda el modo “trace”. Aquí está un ejemplo: Debug.ShowWindow(true); Debug.SetTraceMode(true); for i = 1, 3 do Dialog.Message("Número", i); end File.Copy("C:\\fake_file.ext", "C:\\fake_file.bak");
50
Al ejecutar este script se producirá la siguiente salida en la ventana de depuración:
Nota que cada línea producida por el modo trace inicia con “TRACE:”. Esto es así para que puedas distinguirlas de otras líneas que mandes a la ventana de depuración con Debug.Print. El número después de la parte “TRACE:” es el número de línea que está siendo ejecutado actualmente en el script. Activar el modo trace es algo que probablemente no querrás hacer en tu aplicación distribuible final, pero realmente puede ayudar a encontrar problemas durante el desarrollo de tu proyecto. De hecho, hay una opción en las preferencias de construcción de AutoPlay Media Studio que te permite activar automáticamente el modo trace cada vez que tu lo previsualices. (Elige Edit > Preferences y haz click en la categoría Build. En la sección Preview, activa la opción llamada “Show Debug Window”). Sin embargo, incluso con esta opción habilitada, el modo trace no estará activado en la versión que construyas cuando publiques tu proyecto, a menos que tú específicamente lo actives en tu script
Debug.GetEventContext Esta acción es utilizada para obtener una cadena descriptiva acerca del evento que está siendo ejecutado actualmente. Esto puede ser útil si defines una función en un lugar pero la llamas desde algún otro, y quieres ser capaz de decir desde dónde está siendo llamada la función en cualquier momento dado. Por ejemplo, si ejecutas este script desde el evento de un botón en la Página 1: Dialog.Message("Event Context", Debug.GetEventContext()); ...verás algo como esto:
51
Dialog.Message Esta acción nos ayuda a mostrar mensajes de diálogo. Ya has visto el uso de esta acción a lo largo de este documento, y por buenas razones. Esta es una gran acción que utilizamos mucho en nuestros códigos cuando estamos tratando de seguirle la pista a un problema.
52
Conceptos Finales Esperamos que este documento te haya ayudado a entender la programación en AutoPlay Media Studio. Una vez que te familiarices con ella, es realmente una divertida y poderosa forma de lograr realizar cosas.
Otros Recursos Aquí está una lista de otros lugares en los que puedes obtener ayuda con la programación en AutoPlay Media Studio.
Archivo de Ayuda (Help File) El Archivo de Ayuda de AutoPlay Media Studio está empaquetado con buen material de referencia para todas las acciones y eventos soportados en AutoPlay Media Studio, y para el ambiente de diseño mismo. Puedes acceder al archivo de ayuda en cualquier momento eligiendo el menú Help > AutoPlay Media Studio Help. Otro consejo útil: si estás en el editor de script y quieres aprender más acerca de una acción, simplemente haz click en la acción y oprime la tecla F1 de tu teclado.
Guía del Usuario (User’s Guide) La Guía del Usuario es una fantástica manera de iniciar con AutoPlay Media Studio. Está escrita con un formato de tutorial fácil de seguir, enseñándote acerca de eventos, acciones y scripts. Estarás capacitado en poco tiempo. Puedes acceder a la Guía del Usuario eligiendo el menú Help > AutoPlay Media Studio User's Guide.
Sitio Web de AutoPlay Media Studio El sitio Web de AutoPlay Media Studio está localizado en http://www.indigorose.com. Asegúrate revisar el foro de usuarios donde puedes leer preguntas y respuestas de usuarios y del equipo de Indigo Rose así como hacer tus propias preguntas. Una forma rápida de acceder a los foros en línea es elegir el menú Help > User Forums.
Soporte Técnico de Indigo Rose Si necesitas ayuda con cualquier concepto de programación o tienes un bloqueo mental para llevar a cabo algo, siéntete libre de visitar http://support.indigorose.com. Aunque nosotros no podemos escribir un script por ti o depurar tus propios scripts, estaremos felices de responder cualquier pregunta en general que tengas.
El Sitio Web Lua El motor de programación de AutoPlay está basado en un popular lenguaje de programación llamado Lua. Lua está diseñado e implementado por un equipo de Tecgraf, la Computer Graphics Technology Group of PUC-Rio (en la Universidad
53
