Adobe Guía de Consulta de ActionScript User Manual [es]

®
ma cromedia
FLASH™5
Guía de Consulta de ActionScript
Marcas comerciales
Macromedia, el logotipo de Macromedia, el logotipo de Made With Macromedia, Authorware, Backstage, Director, Extreme 3D y Fontographer son marcas comerciales registradas. Afterburner, AppletAce, Authorware Interactive Studio, Backstage, Backstage Designer, Backstage Desktop Studio, Backstage Enterprise Studio, Backstage Internet Studio, DECK II, Director Multimedia Studio, Doc Around the Clock, Extreme 3D, Flash, FreeHand, FreeHand Graphics Studio, Lingo, Macromedia xRes, MAGIC, Power Applets, Priority Access, SoundEdit, Shockwave, Showcase, Tools to Power Your Ideas y Xtra son marcas comerciales de Macromedia, Inc. Otros nombres de productos, logotipos, diseños, títulos, palabras o frases mencionados en esta publicación pueden ser marcas comerciales, marcas de servicio o nombres registrados de Macromedia, Inc. o de otras entidades y pueden estar registrados en ciertas jurisdicciones.
Limitación de garantías de Apple APPLE COMPUTER, INC. NO GARANTIZA, DE FORMA EXPRESA NI IMPLÍCITA, LA COMERCIABILIDAD
O IDONEIDAD PARA UN FIN DETERMINADO DEL PAQUETE DE SOFTWARE INFORMÁTICO INCLUIDO. LA EXCLUSIÓN DE GARANTÍAS IMPLÍCITAS NO ESTÁ PERMITIDA EN ALGUNOS ESTADOS. LA RESTRICCIÓN ANTERIOR PUEDE NO AFECTARLE. ESTA GARANTÍA LE PROPORCIONA DERECHOS LEGALES ESPECÍFICOS. PUEDE TENER OTROS DERECHOS QUE VARÍAN SEGÚN LA LEGISLACIÓN LOCAL.
Copyright © 2000 Macromedia, Inc. Todos los derechos reservados. No se permite la copia, fotocopia, reproducción, traducción o conversión mediante ningún medio electrónico o mecánico, ya sea de forma total o parcial, sin la previa autorización por escrito de Macromedia, Inc. Nº de pieza ZFL50M200SP
Agradecimientos
Gestión del proyecto: Erick Vera
Redacción: Jody Bleyle, Mary Burger, Louis Dobrozensky, Stephanie Gowin, Marcelle Taylor y Judy Walthers Von Alten
Edición: Peter Fenczik, Rosana Francescato, Ann Szabla
Multimedia: George Brown, John “Zippy” Lehnus y Noah Zilberberg
Diseño de Ayuda e impresión: Chris Basmajian y Noah Zilberberg
Producción: Chris Basmajian y Rebecca Godbois
Gestión del proyecto de localización: Yuko Yagi
Producción de localización: Masayo “Noppe” Noda y Bowne Global Solutions
Agradecimiento especial a: Pablo Francisco Arrieta, Jeremy Clark, Brian Dister y todo el Grupo de Desarrollo de Flash, Michael Dominguez, Margaret Dumas, Rosa Elva Elizondo, Sherri Harte, Yoshika Hedberg, Tim Hussey, Kipling Inscore, Alyn Kelley, Pete Santangeli, Denise Seymour y todo el Grupo de Control de calidad de Flash, Cyn Taylor y Eric Wittman
Primera edición: Septiembre de 2000
Macromedia, Inc. 600 Townsend St. San Francisco, CA 94103 (EE.UU.)
2
TABLE DES MATIÈRES
INTRODUCTION
Procedimientos iniciales . . . . . . . . . . . . . . . . . . . . . . . . 17
Novedades en el lenguaje ActionScript de Flash 5 . . . . . . . . . . . . . . . . 17
Diferencias entre ActionScript y JavaScript . . . . . . . . . . . . . . . . . 18
Edición de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Sintaxis de punto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Funciones definidas por el usuario . . . . . . . . . . . . . . . . . . . . . . . . 19
Objetos predefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Acciones de clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Acciones nuevas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Clips inteligentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Compatibilidad con XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Optimización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Utilización de la Ayuda de Flash
para acciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
CAPÍTULO 1
El lenguaje ActionScript . . . . . . . . . . . . . . . . . . . . . . . .23
Creación de scripts en ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Planificación y depuración de scripts . . . . . . . . . . . . . . . . . . . . . . 25
Creación de scripts orientados a objetos . . . . . . . . . . . . . . . . . . . 26
Objeto MovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Flujo de los scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Control de la ejecución de ActionScript . . . . . . . . . . . . . . . . . . . . 31
Terminología de ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Análisis de un script de ejemplo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3
Utilización del panel Acciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Modo Normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38
Modo Experto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
Cambio del modo de edición . . . . . . . . . . . . . . . . . . . . . . . . . . . .41
Utilización de un editor externo. . . . . . . . . . . . . . . . . . . . . . . . . . .42
Selección de opciones en el panel Acciones . . . . . . . . . . . . . . . . . .42
Realzado y comprobación de la sintaxis . . . . . . . . . . . . . . . . . . . . .44
Realzado de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45
Asignación de acciones a los objetos . . . . . . . . . . . . . . . . . . . . . . . . . . .46
Asignación de acciones a fotogramas . . . . . . . . . . . . . . . . . . . . . . . . . .48
CAPÍTULO 2
Programación de Scripts en ActionScript. . . . . . . . 51
Utilización de la sintaxis de ActionScript. . . . . . . . . . . . . . . . . . . . . . . .52
Tipos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Acerca de las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59
Utilización de operadores para manipular los valores de las expresiones.64
Uso de acciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
Control de los scripts de flujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73
Utilización de las funciones predefinidas . . . . . . . . . . . . . . . . . . . . . . . .76
Creación de funciones personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . .78
Utilización de objetos predefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . .81
Utilización de objetos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . .85
Apertura de archivos de Flash 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Utilización de Flash 5 para crear contenidos de Flash 4 . . . . . . . . . . . . .89
Table des Matières
4
CAPÍTULO 3
Interactividad con ActionScript . . . . . . . . . . . . . . . . . 91
Creación de un cursor personalizado . . . . . . . . . . . . . . . . . . . . . . . . . .92
Obtención de la posición del ratón . . . . . . . . . . . . . . . . . . . . . . . . . . . .94
Captura de presión de una tecla . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Creación de un campo de texto desplazable . . . . . . . . . . . . . . . . . . . . .97
Establecimiento de los valores de color . . . . . . . . . . . . . . . . . . . . . . . .100
Creación de controles de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102
Detección de colisiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105
CAPÍTULO 4
Trabajo con clips de película . . . . . . . . . . . . . . . . . . .109
Líneas de tiempo múltiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110
Relación jerárquica de las Líneas de tiempo . . . . . . . . . . . . . . . . .112
Envío de mensajes entre Líneas de tiempo . . . . . . . . . . . . . . . . . .114
Rutas de destino absolutas y relativas . . . . . . . . . . . . . . . . . . . . . .117
Especificación de rutas de destino . . . . . . . . . . . . . . . . . . . . . . . .121
Utilización de acciones y métodos para controlar Líneas de tiempo . .124
Acerca de métodos versus acciones . . . . . . . . . . . . . . . . . . . . . . . .125
Utilización de varios métodos o acciones para seleccionar como desti-
no a una Línea de tiempo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
Asignación de una acción o método . . . . . . . . . . . . . . . . . . . . . . .127
Carga y descarga de películas adicionales . . . . . . . . . . . . . . . . . . .128
Cambio de posición y aspecto de clips de película . . . . . . . . . . . .128
Clips de película que se pueden arrastrar . . . . . . . . . . . . . . . . . . .129
Duplicación y eliminación de clips de película . . . . . . . . . . . . . .130
Anexión de clips de película . . . . . . . . . . . . . . . . . . . . . . . . . . . .130
Creación de clips inteligentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
Definición de los parámetros de clip . . . . . . . . . . . . . . . . . . . . . .132
CAPÍTULO 5
Integración de Flash con aplicaciones Web . . . . . 139
Envío y carga de variables a y desde un archivo remoto . . . . . . . . . . .140
Utilización de loadVariables, getURL y loadMovie . . . . . . . . . . .144
Lenguaje XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Utilización del objeto XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146
Utilización del objeto XMLSocket . . . . . . . . . . . . . . . . . . . . . . . .150
Creación de formularios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .152
Creación de un formulario de búsqueda. . . . . . . . . . . . . . . . . . . .153
Utilización de variables en formularios. . . . . . . . . . . . . . . . . . . . .154
Verificación de datos introducidos . . . . . . . . . . . . . . . . . . . . . . . .155
Envío de mensajes desde y hasta el Reproductor de Flash. . . . . . . . . .156
Utilización de fscommand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .156
Acerca de los métodos de Flash Player . . . . . . . . . . . . . . . . . . . . .159
Table des Matières
5
CAPÍTULO 6
Solución de problemas de ActionScript . . . . . . . . .161
Directrices para la creación y solución de problemas . . . . . . . . . . . . . .162
Utilización del Depurador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .164
Habilitación de la depuración de películas . . . . . . . . . . . . . . . . . .165
La barra de estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166
La lista de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166
Visualización y modificación de variables. . . . . . . . . . . . . . . . . . .166
Utilización de la lista Observar. . . . . . . . . . . . . . . . . . . . . . . . . . .168
Visualización de las propiedades de las películas y modificación de las
propiedades editables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
Utilización de la ventana Salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . .170
Utilización del comando Mostrar objetos . . . . . . . . . . . . . . . . . .171
Utilización del comando Mostrar variables . . . . . . . . . . . . . . . . .172
Utilización de la acción trace . . . . . . . . . . . . . . . . . . . . . . . . . . . .173
CAPÍTULO 7
Diccionario de ActionScript. . . . . . . . . . . . . . . . . . . . 175
Entrada de muestra para la mayoría de los elementos de ActionScript .176
Entrada de muestra para objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .177
Contenido del diccionario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .178
–– (disminución) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191
++ (incremento) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191
! (valor NOT lógico) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193
!= (no igualdad). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193
% (módulo) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .194
%= (asignación de módulo). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .195
& (operador AND como bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .195
&& (operador AND de cortocircuito) . . . . . . . . . . . . . . . . . . . . . . . .196
&= (operador de asignación AND como bit) . . . . . . . . . . . . . . . . . . .196
() (paréntesis) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197
– (menos) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .198
* (multiplicación) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .199
*= (asignación de multiplicación) . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
, (coma). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
. (operador punto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201
?: (condicional) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202
/ (división) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202
// (delimitador de comentario) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203
Table des Matières
6
/* (delimitador de comentario) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203
/= (asignación de división). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .204
[] (operador de acceso a matriz). . . . . . . . . . . . . . . . . . . . . . . . . . . . . .205
^(operador XOR como bit). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .206
^= (operador de asignación XOR como bit) . . . . . . . . . . . . . . . . . . . .206
{} (inicializador de objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207
| (operador OR como bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .208
|| (operador OR) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .209
|= (operador de asignación OR como bit) . . . . . . . . . . . . . . . . . . . . . .209
~ (operador NOT como bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210
+ (suma) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210
+= (asignación de suma) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .211
< (menor que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .212
<< (desplazamiento a la izquierda como bit) . . . . . . . . . . . . . . . . . . . .213
<< (desplazamiento a la izquierda como bit y asignación) . . . . . . . . . .214
<= (menor o igual que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .215
<> (no igualdad) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .215
= (asignación) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .216
-= (asignación de negación) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .217
== (igualdad). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218
> (mayor que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218
>= (mayor o igual que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .219
>> (desplazamiento a la derecha como bit) . . . . . . . . . . . . . . . . . . . . .220
>>= (desplazamiento a la derecha como bit y asignación) . . . . . . . . . .221
>>> (desplazamiento a la derecha como bit sin signo) . . . . . . . . . . . . .222
>>>= (desplazamiento a la derecha como bit sin signo y asignación) . .222
add . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .223
_alpha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224
and . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224
Array (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .225
Array.concat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227
Array.join . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227
Array.length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .228
Array.pop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229
Array.push. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229
Array.reverse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230
Array.shift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230
Array.slice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Array.sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Array.splice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233
Table des Matières
7
Array.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233
Array.unshift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234
Boolean (función) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234
Boolean (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234
Boolean.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235
Boolean.valueOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .236
break. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .236
call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237
chr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237
Color (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .238
Color.getRGB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .239
Color.getTransform. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .239
Color.setRGB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .240
Color.setTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .240
continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242
_currentframe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242
Date (objeto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .243
Date.getDate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246
Date.getDay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246
Date.getFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247
Date.getHours. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247
Date.getMilliseconds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248
Date.getMinutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248
Date.getMonth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248
Date.getSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .249
Date.getTime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .249
Date.getTimezoneOffset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .249
Date.getUTCDate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .250
Date.getUTCDay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .250
Date.getUTCFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251
Date.getUTCHours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251
Date.getUTCMilliseconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251
Date.getUTCMinutes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252
Date.getUTCMonth. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252
Date.getUTCSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252
Date.getYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253
Date.setDate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253
Date.setFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253
Date.setHours. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .254
Date.setMilliseconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .254
Table des Matières
8
Date.setMinutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255
Date.setMonth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255
Date.setSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255
Date.setTime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256
Date.setUTCDate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256
Date.setUTCFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256
Date.setUTCHours. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257
Date.setUTCMilliseconds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257
Date.setUTCMinutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258
Date.setUTCMonth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258
Date.setUTCSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258
Date.setYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259
Date.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259
Date.UTC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .260
delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .260
do...while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262
_droptarget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263
duplicateMovieClip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .264
else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
eq (equal—string specific) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
escape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .266
eval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .266
evaluate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267
_focusrect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268
for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268
for...in. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .270
_framesloaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .271
fscommand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272
function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272
ge (mayor o igual que, específico de cadena) . . . . . . . . . . . . . . . . . . . .274
getProperty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .274
getTimer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .275
getURL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .275
getVersion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .276
gotoAndPlay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277
gotoAndStop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277
gt (greater than —string specific) . . . . . . . . . . . . . . . . . . . . . . . . . . . .278
_height . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .278
_highquality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279
if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279
Table des Matières
9
ifFrameLoaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .280
#include . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .280
Infinity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
int. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
isFinite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
isNaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .282
Key (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .283
Key.BACKSPACE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285
Key.CAPSLOCK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285
Key.CONTROL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285
Key.DELETEKEY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286
Key.DOWN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286
Key.END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286
Key.ENTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287
Key.ESCAPE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287
Key.getAscii. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287
Key.getCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288
Key.HOME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288
Key.INSERT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288
Key.isDown. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289
Key.isToggled . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289
Key.LEFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289
Key.PGDN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290
Key.PGUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290
Key.RIGHT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290
Key.SHIFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291
Key.SPACE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291
Key.TAB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291
Key.UP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292
le (menor o igual que—específico de cadena) . . . . . . . . . . . . . . . . . . .292
length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292
_level. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .293
loadMovie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .294
loadVariables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
lt (menor que, específico de cadena) . . . . . . . . . . . . . . . . . . . . . . . . . .297
Matemáticas (objeto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .297
Math.abs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299
Math.acos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299
Math.asin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300
Math.atan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300
Table des Matières
10
Math.atan2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301
Math.ceil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301
Math.cos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301
Math.E . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .302
Math.exp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .302
Math.floor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303
Math.log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303
Math.LOG2E . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303
Math.LOG10E . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304
Math.LN2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304
Math.LN10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305
Math.max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305
Math.min . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305
Math.PI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306
Math.pow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306
Math.random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307
Math.round . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307
Math.sin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307
Math.sqrt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308
Math.SQRT1_2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308
Math.SQRT2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309
Math.tan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309
maxscroll. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309
mbchr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310
mblength . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310
mbord. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311
mbsubstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311
Mouse (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .312
Mouse.hide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .312
Mouse.show . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .313
MovieClip (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .313
MovieClip.attachMovie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315
MovieClip.duplicateMovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315
MovieClip.getBounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .316
MovieClip.getBytesLoaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .317
MovieClip.getBytesTotal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .317
MovieClip.getURL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .318
MovieClip.globalToLocal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .318
MovieClip.gotoAndPlay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .319
MovieClip.gotoAndStop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .319
Table des Matières
11
MovieClip.hitTest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .320
MovieClip.loadMovie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .321
MovieClip.loadVariables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322
MovieClip.localToGlobal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .323
MovieClip.nextFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324
MovieClip.play . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324
MovieClip.prevFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324
MovieClip.removeMovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .325
MovieClip.startDrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .325
MovieClip.stop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326
MovieClip.stopDrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326
MovieClip.swapDepths. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326
MovieClip.unloadMovie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327
_name. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327
NaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328
ne (no igual, específico de cadena). . . . . . . . . . . . . . . . . . . . . . . . . . . .328
new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328
newline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .329
nextFrame. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .330
nextScene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .330
not . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
Number (función). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .332
Number (objeto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .332
Number.MAX_VALUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .334
Number.MIN_VALUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .334
Number.NaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .335
Number.NEGATIVE_INFINITY . . . . . . . . . . . . . . . . . . . . . . . . . . .335
Number.POSITIVE_INFINITY . . . . . . . . . . . . . . . . . . . . . . . . . . . .335
Number.toString. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .336
Number.valueOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .336
Object (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .337
Object.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338
Object.valueOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338
onClipEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338
on(mouseEvent) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .340
or . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342
ord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342
_parent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342
parseFloat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .343
Table des Matières
12
parseInt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .344
play. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345
prevFrame. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345
prevScene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346
print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346
printAsBitmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348
_quality. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .349
random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .350
removeMovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .350
return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .351
_root. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .351
_rotation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .352
scroll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353
Selection (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353
Selection.getBeginIndex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .354
Selection.getCaretIndex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .354
Selection.getEndIndex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .355
Selection.getFocus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .355
Selection.setFocus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356
Selection.setSelection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356
set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356
setProperty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .357
Sound (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .358
Sound.attachSound. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .359
Sound.getPan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .360
Sound.getTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .360
Sound.getVolume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361
Sound.setPan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361
Sound.setTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .362
Sound.setVolume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365
Sound.start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365
Sound.stop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .366
_soundbuftime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .366
startDrag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .367
stop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368
stopAllSounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368
stopDrag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .369
String (función). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .369
" " (delimitador de cadena) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .370
Cadena (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .371
Table des Matières
13
String.charAt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373
String.charCodeAt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373
String.concat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373
String.fromCharCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374
String.indexOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374
String.lastIndexOf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374
String.length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375
String.slice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375
String.split . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .376
String.substr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .376
String.substring. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377
String.toLowerCase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377
String.toUpperCase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378
substring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378
_target. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378
targetPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379
tellTarget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379
this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .380
toggleHighQuality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .381
_totalframes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .382
trace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .382
typeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .383
unescape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .384
unloadMovie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .384
updateAfterEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .385
_url. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .386
var. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .386
_visible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .386
void. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387
while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387
_width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389
with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389
_x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .392
XML (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .393
XML.appendChild . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .395
XML.attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .396
XML.childNodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .397
XML.cloneNode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .397
XML.createElement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .398
XML.createTextNode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .398
Table des Matières
14
XML.docTypeDecl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .399
XML.firstChild . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .400
XML.haschildNodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .400
XML.insertBefore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .401
XML.lastChild . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .401
XML.load . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .402
XML.loaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .402
XML.nextSibling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .403
XML.nodeName. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .403
XML.nodeType. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .404
XML.nodeValue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .404
XML.onLoad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .405
XML.parentNode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .406
XML.parseXML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .406
XML.previousSibling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .406
XML.removeNode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .407
XML.send. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .407
XML.sendAndLoad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .407
XML.status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .408
XML.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .409
XML.xmlDecl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .409
XMLSocket (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .410
XMLSocket.close . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .412
XMLSocket.connect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .413
XMLSocket.onClose . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .414
XMLSocket.onConnect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .415
XMLSocket.onXML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .416
XMLSocket.send. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .417
_xmouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .418
_xscale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .418
_y . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .419
_ymouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .420
_yscale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .420
Table des Matières
15
APÉNDICE A
Precedencia de operadores y asociatividad . . . . . 421
Lista de operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .421
APÉNDICE B
Teclas del teclado y valores de códigos de tecla 425
Letras de la A a la Z y números estándar del 0 al 9 . . . . . . . . . . . . . . .426
Teclas del teclado numérico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .428
Teclas de función. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .429
Otras teclas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .430
APÉNDICE C
Mensajes de error . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Table des Matières
16

INTRODUCTION

Procedimientos iniciales

.............................................................................................................
ActionScript es el lenguaje de creación de scripts de Flash. Puede utilizar ActionScript para controlar objetos en las películas de Flash con el fin de crear elementos interactivos y de navegación y para ampliar Flash con el fin de crear películas altamente interactivas y aplicaciones Web.
Novedades en el lenguaje ActionScript de Flash 5
El lenguaje ActionScript de Flash 5 ofrece nuevas funciones muy interesantes para la creación de sitios Web interactivos con juegos, formularios, encuestas e interactividad en tiempo real sofisticadas como los sistemas de chat.
ActionScript de Flash 5 tiene muchas funciones y convenciones de sintaxis nuevas que lo hacen similar en lo fundamental al lenguaje de programación JavaScript. En este manual se explicarán los conceptos básicos de programación como funciones, variables, sentencias, operadores, condicionales y bucles. El Capítulo 7 de esta manual, “Diccionario de ActionScript”, contiene entradas detalladas para cada elemento de ActionScript.
En este manual no se pretende enseñar programación en general. Existen muchos recursos disponibles que proporcionan información sobre los conceptos generales de programación y sobre el lenguaje JavaScript.
17
La Asociación de Fabricantes de PCs Europea (ECMA, European Computers Manufacturers Association) publicó un documento llamado ECMA-262 que se deriva de JavaScript y que sirve como el estándar internacional para el lenguaje JavaScript. ActionScript está basado en la especificación ECMA-262 que se encuentra disponible en http://www.ecma.ch.
Netscape DevEdge Online tiene un centro de desarrollo de JavaScript (JavaScript Developer Central http://developer.netscape.com/tech/javascript/index.html) que contiene documentación y artículos útiles para comprender ActionScript. El recurso más valioso es el manual Core JavaScript Guide que se encuentra en la dirección http://developer.netscape.com/docs/manuals/js/core/jsguide/index.htm.
Diferencias entre ActionScript y JavaScript
No es necesario que conozca JavaScript para utilizar y aprender ActionScript. Sin embargo, si ya conoce JavaScript, ActionScript le parecerá familiar. Algunas de las diferencias entre ActionScript y JavaScript se detallan a continuación:
ActionScript no admite objetos específicos de navegador como Documento, Ventana y Ancla.
ActionScript no admite por completo todos los objetos predefinidos
de JavaScript.
ActionScript admite las construcciones sintácticas que no se permiten en JavaScript (por ejemplo, las acciones
tellTarget
ifFrameLoaded
y
y la
sintaxis de barras).
ActionScript no admite algunas de las construcciones sintácticas de JavaScript, como los rótulos
ActionScript no admite el constructor de JavaScript
En ActionScript, la acción de variables
En JavaScript, compatibilidad con Flash 4,
En JavaScript, evaluar
. En Flash 5, por compatibilidad con Flash 4 , evaluar
NaN
switch, continue, try, catch, throw
solamente puede realizar referencias
eval
.
toString
undefined
de
undefined toString
es
de
undefined
en un contexto numérico da como resultado
undefined
statement
y
Function
.
. En Flash 5, para su
es
.
" "
undefined
da como
.
resultado 0.
ActionScript no admite Unicode; admite ISO-8859-1 y conjuntos de
caracteres Shift-JIS.
18
Introduction
Edición de texto
Puede introducir scripts directamente en el panel Acciones en Modo Experto. También puede elegir elementos de un menú emergente o de una lista de la Caja de herramientas como lo hacía en Flash 4.
Sintaxis de punto
Puede utilizar la sintaxis de punto para obtener y establecer las propiedades y los métodos de un objeto, incluidas instancias y variables de clip de película. Puede utilizar la sintaxis de punto en lugar de la sintaxis de barras que se utilizaba en Flash 4. Ya no se utiliza la sintaxis de barras, pero aún la admite Flash Player.
Tipos de datos
El lenguaje ActionScript de Flash 5 admite los siguientes tipos de datos: cadena, número, booleano, objeto y clip de película. Los distintos tipos de datos le permiten utilizar diferentes tipos de información en ActionScript. Por ejemplo, puede crear matrices y matrices asociativas.
Variables locales
Puede declarar variables locales que expiran al final de la lista de acciones o de la llamada de función. Esto le permite gestionar la memoria y volver a utilizar los nombres de variables. Todas las variables de Flash 4 eran permanentes; incluso las variables temporales como los contadores de bucle que permanecían en la película hasta que finalizaba.
Funciones definidas por el usuario
Puede definir funciones con parámetros que devuelven valores. Esto le permite volver a utilizar los bloques de código en los scripts. En Flash 4, podía volver a utilizar el código mediante la acción
pero no podía pasar parámetros ni
call
devolver valores.
Procedimientos iniciales
19
Objetos predefinidos
Puede utilizar los objetos predefinidos para acceder y manipular ciertos tipos de información. A continuación se muestran algunos de los objetos predefinidos:
El objeto Math dispone de un complemento completo de constantes y
funciones matemáticas integradas como E (constante de Euler), y
(arco tangente).
atan
El objeto Date le permite obtener información sobre la fecha y la hora del
(Coseno),
cos
sistema en el que se esté ejecutando Flash Player.
El objeto Sound le permite agregar sonidos a una película y controlar los sonidos en una película a medida que se reproduce. Por ejemplo, puede ajustar el volumen (
El objeto Mouse le permite ocultar el cursor estándar para que pueda utilizar
setVolume
), o el balance (
setPan
).
un cursor personalizado.
El objeto MovieClip le permite controlar clips de película sin utilizar una
acción envolvente como
loadMovie
, o
duplicateMovieClip
tellTarget
la sintaxis de punto (por ejemplo,
. Puede llamar a un método como
desde un nombre de instancia utilizando
myMovieClip.play()
).
play
Acciones de clip
Puede utilizar la acción
onClipEvent
para asignar acciones directamente a instancias de clip de película en el Escenario. La acción onClipEvent dispone de eventos como
load, enterFrame, mouseMove
, y
data
que le permiten crear
nuevas clases de interactividad avanzada.
,
20
Acciones nuevas
Puede utilizar acciones nuevas como do..while y for para crear bucles complejos. Otras acciones nuevas se implementan como métodos del objeto MovieClip; por ejemplo, getBounds, attachMovie, hitTest, swapDepths, y
globalToLocal.
Clips inteligentes
Los Clips inteligentes tienen scripts internos que el usuario, u otro autor, puede cambiar sin utilizar el panel Acciones. Puede pasar valores a un Clip inteligente por medio de los parámetros de clip que puede definir en la Biblioteca.
Introduction
Depurador
El Depurador le permite ver y cambiar los valores de variables y propiedades cuando está reproduciendo una película en el modo de prueba de película, en el reproductor Flash Player independiente o en un navegador Web. Esto le permite encontrar fácilmente los problemas en su programación ActionScript.
Compatibilidad con XML
El objeto XML predefinido le permite convertir ActionScript en documentos XML y pasarlos a las aplicaciones de servidor. También puede utilizar el objeto XML para cargar documentos XML en una película de Flash e interpretarlos. El objeto predefinido XMLSocket le permite crear una conexión continua con el servidor para pasar datos XML para aplicaciones que se ejecutan en tiempo real.
Optimización
Flash 5 lleva a cabo optimizaciones en el código de ActionScript para mejorar su desempeño y no aumentar el tamaño de archivo. Como resultado de estas optimizaciones, Flash 5 con frecuencia producirá código de bytes de ActionScript más pequeño que en Flash 4.

Utilización de la Ayuda de Flash para acciones

Flash 5 contiene ayuda sensible al contexto para cada acción disponible en el panel Acciones. Mientras crea scripts, puede obtener información sobre las acciones que está utilizando.
Para obtener ayuda sobre las acciones:
1 En el panel Acciones, seleccione una acción en la lista de la Caja de
herramientas.
2 Haga clic sobre el botón Ayuda en la parte superior del panel.
En el navegador aparecerá un tema relacionado con la acción.
Procedimientos iniciales 21
Introduction22

CAPÍTULO 1

El lenguaje ActionScript

.............................................................................................................
ActionScript, el lenguaje de creación de scripts de Flash, permite crear películas con elementos interactivos. La película se puede configurar para que ejecute scripts que respondan a eventos de usuario como pueden ser hacer clic en el botón del ratón o presionar una tecla. Por ejemplo, se puede crear un script para indicar a Flash que cargue una película específica en Flash Player como respuesta al botón del navegador seleccionado por el usuario.
La filosofía de ActionScript es la de una herramienta que permite crear películas que se comportan exactamente del modo establecido por el usuario. No es necesario entender todos los posibles usos de la herramienta para empezar a crear scripts; si parte de un objetivo claro, podrá empezar a crear scripts que incluyan acciones sencillas. Puede incorporar nuevos elementos del lenguaje a medida que aprenda a utilizarlos, para realizar tareas más complejas.
Este capítulo presenta ActionScript como un lenguaje de creación de scripts orientado a objetos e introduce diferentes términos del mismo. También analiza un script de ejemplo, de forma que el usuario desarrolle un marco de referencia global respecto al mismo.
Este capítulo introduce además el panel Acciones, que permite construir scripts mediante la selección de elementos de ActionScript o introducir texto en la ventana Script.
1
23

Creación de scripts en ActionScript

Para empezar a escribir scripts sencillos no es necesario tener un conocimiento profundo de ActionScript. Lo único que se necesita es un objetivo claro; lo demás es sólo cuestión de seleccionar las acciones adecuadas. La mejor forma de descubrir lo fácil que es ActionScript es creando un script. En el siguiente ejemplo se presenta un script que ha sido asignado a un botón para cambiar el estado de visibilidad de un clip de película.
Para cambiar la visibilidad de un clip de película:
1 Seleccione Ventana > Bibliotecas comunes > Botones y, a continuación,
seleccione Ventana > Bibliotecas comunes > Clips de película. Coloque un botón y un clip de película en el Escenario.
2 Seleccione la instancia de clip de película en el Escenario, y seleccione
Ventana > Paneles > Propiedades de instancia.
3 Introduzca en el campo Nombre testMC.
4 Seleccione el botón en el Escenario, y elija Ventana > Acciones para abrir el
panel Acciones.
5 En el panel Acciones de objetos, haga clic en la categoría Acciones para abrirla.
6 Haga doble clic en la acción setProperty para agregarla a la lista Acciones.
7 En el menú emergente Propiedad, seleccione _visible (Visibilidad).
8 Especifique testMC como valor del parámetro Destino.
9 Especifique el valor 0 para el parámetro Valor.
El código resultante deberá ser similar al siguiente:
on (release) { setProperty ("testMC", _visible, false); }
10
Seleccione Control > Probar película y haga clic en el botón para ver cómo desaparece el clip de película.
Capítulo 124
ActionScript es un lenguaje de creación de scripts orientado a objetos. Esto significa que, cuando se dan determinados eventos, las acciones controlan objetos. En este script, el evento es la acción del usuario de soltar el botón del ratón (lo que se conoce como "mouse-up"), el objeto es la instancia de clip de película MC y la acción es setProperty. Cuando el usuario hace clic en el botón que se muestra en la pantalla, el evento release ejecuta un script que establece la propiedad
_visible del objeto MC al valor false lo cual hace que el objeto se vuelva
invisible.
El panel Acciones puede utilizarse como referencia para la configuración de scripts sencillos. Para utilizar toda la potencia de ActionScript, es importante comprender el funcionamiento del lenguaje: los conceptos, elementos y reglas del lenguaje para organizar la información y crear películas interactivas.
Esta sección explica el flujo de trabajo de ActionScript, los conceptos fundamentales para la creación de scripts orientados a objetos, los objetos de Flash y el flujo de ejecución de scripts. También presenta información respecto a la ubicación de los scripts en las películas de Flash.
Planificación y depuración de scripts
Lo más común cuando se programan scripts para una película completa es que se trabaje con una gran cantidad y diversidad de scripts. Es importante planear cuidadosamente qué acciones utilizar en un script, cómo estructurar las instrucciones de forma efectiva y en qué elementos ubicarlos para asegurar el mejor desempeño de los mismos, especialmente cuando la complejidad de la película empieza a ser considerable.
Antes de empezar a programar scripts, es importante establecer un objetivo e intentar clarificar con exactitud lo que se propone conseguir. Esto es tan importante (y normalmente consume tanto tiempo) como el desarrollo de los scripts para el proyecto que se desea realizar. Es recomendable empezar por escribir las acciones que se desea sucedan en la película, como en el siguiente ejemplo:
Deseo crear mi propio sitio Web utilizando Flash.
A las personas que visiten el sitio se les pedirá su nombre, y éste se utilizará en
los mensajes que se generen en todo el sitio Web.
El sitio contendrá una barra de navegación que puede arrastrarse, y sus botones
se vincularán con cada una de las secciones.
Cuando se presione un botón, la nueva sección irá apareciendo
progresivamente en el centro del Escenario.
Una escena dispondrá de un formulario de contacto, en el que se mostrará el
nombre del usuario.
El lenguaje ActionScript 25
Cuando tenga una idea clara de lo que desea, podrá construir los objetos necesarios y escribir los scripts que controlen dichos objetos.
Para lograr que los scripts se comporten del modo deseado se tiene que invertir una cantidad considerable de tiempo, en ocasiones es necesario pasar por más de un ciclo de escritura, pruebas y depuración. La mejor forma de abordar un problema suele ser empezar poco a poco y comprobar el trabajo a medida que se avanza. Cuando haya conseguido que funcione una parte del script, seleccione Guardar como, con el fin de guardar una versión del archivo (por ejemplo, miPelic01.fla) y empiece a escribir la siguiente parte. Este modo de trabajar ayuda a identificar errores de un modo eficiente y asegura que el código de ActionScript es fiable antes de proceder a escribir scripts más complejos.
Creación de scripts orientados a objetos
En los scripts orientados a objetos la información se organiza en grupos denominados clases. Pueden crearse varias instancias de una clase; a éstas se les denomina objetos, y los objetos pueden emplearse en los scripts. El desarrollador puede utilizar en sus scripts clases predefinidas de ActionScript y crear las suyas propias.
Cuando se crea una clase, es preciso definir todas las propiedades (características) y métodos (comportamientos) de cada objeto que ésta crea, de modo análogo a como se definen los objetos en el mundo real. Una persona, por ejemplo, tiene ciertas propiedades como el género, la altura y el color de pelo, así como ciertos métodos como son hablar, caminar y lanzar. En este ejemplo “persona” es, genéricamente, una clase y cada persona individual es un objeto, o una instancia de dicha clase.
Los objetos de ActionScript pueden contener datos o pueden representarse gráficamente en el Escenario como clips de película. Todos los clips de película son instancias de la clase predefinida MovieClip. Cada instancia de clip de película contiene todas las propiedades (por ejemplo, _height, _rotation,
_totalframes) y todos los métodos (por ejemplo, gotoAndPlay, loadMovie, startDrag) de la clase MovieClip.
Para definir una clase, debe crearse una función especial, denominada función constructora; las clases predefinidas tienen funciones constructoras previamente
definidas. Por ejemplo, si se desea obtener información acerca de un ciclista que aparece en la película, puede crearse una función constructora, Biker, con las propiedades time y distance y el método rate, que indique la velocidad a la que se desplaza el ciclista:
function Biker(t, d) {
this.time = t;
this.distance = d; } function Speed() {
return this.time / this.distance; } Biker.prototype.rate = Speed;
Capítulo 126
A continuación pueden crearse copias, es decir, instancias, de la clase. El siguiente código crea instancias del objeto
emma = new Biker(30, 5); hamish = new Biker(40, 5);
Biker denominadas emma y hamish.
Las instancias también pueden comunicarse entre sí. Para el objeto Biker, podría crearse un método denominado shove que permita a un ciclista empujar a otro (la instancia emma podría llamar a su método shove en caso de que hamish se acercase demasiado). Para pasar información a un método se utilizan parámetros (también denominados argumentos): por ejemplo, el método shove podría aceptar los parámetros who y howFar. En este ejemplo emma empuja a hamish 10 píxeles:
emma.shove(hamish, 10);
En la creación de scripts orientados a objetos, las clases pueden recibir propiedades y métodos unas de otras, de acuerdo a un orden determinado; esta funcionalidad se denomina herencia. La herencia puede utilizarse para ampliar o redefinir las propiedades y métodos de una clase. Una clase que hereda propiedades y métodos de otra clase recibe el nombre de subclase. Una clase que pasa propiedades y métodos a otra clase recibe el nombre de superclase. Una clase puede ser a la vez subclase y superclase.
Objeto MovieClip
Las clases predefinidas de ActionScript reciben el nombre de Objetos. Cada objeto permite acceder a un determinado tipo de información. Por ejemplo, el objeto Date tiene dos métodos (por ejemplo, getFullYear, getMonth), que permiten leer la información del reloj del sistema. El objeto Sound tiene métodos (por ejemplo, setVolume, setPan) que permiten controlar el sonido en una película. El objeto MovieClip tiene métodos que permiten controlar las instancias de los clips de película (por ejemplo, play, stop y getURL) a la vez que obtienen y definen información acerca de sus propiedades (por ejemplo, _alpha,
_framesloaded, _visible).
Los clips de película son los objetos más importantes de las películas de Flash porque contienen líneas de tiempo que se ejecutan independientemente de las demás. Por ejemplo, si la línea de tiempo principal sólo tiene un fotograma y en una de las capas se incluye un clip de película que contiene a su vez10 fotogramas, el clip de película presentará todo su contenido independientemente de que la línea principal sólo se extienda un fotograma. Esto permite que cada instancia de un clip de película se comporte como objeto autónomo con capacidad de comunicación con los demás.
El lenguaje ActionScript 27
Cada instancia de un clip de película tiene un nombre único, de modo que es posible controlarlas a través de acciones. Por ejemplo, si dispusiésemos de varias instancias de un clip de película en el Escenario (por ejemplo, leftClip y
rightClip) podríamos asignar una acción para lograr que sólo una se reprodujese
en un momento dado. Para esto, basta asignar una acción que active a la instancia a través del nombre de la misma. En el siguiente ejemplo, el nombre del clip de película es leftClip:
leftClip.play();
Al momento de reproducción de una película también se pueden duplicar, eliminar y arrastrar instancias de uno o varios clips de película utilizando su nombre de instancia. El siguiente ejemplo duplica la instancia
cartItem para
llenar un carrito de compra con el número de artículos comprados:
onClipEvent(load) { do { duplicateMovieClip("cartItem", "cartItem" + i, i); i = i + 1; } while (i <= numberItemsPur); }
Los clips de película poseen propiedades cuyos valores pueden establecerse y recuperarse en forma dinámica mediante ActionScript. La modificación y lectura de estas propiedades puede cambiar el aspecto e identidad de un clip de película y es la clave para darle interactividad. Por ejemplo, el siguiente script utiliza la acción setProperty para establecer la transparencia (parámetro alfa) de la instancia navigationBar al valor 10:
setProperty("navigationBar", _alpha, 10);
Para obtener más información referente a otro tipos de objetos, consulte la sección “Utilización de objetos predefinidos” a pagina 81.
Flujo de los scripts
ActionScript sigue un flujo lógico. Flash ejecuta las sentencias de ActionScript empezando por la primera y continuando secuencialmente hasta llegar a la última o a una sentencia que le indique una bifurcación a otro script u otra parte en el mismo script.
A continuación se presentan algunas acciones que cambian el flujo de ActionScript hacia una sentencia diferente a la que aparece después de ella:
Capítulo 128
La sentencia if, los bucles do...while, y la acción return.
El lenguaje ActionScript 29
Una sentencia if recibe el nombre de sentencia condicional o “bifurcación lógica”, ya que controla el flujo de un script basándose en la evaluación de una determinada condición. Por ejemplo, el siguiente código comprueba si el valor de la variable number es menor o igual que 10. Si la comprobación devuelve true (por ejemplo, el valor de number es 5), se establece la variable alert y muestra su valor en un campo de entrada de texto, como el siguiente:
if (number <= 10) { alert = "The number is less than or equal to 10"; }
También se pueden incluir sentencias else para crear sentencias condicionales más complejas. En el ejemplo siguiente, si la condición devuelve true (por ejemplo, el valor de number es 3), se ejecuta la sentencia encerrada entre el primer conjunto de llaves y la variable alert se establece en la segunda línea. Si la condición devuelve false (por ejemplo, el valor de number es 30), se ignora el primer bloque de código y se ejecuta la sentencia encerrada entre llaves detrás de la sentencia else, como a continuación:
if (number <= 10) { alert = "The number is less than or equal to 10"; } else { alert = "The number is greater than 10"; }
Si desea obtener más información, consulte “Utilización de las sentencias if” a pagina 73.
Los bucles repiten una acción un determinado número de veces, o hasta que se cumpla cierta condición. En el siguiente ejemplo se duplica cinco veces un clip de película:
i = 0; do { duplicateMovieClip ("myMovieClip", "newMovieClip" + i, i); newName = eval("newMovieClip" + i); setProperty(newName, _x, getProperty("myMovieClip", _x) + (i *
5)); i = i + 1; } while (i <= 5);
Para obtener información detallada, consulte “Repetición de una acción” a pagina 74.
Capítulo 130
Control de la ejecución de ActionScript
Para escribir scripts se utiliza el panel Acciones. Dicho panel permite asignar el script a un fotograma de la línea de tiempo principal o a la línea de tiempo de cualquier clip de película, o bien a un botón o clip de película en el Escenario.
Flash ejecuta acciones en momentos diferentes, dependiendo del elemento al que estén asociadas:
Las acciones asociadas con fotogramas se ejecutan cuando la cabeza lectora
accede a dicho fotograma.
Las acciones asociadas con botones se encuentran encerradas en acciones
controladorason.
Las acciones asociadas con clips de película se encuentran encerradas en
acciones controladoras onClipEvent.
Las acciones onClipEvent y on reciben el nombre de controladoras porque “controlan” o administran eventos. (Un evento es una incidencia, como un movimiento del ratón, una pulsación de tecla o un clip de película que se carga). Las acciones de botón y de clip de película se ejecutan cuando se produce el evento especificado por el controlador. Es posible asociar más de un controlador a un objeto para que éstos ejecuten acciones como respuesta a diferentes eventos. Para obtener más información, consulte el Capítulo 3, “Interacción con ActionScript”.
Varios controladores onClipEvent asociados a un clip de película en el Escenario.
El lenguaje ActionScript 31

Terminología de ActionScript

Al igual que cualquier lenguaje de creación de scripts, ActionScript utiliza terminología específica y está sujeta a determinadas reglas sintácticas. La siguiente lista introduce términos importantes de ActionScript, en orden alfabético. En el Capítulo 2, “Programación de scripts con ActionScript”, se estudian con mayor detalle dichos términos y la sintaxis que los gobierna.
Acciones: son sentencias que ordenan a una película efectuar alguna acción
durante su reproducción. Por ejemplo, gotoAndStop envía la cabeza lectora a un fotograma o etiqueta determinados. En este manual, los términos acción y sentencia pueden emplearse indistintamente.
Argumentos: también llamados parámetros, actúan como contenedores que
permiten pasar valores a las funciones. Por ejemplo, la siguiente función, denominada welcome, utiliza dos valores que recibe como argumentos
firstName y hobby:
function welcome(firstName, hobby) {
welcomeText = "Hello, " + firstName + "I see you enjoy " + hobby;
}
Clases: son un tipo de datos que pueden emplearse para definir un nuevo tipo de
objeto. Para definir una clase de objeto, debe utilizarse una función constructora.
Constantes: son elementos cuyo valor no cambia. Por ejemplo, la constante
TAB tiene siempre el mismo significado. Las constantes son útiles para
comparar valores.
Constructores: son funciones que se utilizan para definir las propiedades y
métodos de una clase. Por ejemplo, el siguiente código crea un nueva clase Circle mediante una función constructora denominada Circle:
function Circle(x, y, radius){
this.x = x;
this.y = y;
this.radius = radius; }
Tipos de datos: son conjuntos de valores y las operaciones que pueden realizarse
sobre ellos, e incluyen cadenas, números, los valores booleanos true y false, objetos y clips de película. Para conocer más detalles acerca de estos elementos del lenguaje ActionScript, consulte la sección “Tipos de datos” a pagina 56.
Capítulo 132
Eventos: son acciones que ocurren durante la reproducción de una película.
Por ejemplo, cuando se carga un clip de película se generan diferentes eventos: la cabeza lectora accede a un fotograma, el usuario hace clic en un botón o clip de película, o el usuario introduce información mediante el teclado.
Expresiones: son las partes de una sentencia que generan valores. Por ejemplo,
2 + 2 es una expresión.
Funciones: son bloques de código reutilizables, que aceptan argumentos
(parámetros) y pueden devolver valores. Por ejemplo, la función getProperty acepta como parámetro el nombre de una propiedad y el nombre de instancia de un clip de película y como resultado devuelve el valor de la propiedad. La función
getVersion devuelve la versión de Flash Player que está reproduciendo la película
en un momento dado.
Controladores: son acciones especiales que “controlan” o administran un evento,
como mouseDown o load. Por ejemplo, on (onMouseEvent) y onClipEvent son controladores de ActionScript.
Identificadores: son nombres que se utilizan para identificar una variable,
propiedad, objeto, función o método. El primer carácter debe ser una letra, símbolo de subrayado (_) o símbolo de dólar ($). Los siguientes caracteres pueden ser letras, números, símbolos de subrayado (_) o símbolos de dólar ($). Por ejemplo, firstName es el nombre de una variable.
Instancias: son objetos que pertenecen a una determinada clase. Cada instancia
de una clase contiene todas las propiedades y métodos de dicha clase. Todos los clips de película son instancias con propiedades (por ejemplo, _alpha y _visible) y métodos (por ejemplo, gotoAndPlay y getURL) de la clase MovieClip.
Nombres de instancias: son nombres únicos que permiten controlar instancias
de clips de película a través de scripts. Por ejemplo, un símbolo maestro de la Biblioteca podría llamarse counter y las dos instancias de dicho símbolo que se utilizan en la película podrían nombrarse instancia scorePlayer1 y
scorePlayer2. En el siguiente código se utilizan los nombres de instancia para
establecer una variable llamada score en cada instancia de un clip de película:
_root.scorePlayer1.score += 1 _root.scorePlayer2.score -= 1
El lenguaje ActionScript 33
Palabras clave: son palabras reservadas que tienen un significado especial. Por
ejemplo,
Métodos: son funciones que han sido asignadas a un objeto. Una vez que se ha
var es una palabra clave que se utiliza para declarar variables locales.
asignado una función se puede realizar un llamado a la misma como método de ese objeto. Por ejemplo, en el siguiente código, clear se convierte en un método del objeto controller:
function Reset(){
x_pos = 0;
x_pos = 0; } controller.clear = Reset; controller.clear();
Objetos: son conjuntos de propiedades; cada objeto posee su propio nombre
y valor. Los objetos permiten acceder a un determinado tipo de información. Por ejemplo, el objeto predefinido Date ofrece información procedente del reloj del sistema.
Operadores: son términos que calculan un nuevo valor a partir de uno o más
valores. Por ejemplo, el operador suma (+) suma dos o más valores y arroja como resultado un nuevo valor.
Rutas de destino: son direcciones jerárquicas de nombres de instancias de clips
de película, o bien variables y objetos en una película. Para asignar nombre a una instancia de clip de película se utiliza el panel Instancia. El nombre de la Línea de tiempo principal es siempre _root. Se puede usar una ruta de destino para dirigir una acción a un clip de película, o para obtener o establecer el valor de una variable. Por ejemplo, la siguiente sentencia establece una ruta de destino a la variable volume dentro del clip de película stereoControl:
_root.stereoControl.volume
Propiedades: son atributos que definen a un objeto. Por ejemplo, _visible es
una propiedad de todos los clips de película que define si el clip está visible o si se encuentra oculto.
Variables: son identificadores que almacenan valores de cualquier tipo de datos.
Las variables pueden crearse, modificarse y actualizarse. Los valores almacenados en una variable pueden recuperarse para ser utilizados en scripts. En el siguiente ejemplo, los identificadores situados a la izquierda de los signos igual son variables:
x = 5; name = "Lolo"; customer.address = "66 7th Street"; c = new Color(mcinstanceName);
Capítulo 134

Análisis de un script de ejemplo

En la siguiente película de ejemplo, cuando un usuario arrastra el insecto hacia el matamoscas, el insecto cambia de color al color negro y cae, y el matamoscas parece parpadear. La película tiene una longitud de un fotograma y contiene dos objetos, la instancia del clip de película del insecto y la instancia del clip de película del matamoscas. Cada clip de película contiene asimismo un fotograma.
Las instancias de clip de película del insecto y del matamoscas en el Escenario en el fotograma 1.
Controlador
Acción
Variable
Sentencia
condicional if
Else, sentencia
Sólo hay un script en la película y está asociado a la instancia del insecto, como puede apreciarse en el panel Acciones de objetos que se muestra a continuación:
Evento
Función constructora
Operador new
Panel Acciones de objetos, que muestra el script asignado a la instancia del insecto.
El lenguaje ActionScript 35
Ambos objetos deben ser clips de película, de forma que sea posible asignarles nombres de instancia en el panel Instancia y manipularlos mediante ActionScript. El nombre de instancia del insecto es bug y el del matamoscas es zapper. En el script, se hace referencia al insecto como this porque el script está anexado al insecto y la palabra reservada this hace referencia al objeto que lo llama.
Hay dos controladores onClipEvent con dos eventos diferentes: load y
enterFrame. Las acciones de la sentencia onClipEvent(load) se ejecutan
sólo una vez, al cargarse la película. Las acciones de la sentencia
onClipEvent(enterFrame) se ejecutan cada vez que la cabeza lectora accede
a un fotograma. Incluso aunque se trate de películas de un solo fotograma, la cabeza lectora accederá al fotograma reiterativamente y el script se ejecutará de la misma forma. Dentro de cada controlador onClipEvent se llevan a cabo las siguientes acciones:
onClipEvent(load) La acción startDrag hace posible que se pueda arrastrar el
clip de película del insecto. El operador new y la función constructora de color,
Color, crean una instancia del objeto Color y la asignan a la variable zap:
onClipEvent (load) {
startDrag (this, true);
zap = new Color(this); }
onClipEvent(enterFrame) Una sentencia condicional if evalúa una acción
hitTest para comprobar si la instancia del insecto (this) está tocando a la
instancia del matamoscas (_root.zapper). La evaluación puede generar dos posibles resultados, true o false:
onClipEvent (enterFrame) {
if (hitTest(_target, _root.zapper)) {
zap.setRGB(0); setProperty (_target, _y, _y+50); setProperty (_root.zapper, _alpha, 50); stopDrag ();
} else {
setProperty (_root.zapper, _alpha, 100);
} }
Si la acción hitTest devuelve true, el objeto zap creado por el evento load se utilizará para cambiar el color del insecto a negro. La propiedad y (_y) del insecto se establece a su valor más 50, de modo que el insecto caiga. La transparencia del matamoscas (_alpha) se establece al valor 50, de modo que se atenúe. La acción
stopDrag impide que se arrastre el objeto.
Capítulo 136
Si la acción hitTest devuelve el valor false, se ejecutará la acción que sigue a la sentencia
else y el valor _alpha del matamoscas se establecerá al valor 100.
Esto provocará que el matamoscas aparezca intermitentemente, ya que su valor
_alpha pasará de un estado inicial (100) a un estado activo (50), volviendo
posteriormente al estado inicial. La acción hitTest arroja como resultado el valor
false y las sentencias else se ejecutan una vez que se ha alcanzado y abatido al
insecto.
Para ver cómo se reproduce la película, consulte la Ayuda de Flash.

Utilización del panel Acciones

El panel Acciones permite crear y editar acciones de un objeto o fotograma mediante el uso de dos modos de edición. Es posible seleccionar acciones previamente escritas en la lista de la Caja de herramientas, arrastrar y colocar acciones, así como utilizar botones para eliminar o reordenar acciones. El modo Normal permite escribir acciones utilizando campos de parámetros (argumentos) que solicitan los argumentos apropiados. El modo Experto permite escribir y editar acciones directamente en un cuadro de texto, como si se escribiesen en un procesador de texto.
Para mostrar el panel Acciones:
Seleccione Ventana > Acciones.
El panel Acciones se activa cuando se selecciona una instancia de un botón o clip de película. El título del panel Acciones cambia a Acciones de objetos si algún botón o clip de película se encuentra seleccionado, y a Acciones de fotograma si se encuentra seleccionado hay un fotograma.
Para seleccionar un modo de edición:
1 Con el panel Acciones en pantalla, haga clic en la flecha de la esquina superior
derecha para que se muestre el menú emergente.
2 Seleccione Modo Normal o Modo Experto en el menú emergente.
Cada script conserva su propio modo. Por ejemplo, si se crea un script para una instancia de un botón en modo Normal y otro en modo Experto, posteriormente se cambiará el modo del panel al seleccionar cada uno de los botones.
El lenguaje ActionScript 37
Modo Normal
El modo Normal permite crear acciones seleccionándolas de una lista situada en la parte izquierda del panel, denominada lista de la Caja de herramientas. La lista de la Caja de herramientas contiene las siguientes categorías: Acciones básicas, Acciones, Operadores, Funciones, Propiedades y Objetos. La categoría Acciones básicas contiene las acciones de Flash más simples y sólo está disponible en el modo Normal. Las acciones seleccionadas se muestran en la parte derecha del panel, en la lista Acciones. Es posible agregar, eliminar o modificar el orden de las sentencias de acciones; también es posible especificar parámetros (argumentos) para las acciones en los campos que se encuentran en la parte inferior del panel.
En modo Normal se pueden utilizar los controles del panel Acciones para eliminar o cambiar el orden de las sentencias de la lista Acciones. Estos controles resultan especialmente útiles para controlar acciones de botón o fotograma que contienen varias sentencias.
Agregar una sentencia
Eliminar una sentencia
Lista de la Caja
de herramientas
panel Parámetros
Capítulo 138
Lista Acciones
Insertar ruta de destino, botón
Panel Acciones en modo Normal.
Para seleccionar una acción:
1 Haga clic en una categoría de acciones de la Caja de herramientas para acceder
a las acciones de dicha categoría.
2 Haga doble clic en una acción o arrástrela a la ventana de scripts.
Para utilizar los campos de parámetros:
1 Haga clic en el botón Parámetros, situado en la esquina inferior derecha del
panel Acciones, para mostrar los campos.
2 Seleccione la acción y especifique nuevos valores en los campos de parámetros,
si desea modificar los parámetros de las acciones existentes.
Para insertar una ruta de destino de clip de película:
1 Haga clic en el botón Ruta de destino, situado en la esquina inferior derecha
del panel Acciones; accederá al cuadro de diálogo Insertar ruta de destino.
2 Seleccione un clip de película de la lista de visualización.
Para desplazar una sentencia de la lista hacia arriba o hacia abajo:
1 Seleccione una sentencia en la lista Acciones. 2 Haga clic en los botones de flecha arriba o abajo.
Para eliminar una acción:
1 Seleccione una sentencia en la lista Acciones. 2 Haga clic en el botón Eliminar (-).
Para cambiar los parámetros de las acciones existentes:
1 Seleccione una sentencia en la lista Acciones. 2 Introduzca los nuevos valores en los campos de parámetros.
Para cambiar el tamaño de la Caja de herramientas o de la lista Acciones, utilice uno de los siguientes procedimientos:
Arrastre la barra separadora vertical que aparece entre la Caja de herramientas
y la lista Acciones.
Haga doble clic en la barra separadora para contraer la lista de la Caja de herramientas; vuelva a hacer doble clic en la barra para mostrar la lista de nuevo.
Haga clic en el botón de flecha izquierda o derecha de la barra separadora para
expandir o contraer la lista.
Aunque la Caja de herramientas esté oculta, es posible acceder a sus elementos mediante el botón Agregar (+), que se encuentra en la parte superior izquierda del panel Acciones.
El lenguaje ActionScript 39
Modo Experto
El modo Experto permite crear acciones introduciendo comandos de ActionScript en el cuadro de texto situado en la parte derecha del panel, o bien seleccionado acciones en la lista de la Caja de herramientas de la izquierda. Para editar acciones, especificar parámetros de acciones o eliminar acciones se utiliza directamente el cuadro de texto, como se haría si se estuviesen creando los scripts mediante un procesador de texto.
El modo Experto permite a los usuarios experimentados de ActionScript modificar sus propios scripts con un procesador de texto, como si se tratase de JavaScript o VBScript. Las principales diferencias respecto al modo Normal son las siguientes:
Al seleccionar un elemento en el menú emergente Agregar o en la lista
de la Caja de herramientas, se introduce dicho elemento en el área de edición de texto.
No aparecen campos de parámetros.
En el panel de botones, únicamente se encuentra activo el botón Agregar (+).
Los botones de flecha arriba y abajo permanecen inactivos.
El panel Acciones en modo Experto.
Capítulo 140
Cambio del modo de edición
Si se cambia de modo de edición mientras se está creando un script, el formato de éste podría alterarse. Por ese motivo, se recomienda utilizar un solo modo de edición por script.
Al cambiar de modo Normal a Experto se conserva la sangría y el formato. Aunque se pueden convertir scripts creados en modo Normal que contienen errores a modo Experto, no podrán exportarse hasta que éstos hayan sido corregidos.
El cambio de modo Experto a modo Normal es ligeramente más complejo:
Cuando se cambia de modo Experto a modo Normal, Flash vuelve a asignar
formato al script y elimina los espacios en blanco y la sangría que hubiera podido agregarse.
Si se cambia a modo Normal y, seguidamente, a modo Experto, Flash vuelve a
asignar formato al script de acuerdo con el aspecto que tenía en modo Normal.
Los scripts en modo Experto que contienen errores no pueden exportarse ni
convertirse al modo Normal; si se intenta, presentará un mensaje de error.
Para cambiar el modo de edición:
Seleccione Modo Normal o Modo Experto en el menú emergente situado en la parte superior derecha del panel Acciones. Se indicará el modo seleccionado a través de una marca de verificación.
Para establecer las preferencias de un modo de edición:
1 Seleccione Edición > Preferencias.
2 Seleccione la ficha General.
3 En la sección Panel Acciones, elija Modo Normal o Modo Experto en
el menú emergente.
El lenguaje ActionScript 41
Utilización de un editor externo
Aunque el modo Experto del panel Acciones proporciona un mayor control de edición con ActionScript, también puede optar por editar scripts externamente a Flash. Posteriormente puede hacer uso de la acción include para agregar los scripts creados mediante el editor externo a un script de Flash.
Por ejemplo, la siguiente sentencia importa un archivo de script:
#include "externalfile.as"
El texto del archivo de script sustituye a la acción include. El archivo de texto deberá estar presente cuando se exporte la película.
Para agregar los scripts creados con un editor externo a un script de Flash:
1 Arrastre la acción include desde la lista de la Caja de herramientas a la
ventana de scripts.
2 Especifique la ruta del archivo externo en el cuadro Ruta.
La ruta deberá ser relativa respecto al archivo FLA. Por ejemplo, si los archivos mi_Pelicula.fla y archivo_externo.as estuviesen situados en la misma carpeta, la ruta sería archivo_externo.as. Si archivo_externo.as se encontrase en una subcarpeta denominada scripts, la ruta sería scripts/archivo_externo.as.
Selección de opciones en el panel Acciones
El panel Acciones permite manipular scripts de varias maneras. El tamaño de la fuente puede modificarse en la ventana de scripts. Pueden importarse archivos de texto que contengan comandos de ActionScript en el panel Acciones, así como exportar acciones como archivos de texto, buscar y reemplazar texto en un script y utilizar elementos para realzar la sintaxis para facilitar la identificación de los scripts y la detección de errores. El panel Acciones muestra elementos de realzado de tipo advertencia cuando existen errores sintácticos e incompatibilidades de versiones con Flash Player. También realza elementos de ActionScript no aprobados o no deseables.
Estas opciones del panel Acciones se encuentran disponibles tanto en modo Normal como en modo Experto, a menos que se especifique lo contrario.
Para cambiar el tamaño de fuente en la ventana de scripts:
1 En el menú emergente situado a la derecha del panel Acciones, seleccione
Tamaño de fuente.
2 Seleccione Pequeño, Normal o Grande.
Capítulo 142
Para importar un archivo de texto que contenga comandos de ActionScript:
1 En el menú emergente situado en la parte superior derecha del panel Acciones,
seleccione Importar desde archivo.
2 Seleccione un archivo de texto que contenga comandos de ActionScript y haga
clic en Abrir.
Nota:
Los scripts que contienen errores sintácticos sólo pueden importarse en modo
Experto. En modo Normal se generará un mensaje de error.
Para exportar acciones como archivos de texto:
1 En el menú emergente situado en la parte superior derecha del panel Acciones
seleccione Exportar como archivo.
2 Elija una ubicación para el archivo y haga clic en Guardar.
Para imprimir acciones:
1 En el menú emergente situado en la parte superior derecha del panel Acciones,
seleccione Imprimir.
Se mostrará el cuadro de diálogo Imprimir.
2 Seleccione Opciones y haga clic en Imprimir.
Nota:
El archivo impreso no incluirá información respecto al archivo de Flash del que
procede. Es recomendable incluir esta información en una acción
comment en el script.
Para buscar texto en un script, seleccione una opción en el menú emergente del panel Acciones:
Seleccione Ir a línea para desplazarse a una línea determinada de un script.
Seleccione Buscar para buscar texto.
Seleccione Buscar otra vez para buscar una cadena de texto de nuevo.
Seleccione Reemplazar para buscar y reemplazar texto.
En modo Experto, el comando Reemplazar busca en todo el cuerpo de texto de un script. En modo Normal, el comando Reemplazar busca y reemplaza texto únicamente en el campo de parámetros de cada acción. Por ejemplo, en modo Normal no sería posible reemplazar todas las acciones gotoAndPlay por
gotoAndStop.
Nota:
Utilice los comandos Buscar o Reemplazar para buscar en la lista Acciones actual. Para buscar texto en todos los script de una película, utilice el Explorador de películas. Para obtener más información, consulte la sección
Utilización de Flash
El lenguaje ActionScript 43
.
Realzado y comprobación de la sintaxis
Los elementos de realzado de la sintaxis permiten identificar determinados elementos de ActionScript y asignarles diferentes colores. De esto modo se evitan errores sintácticos, como la incorrecta colocación de mayúsculas y minúsculas en palabras clave. Por ejemplo, si la palabra clave typeof se escribiese como typeOf, ésta no aparecería en color azul y esto ayudaría a que se detectase el error. Cuando se encuentra activada la opción de realzado de sintaxis, el texto se destacará del siguiente modo:
Las palabras clave y los identificadores predefinidos (por ejemplo,
gotoAndStop, play y stop) aparecen en color azul.
Las propiedades aparecen en verde.
Los comentarios aparecen en color morado.
Las cadenas encerradas entre comillas aparecen en color gris.
Para activar o desactivar el realzado de sintaxis:
Seleccione Sintaxis en color en el menú emergente situado en la parte superior derecha del panel Acciones. Una marca de verificación indica que la opción está activada. El realzado se aplicará a todos los scripts de la película.
Es recomendable comprobar que la sintaxis de los scripts es correcta antes de exportar películas. Los errores se muestran en la Ventana de salida. Podrán exportarse películas que contengan scripts con errores. No obstante, el usuario recibirá una advertencia indicándole que los scripts con errores no se exportarán.
Para comprobar los errores sintácticos del script actual:
Seleccione Revisar sintaxis en el menú emergente situado en la parte superior derecha del panel Acciones.
Capítulo 144
Realzado de errores
En modo Normal, todos los errores sintácticos se realzan utilizando un fondo de color rojo sólido en la ventana de scripts. Esto ayuda a detectar problemas. Si se desplaza el puntero de ratón sobre una acción sintácticamente incorrecta, se mostrará el mensaje de error asociado en un cuadro de información. Cuando se selecciona la acción, el mensaje de error se muestra también en el título del panel del área de parámetros.
En modo Normal todas las posibles incompatibilidades de exportación de ActionScript se realzan con un fondo de color amarillo sólido en la ventana de scripts. Por ejemplo, si la versión de exportación de Flash Player se establece como Flash 4, los comandos de ActionScript que sólo sean compatibles con Flash Player 5 se mostrarán realzados en color amarillo. La versión de exportación se determina en el cuadro de diálogo Configuración de publicación.
Todas las acciones no aprobadas se realzan con fondo de color verde en la Caja de herramientas. Las acciones no aprobadas sólo se realzan cuando la versión de exportación de Flash se establece como Flash 5.
Para establecer la versión de exportación de Flash Player:
1 Seleccione Archivo > Configuración de publicación.
2 Haga clic en la ficha Flash.
3 Elija una versión de exportación en el menú emergente Versión.
Nota:
El realzado de errores sintácticos no puede desactivarse.
Para realzar la sintaxis no aprobada:
Seleccione Mostrar sintaxis no aprobada en el menú emergente del panel Acciones.
Para desea obtener la relación completa de mensajes de error, consulte el Apéndice C, “Mensajes de error”.
El lenguaje ActionScript 45

Asignación de acciones a los objetos

Se pueden asignar acciones a botones o a clips de película, de modo que la acción se ejecute cuando el usuario haga clic en un botón o sitúe el puntero sobre él, o bien cuando se cargue el clip de película o se alcance un determinado fotograma. La acción se asigna a una instancia del botón o del clip de película; el resto de instancias del símbolo no se verán afectadas (si desea asignar una acción a un fotograma, consulte la sección “Asignación de acciones a fotogramas” a pagina 48).
Cuando asigna una acción a un botón, debe anidarla dentro de un controlador
on(mouse event) y especificar los eventos de ratón o teclado que activan la
acción. Cuando asigna una acción a un botón en el Modo Normal, el controlador
on(mouse event) se inserta automáticamente.
Cuando asigna una acción a un clip de película, debe anidarla dentro de un controlador onClipEvent y especificar el evento de clip que activa la acción. Cuando asigna una acción a un clip de película en el Modo Normal, el controlador on(mouse event) se inserta automáticamente.
Las siguientes instrucciones describen el modo de asignar acciones a objetos mediante el panel Acciones utilizado en modo Normal.
Una vez asignada una acción, utilice el comando Control > Probar película para verificar si funciona. La mayoría de las acciones no funcionan en el modo de edición.
Para asignar una acción a un botón o clip de película:
1 Seleccione un botón o una instancia de clip de película y elija
Ventana > Acciones.
Si la selección no es un botón, una instancia de clip de película o un fotograma, o si la selección incluye varios objetos, el panel Acciones aparecerá atenuado.
2 Seleccione Modo Normal en el menú emergente situado en la parte superior
derecha del panel Acciones de objetos.
3 Para asignar una acción utilice uno de los siguientes procedimientos:
Haga clic en la carpeta Acciones, que se encuentra en la lista de la Caja de
herramientas, a la izquierda del panel Acciones. Haga doble clic en una acción para agregarla a la lista Acciones situada a la derecha del panel.
Arrastre una acción desde la lista de la Caja de herramientas hasta la
lista Acciones.
Haga clic en el botón Agregar (+) y elija una acción en el menú emergente.
Capítulo 146
Utilice el método abreviado de teclado situado junto a cada acción en
el menú emergente.
Selección de objetos de la Caja de herramientas en modo Normal
4 Seleccione los parámetros que se requieran para la acción en los campos de
parámetros, situados en la parte inferior del panel.
Los parámetros variarán dependiendo de la acción que se seleccione. Para obtener información detallada acerca de los parámetros necesarios para cada acción, consulte el Capítulo 7, “Diccionario de ActionScript”. Para insertar una Ruta de destino para un clip de película en un campo de parámetros, haga clic en el botón Ruta de destino, que se encuentra en la esquina inferior derecha del panel Acciones. Para obtener más información, consulte el Capítulo 4, “Utilización de clips de película”.
5 Repita los pasos 3 y 4 para asignar más acciones, si fuera necesario.
Para probar la acción de un objeto:
Seleccione Control > Probar película.
El lenguaje ActionScript 47

Asignación de acciones a fotogramas

Si se desea que una película realice un acción específica cuando alcance un fotograma clave, basta con asignar una acción de fotograma al fotograma clave. Por ejemplo, para crear un bucle entre los fotogramas 20 y 10 de la Línea de tiempo, agregue la siguiente acción de fotograma al fotograma 20:
gotoAndPlay (10);
Es conveniente situar las acciones de fotograma en capas independientes. Los fotogramas con acciones se indican con una pequeña a en la Línea de tiempo.
Una “a” en un fotograma clave indica una acción de fotograma.
Una vez asignada la acción, seleccione Control > Probar película para verificar si funciona. La mayoría de las acciones no funcionan en el modo de edición.
Las siguientes instrucciones describen el modo de asignar acciones de fotograma mediante el panel Acciones en modo Normal (para obtener información acerca de la asignación de acciones a botones o clips de película, consulte la sección “Asignación de una acción o método” a pagina 127).
Para asignar una acción a un fotograma clave:
1 Seleccione un fotograma clave en la Línea de tiempo y elija Ventana > Acciones.
Si el fotograma seleccionado no es un fotograma clave, la acción se asignará al fotograma clave anterior. Si no se ha seleccionado ningún fotograma, o si la selección incluye varios fotogramas clave, el panel Acciones aparecerá atenuado.
2 Seleccione Modo Normal en el menú emergente situado en la parte superior
derecha del panel Acciones de fotograma.
Capítulo 148
3
Para asignar una acción utilice uno de los siguientes procedimientos:
Haga clic en la carpeta Acciones, que se encuentra en la lista de la Caja de
herramientas, a la izquierda del panel Acciones. Haga doble clic en una acción para agregarla a la lista Acciones situada a la derecha del panel.
Arrastre una acción desde la lista de la Caja de herramientas hasta la
lista Acciones.
Haga clic en el botón Agregar (+) y elija una acción en el menú emergente.
Utilice el método abreviado de teclado situado junto a cada acción en el
menú emergente.
Seleccione los parámetros que se requieran para la acción en los campos
de parámetros, situados en la parte inferior del panel.
4 Para asignar acciones adicionales, seleccione otro fotograma clave y
repita el paso 3.
Para probar una acción de fotograma:
Seleccione Control > Probar película.
El lenguaje ActionScript 49
Capítulo 150

CAPÍTULO 2

Programación de Scripts en ActionScript

.............................................................................................................
Es posible crear scripts en ActionScript, optando por el nivel de detalle que se desee utilizar. Para utilizar las acciones sencillas, puede acceder al panel Acciones en Modo Normal y crear scripts eligiendo las opciones que desea utilizar de los menús y de las listas. Sin embargo, si desea utilizar ActionScript para escribir scripts más poderosos, es recomendable entender las bases del lenguaje ActionScript.
Como otros lenguajes de scripts, ActionScript consta de componentes como objetos predefinidos y funciones, y le permite crear sus propios objetos y funciones. ActionScript tiene sus propias reglas sintácticas, se reserva palabras clave, proporciona operadores y le permite utilizar variables para almacenar y recuperar información.
La sintaxis y el estilo de ActionScript se parece mucho al de JavaScript. Flash 5 convierte los scripts de ActionScript escritos en cualquier versión anterior de Flash.
2
51

Utilización de la sintaxis de ActionScript

ActionScript sigue reglas gramaticales y de puntuación que determinan qué caracteres y palabras se utilizan para dar significado a una sentencia y el orden en que se deben escribir. Por ejemplo, en español, una oración termina con un punto. En ActionScript, se utiliza un punto y coma para finalizar una sentencia.
A continuación se detallan las reglas generales que se aplican a todo el lenguaje ActionScript. La mayoría de los términos de ActionScript tienen sus propios requisitos; para conocer las reglas de un término específico, consúltelo en el Capítulo 7, “Diccionario de ActionScript”.
Sintaxis de punto
En ActionScript, se utiliza un punto (.) para indicar las propiedades o métodos relacionados con un objeto o un clip de película. También se utiliza para identificar la ruta de destino a un clip de película o a una variable. Una expresión de sintaxis de punto comienza con el nombre del objeto o del clip de película seguido por un punto y finaliza con la propiedad, el método o la variable que desee especificar.
Por ejemplo, la propiedad de clip de película _x indica la posición del clip de película en el eje x en el Escenario. La expresión ballMC._x se refiere a la propiedad _x de la instancia del clip de película ballMC.
Otro ejemplo, submit es una variable establecida en el clip de película form que se encuentra anidado dentro del clip de película shoppingCart. La expresión
shoppingCart.form.submit = true establece la variable submit de la instancia form en true.
La expresión de un método de un objeto o de un clip de película sigue el mismo esquema. Por ejemplo, el método play de la instancia ballMC mueve la cabeza lectora en la Línea de tiempo de ballMC, como en la siguiente sentencia:
ballMC.play();
La sintaxis de punto también utiliza dos alias especiales, _root y _parent. El alias _root se refiere a la Línea de tiempo principal. Puede utilizar el alias _root para crear una ruta de destino absoluta. Por ejemplo, la siguiente sentencia llama a la función buildGameBoard en el clip de película functions en la Línea de tiempo principal:
_root.functions.buildGameBoard();
Puede utilizar el alias _parent para referirse a un clip de película en el que está anidado el clip de película actual. Puede utilizar _parent para crear una ruta de destino relativa. Por ejemplo, si el clip de película dog se encuentra anidado dentro del clip de película animal, la siguiente sentencia en la instancia dog dice a animal que se detenga:
_parent.stop();
Consulte el Capítulo 4, “Trabajo con clips de películas”.
Capítulo 252
Sintaxis de barras
La sintaxis de barra se utilizó en Flash 3 y 4 para indicar la ruta de destino de un clip de película o de una variable. Esta sintaxis aún se admite en Flash Player 5, pero no se recomienda su utilización. En la sintaxis de barras inversas, éstas se utilizan en lugar de los puntos para indicar la ruta a un clip de película o a una variable. Para indicar una variable, debe anteponerle dos puntos como se muestra a continuación:
myMovieClip/childMovieClip:myVariable
Puede escribir la misma ruta de destino en sintaxis de punto, como se muestra a continuación:
myMovieClip.childMovieClip.myVariable
La sintaxis de barra inversa se utilizaba comúnmente con la acción tellTarget, pero su utilización ya no se recomienda.
Nota:
Ahora es recomendable emplear la acción with en lugar de tellTarget debido a que es más compatible con la sintaxis de punto. Para obtener más información, consulte el Capítulo 7, “Diccionario de ActionScript”.
Llaves
Las sentencias de ActionScript se agrupan en bloques con llaves ({ }), como se muestra en el script siguiente:
on(release) { myDate = new Date(); currentMonth = myDate.getMonth(); }
Consulte “Uso de acciones” a pagina 71.
Puntos y coma
Una sentencia de ActionScript se termina con punto y coma, pero si omite el punto y coma final, Flash compilará con éxito script. Por ejemplo, las siguientes sentencias finalizan con punto y coma:
column = passedDate.getDay(); row = 0;
Las mismas sentencias podrían escribirse sin terminar en punto y coma:
column = passedDate.getDay() row = 0
Programación de Scripts en ActionScript 53
Paréntesis
Cuando defina una función, coloque los argumentos entre paréntesis:
function myFunction (name, age, reader){
...
}
Cuando llame a una función, incluya cualquiera de los argumentos que se desean pasar a la misma entre paréntesis, como se muestra a continuación:
myFunction ("Steve", 10, true);
También puede utilizar paréntesis para cancelar el orden de precedencia de ActionScript o para hacer más legibles las sentencias de ActionScript. Consulte “Precedencia de operadores” a pagina 65.
También puede utilizar los paréntesis para evaluar una expresión a la izquierda de un punto en la sintaxis de punto. Por ejemplo, en el siguiente enunciado, los paréntesis hacen que new color(this) evalúe y cree un nuevo objeto Color:
onClipEvent(enterFrame) {
(new Color(this)).setRGB(0xffffff));
}
Si no ha utilizado paréntesis, tendrá que agregar una sentencia al código para evaluarlo:
onClipEvent(enterFrame) {
myColor = new Color(this); myColor.setRGB(0xffffff);
}
Letras en mayúsculas y minúsculas
ActionScript solamente distingue el uso de mayúsculas y minúsculas en sus palabras clave; con el resto de ActionScript puede utilizar mayúsculas y minúsculas según desee. Por ejemplo, las siguientes sentencias son equivalentes:
cat.hilite = true; CAT.hilite = true;
Sin embargo, es conveniente seguir convenciones coherentes en el uso de mayúsculas y minúsculas, como las que se utilizan en este manual, para que sea más fácil identificar los nombres de las funciones y de las variables cuando se lea el código de ActionScript.
Si no utiliza el formato correcto de mayúsculas y minúsculas con las palabras clave, puede que su script tenga errores. Cuando está activada la Sintaxis en color en el panel de Acciones, las palabras clave escritas con el formato correcto de mayúsculas y minúsculas aparecen en azul. Si desea obtener más información, consulte las secciones “Palabras clave” a pagina 55 y “Realzado y comprobación de la sintaxis” a pagina 44.
Capítulo 254
Comentarios
En el panel Acciones utilice la sentencia
comment para agregar notas a una acción
de botón o un fotograma que le faciliten el seguimiento de lo que desea que haga una acción. Los comentarios también son útiles para pasar información a otros desarrolladores cuando se trabaje en un entorno de colaboración o se proporcionen ejemplos.
Cuando elija la acción
comment, los caracteres // se insertan en el script.
Incluso un script sencillo es más fácil de entender si documenta sus notas a medida que lo crea:
on(release) { // create new Date object myDate = new Date(); currentMonth = myDate.getMonth(); // convert month number to month name monthName = calcMonth(currentMonth); year = myDate.getFullYear(); currentDate = myDate.getDat (); }
Los comentarios aparecen en rosa color en la ventana Script. Pueden ser de cualquier longitud sin afectar al tamaño del archivo exportado, y no necesitan seguir las reglas de la sintaxis o palabras clave de ActionScript.
Palabras clave
ActionScript se reserva palabras para su uso específico en el lenguaje, de modo que no se pueden utilizar como nombres de variables, de funciones ni de etiquetas. En la siguiente tabla se muestra una lista de las palabras clave de ActionScript:
break for new var
continue function return void
delete if this while
else in typeof with
Si desea obtener más información acerca de una palabra clave concreta, consulte el Capítulo 7, “Diccionario de ActionScript”.
Programación de Scripts en ActionScript 55
Constantes
Una constante es una propiedad cuyo valor nunca cambia. En la caja de herramientas Acciones y en el Capítulo 7, “Diccionario de ActionScript”, se muestra una lista de las constantes, todas en mayúsculas.
Por ejemplo, las constantes BACKSPACE, ENTER, QUOTE, RETURN, SPACE, y TAB son propiedades del objeto Key y se refieren a las teclas del teclado. Para comprobar si el usuario está presionando la tecla Intro, utilice la siguiente sentencia:
if(keycode() == Key.ENTER) {
alert = "Are you ready to play?" controlMC.gotoAndStop(5);
}

Tipos de datos

Un tipo de datos describe la clase de información que puede contener una variable o el elemento de ActionScript. Existen dos clases de tipo de datos: primitivos y de referencia. Los datos de tipo primitivo (cadena, número y Booleano) tienen un valor constante y por lo tanto pueden contener el valor real del elemento que representan. El tipo de datos de referencia (clip de película y objeto) tienen valores que pueden cambiar y por lo tanto contienen referencias al valor real del elemento. Las variables que contienen datos de tipo primitivo se comportan de modo diferente en ciertas situaciones que las que contienen datos de tipo referencia. Consulte “Utilización de las variables en un script” a pagina 62.
Cada tipo de datos tiene sus propias reglas y aparece es esta lista. Se incluyen referencias del tipo de datos que se explican con más detalle.
Cadena
Una cadena es una secuencia de caracteres tales como letras, números y signos de puntuación. Las cadenas se introducen en una sentencia de ActionScript incluyéndolas entre comillas simples o dobles. A las cadenas se les trata como caracteres en lugar de como variables. Por ejemplo, en la siguiente sentencia,
"L7" es una cadena:
favoriteBand = "L7";
Puede utilizar el operador de suma (+) para concatenar, o unir, dos cadenas. ActionScript trata los espacios del comienzo o del final de una cadena como parte literal de la cadena. La siguiente expresión incluye un espacio después de la coma:
greeting = "Welcome, " + firstName;
Capítulo 256
Aunque ActionScript no distingue entre mayúsculas y minúsculas en las referencias a variables, los nombres de instancia y las etiquetas de fotogramas, en las cadenas literales sí las distingue. Por ejemplo, las dos siguientes sentencias colocan texto diferente en las variables de campo de texto especificadas, ya que
"Hello" y "HELLO" son cadenas literales.
invoice.display = "Hello"; invoice.display = "HELLO";
Para incluir un signo de interrogación en una cadena, ponga delante el carácter de barra inversa (\). A esto se le llama “escape” de un carácter. Hay otros caracteres que no pueden representarse en ActionScript excepto por secuencias de escape especiales. La siguiente tabla muestra todos los caracteres de escape de ActionScript:
Secuencia de escape Carácter
\b
\f Carácter de salto de página (ASCII 12)
\n
\r
\t Carácter de tabulación (ASCII 9)
\"
\'
\\
\000 - \377
\x00 - \xFF
\u0000 - \uFFFF
Carácter de retroceso (ASCII 8)
Carácter de avance de línea (ASCII 10)
Carácter de retorno de carro (ASCII 13)
Comillas dobles
Comillas simples
Barra inversa
Un byte especificado en octal
Un byte especificado en hexadecimal
Un carácter Unicode de 16 bits especificado en hexadecimal
Numérico
El tipo de datos numérico es un número en coma flotante de doble precisión. Puede manipular los números utilizando los operadores aritméticos de suma (+), resta (-), multiplicación, (*), división (/), módulo (%), incremento (++) y decremento (--). También puede utilizar los métodos del objeto predefinido Math para manipular los números. El siguiente ejemplo utiliza el método
sqrt
(raíz cuadrada) para devolver la raíz cuadrada del número 100:
Math.sqrt(100);
Consulte “Operadores numéricos” a pagina 66.
Programación de Scripts en ActionScript 57
Booleano
Un valor Booleano es uno que es los valores
true y false en 1 y 0 cuando sea adecuado. Los valores booleanos se
true o false. ActionScript también convierte
usan con mayor frecuencia con los operadores lógicos en sentencias de ActionScript que realizan comparaciones para controlar el flujo de un script. Por ejemplo, en el siguiente script, la película se reproduce si la variable password es true:
onClipEvent(enterFrame) { if ((userName == true) && (password == true)){ play(); } }
Consulte “Utilización de las sentencias if” a pagina 73 y “Operadores lógicos” a pagina 67.
Objeto
Un objeto es un conjunto de propiedades. Cada propiedad tiene un nombre y un valor. El valor de la propiedad puede ser cualquier tipo de datos de Flash, incluso el tipo de datos de objeto. Esto le permite organizar los objetos unos dentro de otros, o “anidarlos”. Para especificar objetos y sus propiedades, debe utilizar el operador punto (.). Por ejemplo, en el siguiente código, hoursWorked es una propiedad de weeklyStats, que a su vez es una propiedad de employee:
employee.weeklyStats.hoursWorked
Puede utilizar los objetos predefinidos de ActionScript para acceder y manipular tipos de información específicos. Por ejemplo, el objeto Math tiene métodos que realizan operaciones matemáticas con los números que le pasan. Este ejemplo utiliza el método sqrt:
squareRoot = Math.sqrt(100);
El objeto MovieClip de ActionScript tiene métodos que le permiten controlar las instancias del símbolo de clip de película en el Escenario. Este ejemplo, utiliza los métodos play y nextFrame:
mcInstanceName.play(); mc2InstanceName.nextFrame();
También puede crear sus propios objetos de modo que pueda organizar la información de su película. Para agregar interactividad a una película con ActionScript, necesitará varios elementos de información diferentes: por ejemplo, puede que necesite un nombre de usuario, la velocidad de una pelota, los nombres de los elementos en un carrito de la compra, el número de fotogramas cargados, el código postal del usuario y qué tecla se presionó en último lugar. La creación de objetos personalizados le permite organizar esta información en grupos, simplificando la creación de scripts y su reutilización. Si desea obtener más información, consulte “Utilización de objetos personalizados” a pagina 85.
Capítulo 258
Clip de película
Los clips de película son símbolos que pueden contener y ejecutar una animación en una película de Flash. Son el único tipo de datos que hacen referencia a elementos gráficos. El tipo de datos de clip de película le permite controlar los símbolos del clip de películas utilizando los métodos del objeto MovieClip. Puede llamar a los métodos utilizando el operador punto (.) como se muestra a continuación:
myClip.startDrag(true); parentClip.childClip.getURL( "http://www.macromedia.com/support/"
+ product);

Acerca de las variables

Una variable es un contenedor que almacena información. El contenedor en sí es siempre el mismo, pero el contenido puede cambiar. La modificación del valor de una variable a medida que se reproduce la película permite registrar y guardar información sobre las acciones del usuario, registrar valores que se modifican conforme se reproduce la película o evaluar si una determinada condición es verdadera o falsa.
Es bastante útil asignar a una variable un valor conocido la primera vez la defina. Esto se llama inicializar una variable y a menudo se hace en el primer fotograma de una película. Inicializar las variables hace que sea más sencillo realizar el seguimiento y comparar el valor de la variable a medida que se reproduce la película.
Las variables pueden contener cualquier tipo de datos: número, cadena, Booleano, objeto o clip de película. El tipo de datos que contiene una variable afecta al modo en el que cambia el valor de la variable cuando se le asigna en un script.
El tipo de información normal que suele guardarse en una variable incluye una URL, un nombre de usuario, el resultado de una operación matemática, el número de veces que ocurre un evento o si se ha hecho clic en un botón. Cada película e instancia de clip de película tiene su propio conjunto de variables, cada una de ellas con su propio valor independiente de otras variables definidas en otras películas o clips de película.
Asignación de nombre para una variable
El nombre de una variable debe seguir estas reglas:
Debe ser un identificador.
No puede ser una palabra clave o un literal Booleano (true o false).
Debe ser exclusivo dentro de su ámbito. (Consulte “Ámbito de una variable” a
pagina 61).
Programación de Scripts en ActionScript 59
Determinación del tipo de variable
En Flash, no tiene que definir explícitamente una variable de forma que contenga un número, una cadena u otro tipo de datos. Flash determina el tipo de datos de una variable cuando se asigna un valor a la misma:
x = 3;
En la expresión x = 3 Flash evalúa el elemento de la parte derecha del operador y determina que es del tipo número. Una asignación posterior puede cambiar el tipo de x; por ejemplo, x = "hello" cambia el tipo de x a una cadena. Una variable a la que no se ha asignado un valor tiene el tipo de undefined.
ActionScript convierte los tipos de datos automáticamente cuando lo requiere una expresión. Por ejemplo, cuando pasa un valor a la acción trace, trace automáticamente convierte el valor en una cadena y la envía a la ventana Salida. En las expresiones con operadores, ActionScript convierte los tipos de datos según sea necesario; por ejemplo, cuando se utiliza con una cadena, el operador + espera que el otro operando sea una cadena:
"Next in line, number " + 7
ActionScript convierte el número 7 en la cadena "7" y la agrega al final de la primera cadena, lo que da como resultado la siguiente cadena:
"Next in line, number 7"
Cuando se depuran scripts, con frecuencia es muy útil determinar el tipo de datos de una expresión o variable para entender por qué se comporta de cierta manera. Puede realizar esto por medio del operador typeof como en el siguiente ejemplo:
trace(typeof(variableName));
Para convertir una cadena en un valor numérico, utilice la función Number. Para convertir un valor numérico en una cadena, utilice la función String. Consulte el Capítulo 7, “Diccionario de ActionScript” a pagina 175.
Capítulo 260
Ámbito de una variable
El “ámbito” de una variable se refiere al área en la que se conoce y se puede hacer referencia a ella. Las variables en ActionScript pueden ser globales o locales. Una variable global se comparte por todas las Líneas de tiempo, mientras que una variable local sólo está disponible dentro de su propio bloque de código (entre corchetes).
Puede utilizar la sentencia var para declarar una variable local dentro de un script. Por ejemplo, las variables i y j con frecuencia se utilizan como contadores de bucles. En el siguiente ejemplo, i se utiliza como la variable local, solamente existe dentro de la función makeDays:
function makeDays(){
var i for( i = 0; i < monthArray[month]; i++ ) {
_root.Days.attachMovie( "DayDisplay", i, i + 2000 );
_root.Days[i].num = i + 1; _root.Days[i]._x = column * _root.Days[i]._width; _root.Days[i]._y = row * _root.Days[i]._height;
column = column + 1;
if (column == 7 ) {
column = 0; row = row + 1;
}
}
}
Las variables locales también pueden evitar los conflictos ocasionados por la utilización de los mismos nombres en diferentes variables, que pueden originar errores en su película. Por ejemplo, si utiliza name como una variable local, podría utilizarla para almacenar un nombre de usuario en un contexto y el nombre de una instancia de un clip de película en otro; como estas variables se ejecutarán en ámbitos independientes, no se presentaría conflicto alguno.
Es usual y recomendable utilizar variables locales en el contexto de una función de modo que ésta pueda actuar como un segmento de código independiente. Una variable local solamente puede cambiar dentro de su propio bloque de código. Si la expresión contenida en una función utiliza una variable global, algo externo a la función podría modificar su valor, lo cual cambiaría la función.
Programación de Scripts en ActionScript 61
Declaración de variables
Para declarar variables globales, utilice la acción
setVariables o el operador de
asignación (=). Ambos métodos consiguen el mismo resultado.
Para declarar una variable local, utilice la sentencia
var dentro de una función. El
ámbito de las variables locales es el contexto del bloque de código y expiran al final del mismo. Las variables locales que no han sido declaradas dentro de un bloque de código expiran cuando finaliza el script en que se utilizan.
Nota:
La acción call también crea el ámbito de una nueva variable local y que está constituido por el script al que llama. Cuando se sale del script que llamó, desaparece el ámbito de esta variable local. Sin embargo, esto no es recomendable ya que la acción
call ha sido sustituida por la acción with que es más compatible con la sintaxis de punto.
Para comprobar el valor de una variable, utilice la acción trace para enviar el valor a la ventana Salida. Por ejemplo, trace(hoursWorked) envía el valor de la variable hoursWorked a la ventana Salida en el modo probar película. También puede comprobar y establecer los valores de las variables en el Depurador en el modo probar película. Para obtener más información, consulte el Capítulo 6, “Resolución de problemas de ActionScript.”
Utilización de las variables en un script
Debe declarar una variable en un script antes de poder utilizarla en una expresión. Si utiliza una variable que no ha sido declarada, como en el siguiente ejemplo, el valor de la variable estará
getURL(myWebSite); myWebSite = "http://www.shrimpmeat.net";
undefined y su script generará un error:
La sentencia que declara la variable myWebSite debe ir al principio de modo que la variable de la acción getURL pueda ser sustituida por un valor.
El valor de una variable puede cambiar muchas veces en un script. El tipo de datos que contiene la variable afecta a cómo y cuándo cambia la misma. Las variables que contienen datos de tipo primitivo, como son las cadenas y números, se pasan basados en su valor. Esto quiere decir se pasa a la variable el contenido real de la misma.
En el siguiente ejemplo, x está establecida en 15 y ese valor se copia en y. Cuando
x se cambia a 30, el valor de y sigue siendo 15 ya que y no busca en x su valor, sino
que contiene el valor de x que se le pasó.
var x = 15; var y = x; var x = 30;
Capítulo 262
Otro ejemplo, es el caso en que la variable in contiene un valor primitivo de 9, de modo que el valor real se pasa a la función
function sqrt(x){ return x * x; }
var in = 9; var out = sqr(in);
sqrt y el valor que devuelve es 3:
El valor de la variable in no cambia.
Los datos de tipo objeto pueden contener una cantidad de información tan compleja y grande que una variable cuyo contenido es este tipo de dato no contiene el valor real, contiene una referencia al valor. Esta referencia es como un alias que apunta al contenido de la variable. Cuando la variable necesita conocer su valor, la referencia solicita el contenido y devuelve la respuesta sin transferir el valor a la variable.
A continuación se muestra un ejemplo en el que se pasa un valor por referencia:
var myArray = ["tom", "dick"]; var newArray = myArray; myArray[1] = "jack"; trace(newArray);
El código anterior crea un objeto Array llamado myArray que tiene dos elementos. Se crea la variable newArray y se pasa una referencia a myArray. Cuando el segundo elemento de myArray cambia, afectará a cualquier variable que haga referencia al mismo. La acción trace enviaría ["tom", "jack"] a la ventana Salida.
En el siguiente ejemplo, myArray contiene un objeto Array, de modo que se pasa a la función zeroArray por referencia. La función zeroArray cambia el contenido de la matriz en myArray.
function zeroArray (array){ var i; for (i=0; i < array.length; i++) { array[i] = 0; } }
var myArray = new Array(); myArray[0] = 1; myArray[1] = 2; myArray[2] = 3;
var out = zeroArray(myArray)
Programación de Scripts en ActionScript 63
La función zeroArray acepta como argumento un objeto Array y establece todos los elementos del mismo en 0. Puede modificar la matriz ya que sus valores se pasan a través de una referencia.
Las referencias a todos los objetos excepto a los clips de película reciben el nombre de referencias fijas debido a que no se puede borrar el objeto al que se hace referencia. Una referencia a un clip de película es un tipo especial de referencia llamada una referencia variable. Las referencias variables no obligan a que exista el objeto al que hacen referencia. Si se destruye un clip de película con una acción como removeMovieClip, cualquier referencia a él ya no funcionará.

Utilización de operadores para manipular los valores de las expresiones

Una expresión es cualquier sentencia que Flash puede evaluar y que devuelve un valor. Puede crear una expresión combinando operadores y valores, o bien llamando a una función. Cuando escribe una expresión en el panel Acciones en Modo Normal, asegúrese de que el cuadro Expresión se encuentra marcado en el panel Parámetros, en caso contrario el campo contendrá el valor literal de una cadena.
Cuadro Expresión
Capítulo 264
Los operadores son caracteres que especifican cómo combinar, comparar o modificar los valores de una expresión. Los elementos sobre los que el operador actúa se llaman operandos. Por ejemplo, en la siguiente sentencia, el operador + agrega el valor de un literal numérico al valor de la variable foo; foo y 3 son los operandos:
foo + 3
En esta sección se describen las reglas generales sobre los tipos de operadores más comunes. Para obtener información detallada sobre cada operador que se menciona aquí, y sobre los operadores especiales que no se cubren en esta sección, consulte el Capítulo 7, “Diccionario de ActionScript”.
Precedencia de operadores
Cuando se utilizan dos o más operadores en la misma sentencia, algunos operadores toman precedencia sobre otros. ActionScript sigue una jerarquía muy estricta para determinar qué operadores deben ejecutarse en primer lugar. Por ejemplo, la multiplicación siempre se realiza antes que la suma; sin embargo, los elementos entre paréntesis tienen precedencia sobre la multiplicación. De modo que, sin paréntesis, ActionScript realiza primero la multiplicación en el ejemplo siguiente:
total = 2 + 4 * 3;
El resultado es 14.
Pero cuando la operación de suma está entre paréntesis, ActionScript realiza la suma en primer lugar:
total = (2 + 4) * 3;
El resultado es 18.
Si desea ver una tabla con todos los operadores y su precedencia, consulte el Apéndice B, “Precedencia de operadores y su asociatividad”.
Asociatividad de operadores
Cuando dos o más operadores comparten la misma precedencia, su asociatividad determina el orden en el que se llevan a cabo. La asociatividad puede ser de izquierda a derecha o de derecha a izquierda. Por ejemplo, el operador de multiplicación tiene una asociatividad de izquierda a derecha, las dos sentencias siguientes son equivalentes:
total = 2 * 3 * 4; total = (2 * 3) * 4;
Si desea ver una tabla con todos los operadores y su asociatividad, consulte el Apéndice B, “Precedencia de operadores y su asociatividad”.
Programación de Scripts en ActionScript 65
Operadores numéricos
Los operadores numéricos realizan sumas, restas, multiplicaciones, divisiones y otras operaciones aritméticas. Los paréntesis y el signo menos son operadores aritméticos. En la tabla siguiente se muestran los operadores numéricos de ActionScript:
Operador Operación realizada
+ Suma
* Multiplicación
/ División
% Módulo
- Resta
++ Incremento
-- Decremento
Operadores de comparación
Los operadores de comparación comparan los valores de las expresiones y devuelven un valor Booleano (true o false). Estos operadores se utilizan con mayor frecuencia en los bucles y en las sentencias condicionales En el ejemplo siguiente, si la variable score es 100, se carga cierta película; en caso contrario se carga una película diferente:
if (score == 100){
loadMovie("winner.swf", 5);
} else {
loadMovie("loser.swf", 5); }
En la tabla siguiente se muestran los operadores de comparación de ActionScript:
Operador Operación realizada
< Menor que
> Mayor que
<= Menor que o igual
>= Mayor que o igual
Capítulo 266
Operadores de cadena
El operador
+ tiene un efecto especial cuando se aplica sobre cadenas: concatena
los operandos de las dos cadenas. Por ejemplo, las sentencia siguiente agrega:
"Congratulations, " a "Donna!": "Congratulations, " + "Donna!"
El resultado es "Congratulations, Donna!" Si solamente uno de los operandos del operador + es una cadena, Flash convierte el otro operando en una cadena.
Los operadores de comparación, >, >=, <, y <= también tienen un efecto especial cuando actúan sobre cadenas. Estos operadores comparan dos cadenas para determinar cuál es la primera de acuerdo a su orden alfabético. Los operadores de comparación solamente comparan cadenas si ambos operandos son cadenas. Si solamente uno de los operandos es una cadena, ActionScript convierte los números y realiza una comparación numérica.
Nota:
Los tipos de datos que maneja ActionScript de Flash 5 permite que se utilicen los mismos operadores en diferentes tipos de datos. Ya no es necesario utilizar los operadores de cadenas de Flash 4 (por ejemplo, scripts como una película de Flash 4.
eq, ge, y lt) a no ser que se planee exportar los
Operadores lógicos
Los operadores lógicos comparan los valores Booleanos (true y false) y devuelven un tercer valor Booleano. Por ejemplo, si ambos operandos evalúan como true, el operador lógico AND (&&) devuelve true. Si uno o ambos operandos evalúan como true, el operador lógico OR (||) devuelve false. Los operadores lógicos se utilizan con frecuencia junto con los operadores de comparación para determinar la condición de una acción if. Por ejemplo, en el siguiente script, si ambas expresiones son verdaderas, la acción if se ejecutará:
if ((i > 10) && (_framesloaded > 50)){
play()
}
En la siguiente tabla se muestra una lista de los operadores lógicos de ActionScript:
Operador Operación realizada
&& AND lógico
|| OR lógico
! NOT lógico
Programación de Scripts en ActionScript 67
Operadores como bit
Los operadores como bit manipulan internamente los números en coma flotante para convertirlos en números enteros de 32 bits, con los que es más sencillo trabajar. La operación precisa como bit que se realizará depende del operador, pero todas las operaciones como bit evalúan cada dígito de un número en coma flotante para calcular un nuevo valor.
En la siguiente tabla se muestran los operadores como bit de ActionScript:
Operador Operación realizada
& And como bit
| Or como bit
^ Xor como bit
~ Not como bit
<< Desplazamiento a la izquierda
>> Desplazamiento a la derecha
>>> Desplazamiento a la derecha rellenando con ceros
Operadores de igualdad y de asignación
Puede utilizar el operador de igualdad (==) para determinar si los valores o las identidades de dos operandos son iguales. Esta comparación devuelve un valor Booleano (true o false). Si los operandos son cadenas, números o valores Booleanos, se comparan en base a su valor. Si los operandos son objetos o matrices, se comparan por referencia.
Puede utilizar el operador de asignación (
=) para asignar un valor a una variable,
como se muestra a continuación:
contraseña = “Sk8tEr”;
También puede utilizar el operador de asignación para asignar valores a múltiples variables en la misma expresión. En la siguiente sentencia, el valor de b se asigna a las variables c y d:
a = b = c = d;
También puede utilizar operadores de asignación compuestos para combinar operaciones. Los operadores compuestos actúan sobre los dos operandos y después asignan un nuevo valor al primer operando. Por ejemplo, las dos siguientes sentencias son equivalentes:
x += 15; x = x + 15;
Capítulo 268
En la siguiente tabla se muestra una lista de los operadores de igualdad y de asignación de ActionScript:
Operador Operación realizada
== Igualdad
!= No igualdad
= Asignación
+= Suma y asignación
-= Resta y asignación
*= Multiplicación y asignación
%= Módulo y asignación
/= División y asignación
<<= Desplazamiento a la izquierda como bit y asignación
>>= Desplazamiento a la derecha como bit y asignación
>>>= Desplazamiento a la derecha rellenando con ceros y asignación
^= Xor como bit y asignación
|= Or como bit y asignación
&= And como bit y asignación
Operadores punto y de acceso a una matriz
Puede utilizar el operador de punto (.) y el operador de acceso a una matriz ([]) para acceder a cualquiera de las propiedades del objeto predeterminadas o personalizadas de ActionScript, incluyendo las de un clip de película.
El operador de punto utiliza el nombre de un objeto a su lado izquierdo y el nombre de una propiedad o variable a su lado derecho. El nombre de la propiedad o la variable no puede ser una cadena o una variable que evalúe en una cadena, debe ser un identificador. A continuación se muestran ejemplos que utilizan el operador de punto:
year.month = "June"; year.month.day = 9;
Programación de Scripts en ActionScript 69
El operador de punto y el operador de acceso a una matriz se comportan de la misma manera, pero el
operador de punto toma un identificador como su
propiedad y el operador de acceso a una matriz evalúa su contenido respecto a un nombre y después accede al valor de esa propiedad con nombre. Por ejemplo, las siguientes dos líneas de código acceden a la misma variable
velocity en el clip
de película rocket:
rocket.velocity; rocket["velocity"];
Puede utilizar el operador de acceso a una matriz para establecer y recuperar dinámicamente nombres de instancias y variables. Por ejemplo, en el código que se muestra a continuación, la expresión dentro del operador
[] se evalúa y
el resultado de la evaluación se utiliza como nombre de la variable que se va a recuperar del clip de película name:
name["mc" + i ]
Si está familiarizado con la sintaxis de diagonal de ActionScript de Flash 4, puede que haya hecho lo mismo utilizando la función eval, como se muestra a continuación:
eval("mc" & i);
El operador de acceso a una matriz también puede utilizarse al lado izquierdo de una sentencia de asignación. Esto le permite establecer dinámicamente los nombres de sentencia, de variable y de objeto, como se muestra en el ejemplo siguiente:
name[index] = "Gary";
De nuevo, esto es equivalente a la sintaxis de diagonal de ActionScript de Flash 4 que se muestra a continuación:
Set Variable: "name:" & index = "Gary"
El operador de acceso a una matriz también puede anidarse en sí mismo para simular matrices multidimensionales.
chessboard[row][column]
Esto es equivalente a la sintaxis de barra que se muestra a continuación:
eval("chessboard/" & row & ":" & column)
Nota:
Si desea escribir un ActionScript que sea compatible con Flash Player 4, puede utilizar la acción
Capítulo 270
eval con el operador add.

Uso de acciones

Las acciones son sentencias o comandos de ActionScript. Si se asignan varias acciones al mismo fotograma u objeto se crea un script. Las acciones pueden actuar independientemente unas de otras, como se muestra en las siguientes sentencias:
swapDepths("mc1", "mc2"); gotoAndPlay(15);
También puede anidar acciones utilizando una acción dentro de otra, esto permite que las acciones afecten unas a las otras. En el siguiente ejemplo, la acción if dice a la acción gotoAndPlay cuándo debe ejecutarse:
if (i >= 25) {
gotoAndPlay(10);
}
Las acciones pueden mover la cabeza lectora en la Línea de tiempo (gotoAndPlay), controlar el flujo de un script creando bucles (do while) o lógica condicional (if), o crear nuevas funciones y variables (function, setVariable). En la siguiente tabla se muestra una lista de las acciones de ActionScript:
Acciones
break evaluate include print stopDrag
call for loadMovie printAsBitmap swapDepths
comment for...in loadVariables removeMovieClip tellTarget
continue fsCommand nextFrame
nextScene
delete function on setVariable stopDrag
do...while getURL onClipEvent setProperty trace
duplicateMovie Clip
else if prevFrame stop var
else if ifFrameLoaded prevScene stopAllSounds while
gotoAndPlay gotoAndStop
play startDrag unloadMovie
return toggleHighQual
ity
Si desea ver ejemplos de la sintaxis y de la utilización de cada acción, consulte el Capítulo 7, “Diccionario de ActionScript”.
Nota:
En este manual, el término action de ActionScript es sinónimo del término
statement de JavaScript.
Programación de Scripts en ActionScript 71
Programación de una ruta de destino
Para utilizar una acción a fin de controlar un clip de película o una película que ha sido cargada, debe especificar su nombre y su dirección, llamada ruta de destino. Las siguientes acciones toman una o más rutas de destino como argumentos:
loadMovie
loadVariables
unloadMovie
setProperty
startDrag
duplicateMovieClip
removeMovieClip
print
printAsBitmap
tellTarget
Por ejemplo, la acción loadMovie toma los argumentos URL, Location, y
Variables. La dirección URL es la ubicación en la Web de la película que desea
cargar. Location es la ruta de destino en la que se cargará la película.
loadMovie(URL, Location, Variables);
Nota:
El argumento Variables no es necesario para este ejemplo.
La siguiente sentencia carga la dirección URL http://www.mySite.com/
myMovie.swf en la instancia bar en la Línea de tiempo principal, _root; _root.bar es la ruta de destino;
loadMovie("http://www.mySite.com/myMovie.swf", _root.bar);
En ActionScript se identifica a un clip de película por su nombre de instancia. Por ejemplo, en la siguiente sentencia, la propiedad _alpha del clip de película llamado star está establecida a un 50% de visibilidad:
star._alpha = 50;
Dar un nombre de instancia a un clip de película:
1 Seleccione el clip de película en el Escenario.
2 Seleccione Ventana > Paneles > Instancia.
3 Introduzca un nombre de instancia en el campo Nombre.
Capítulo 272
Para identificar una película que ha sido cargada:
Utilice _levelX donde X es el número de nivel especificado en la acción
loadMovie que cargó la película.
Por ejemplo, una película que ha sido cargada en el nivel 5 tiene el nombre de instancia _level5. En el siguiente ejemplo, se carga una película en el nivel 5 y su visibilidad está establecida como falsa:
onClipEvent(load) { loadMovie("myMovie.swf", 5); } onClipEvent(enterFrame) {
_level5._visible = false;
}
Para introducir una ruta de destino de película:
Haga clic sobre el botón Insertar ruta de destino en el panel Acciones y seleccione un clip de película de la lista que se muestra.
Si desea obtener más información sobre cómo escribir rutas de destino, consulte el Capítulo 4, “Trabajo con clips de película”.

Control de los scripts de flujo

ActionScript utiliza las acciones if, for, while, do...while, y for...in para realizar una acción dependiendo de si se da una condición.
Utilización de las sentencias if
Las sentencias que comprueban si una condición es verdadera o falsa comienzan con el término if. Si la condición se da, ActionScript ejecuta la sentencia que aparece a continuación de la misma. Si la condición no se da, ActionScript salta a la siguiente sentencia en el bloque de código.
Para optimizar el rendimiento de su código, compruebe primero las condiciones más probables.
Las siguientes sentencias comprueban varias condiciones. El término else if especifica comprobaciones alternativas que se deberán llevar a cabo si las condiciones anteriores son falsas.
if ((password == null) || (email == null)){
gotoAndStop("reject");
} else {
gotoAndPlay("startMovie");
}
Programación de Scripts en ActionScript 73
Repetición de una acción
ActionScript puede repetir una acción un número especificado de veces o mientras se dé una condición. Utilice las acciones while, do...while, for, y for...in para crear bucles.
Para repetir una acción mientras se dé una condición:
Utilice la sentencia while.
Un bucle while evalúa una expresión y ejecuta el código del bucle si la expresión es true. Después de que se ha ejecutado cada sentencia del bucle, la expresión se evalúa de nuevo. En el siguiente ejemplo, el bucle se ejecuta cuatro veces:
i = 4 while (i > 0) {
myMC.duplicateMovieClip("newMC" + i, i ); i --;
}
Puede utilizar la sentencia do...while para crear el mismo tipo de bucle como el de un bucle while. En un bucle do...while la expresión se evalúa al final del segmento de código de modo que el bucle siempre se ejecuta al menos una vez, como se muestra a continuación:
i = 4 do {
myMC.duplicateMovieClip("newMC" +i, i ); i --;
} while (i > 0);
Para repetir una acción utilizando un contador incorporado:
Utilice la sentencia for.
La mayoría de los bucles utilizan algún tipo de contador para controlar cuantas veces se ejecuta el bucle. Puede declarar una variable y escribir una sentencia que incremente o disminuya el valor de la variable cada vez que se ejecute el bucle. En la acción for, el contador y la sentencia que incrementa el contador son parte de la acción, como se muestra a continuación:
for (i = 4; i > 0; i--){
myMC.duplicateMovieClip("newMC" + i, i + 10);
}
Capítulo 274
Para que se realice el bucle a través de los subniveles de un clip de película u objeto:
Utilice la sentencia for...in.
Los subniveles incluyen otros clips de películas, funciones, objetos y variables. El siguiente ejemplo utiliza trace para imprimir sus resultados en la ventana Salida:
myObject = { name:'Joe', age:25, city:'San Francisco' }; for (propertyName in myObject) { trace("myObject has the property: " + propertyName + ", with the
value: " + myObject[propertyName]); }
Este ejemplo produce los siguientes resultados en la ventana Salida:
myObject has the property: name, with the value: Joe myObject has the property: age, with the value: 25 myObject has the property: city, with the value: San Francisco
Puede que desee que su script se repita sobre un tipo de subnivel en particular: por ejemplo, solamente sobre el clip de película secundario. Puede hacer esto con for...in junto con el operador typeof.
for (name in myMovieClip) { if (typeof (myMovieClip[name]) == "movieclip") { trace("I have a movie clip child named " + name); } }
Nota:
La sentencia for...in se repite sobre las propiedades de los objetos que forman parte de la cadena prototipo del objeto sobre el que se está efectuando la repetición. Si el prototipo de un objeto secundario es propiedades de
parent. Consulte “Definición de herencia” a pagina 86.
parent, for...in también se repetirá en las
Si desea obtener más información sobre cada acción, consulte el Capítulo 7, “Diccionario de ActionScript”.
Programación de Scripts en ActionScript 75

Utilización de las funciones predefinidas

Una función es un bloque de código de ActionScript que puede volver a utilizarse en cualquier parte de una película. Si pasa valores específicos llamados argumentos a una función, la función actuará sobre esos valores. Una función también puede devolver valores. Flash dispone de funciones predeterminadas que le permiten acceder a cierta información y realizar ciertas tareas, como la detección de choque (hitTest), la obtención del valor de la última tecla presionada (keycode), y la obtención del número de versión de Flash Player que contiene la película (getVersion).
Llamada a una función
Puede llamar a una función de cualquier Línea de tiempo desde cualquier Línea de tiempo, incluida una película que ha sido cargada. Cada función tiene sus propias características y algunas necesitan que se le pasen ciertos valores. Si se le pasan más argumentos de los que necesita la función, los valores sobrantes se ignorarán. Si no se le pasa un argumento necesario, los argumentos vacíos se asignarán al tipo de datos undefined, que puede causar errores cuando exporte un script. Para llamar a una función, ésta debe encontrase en un fotograma al que haya llegado la cabeza lectora.
Las funciones predeterminadas de Flash se enumeran en la siguiente tabla:
Boolean getTimer isFinite newline scroll
escape getVersion isNaN number String
eval globalToLocal keycode parseFloat targetPath
false hitTest localToGlobal parseInt true
getProperty int maxscroll random unescape
Nota:
Las funciones de cadena no están aprobadas y no aparecen en la lista de la
anterior.
tabla
Para llamar a una función en Modo Experto:
Utilice el nombre de la función. Pase cualquiera de los argumentos necesarios entre paréntesis.
El siguiente ejemplo llama a la función initialize que no requiere argumentos:
initialize();
Capítulo 276
Para llamar a una función en Modo Normal:
Utilice la acción evaluate. Introduzca el nombre de la función y cualquier argumento necesario en el campo Expresión.
Utilice la acción evaluate para llamar a una función en Modo Normal
Para llamar a una función en otra Línea de tiempo utilice una ruta de destino. Por ejemplo, para llamar a la función calculateTax que se declaró en la instancia
functionsMovieClip, utilice la siguiente ruta:
_root.functionsMovieClip.calculateTax(total);
Nota:
Pase cualquiera de los argumentos entre paréntesis.
Si desea obtener más información sobre cada función, incluidas las funciones de cadena no aprobadas, consulte el Capítulo 7, “Diccionario de ActionScript”.
Programación de Scripts en ActionScript 77

Creación de funciones personalizadas

Puede definir funciones para que éstas ejecuten una serie de sentencias en función de los valores que se le han pasado. Sus funciones también pueden devolver valores. Una vez que se ha definido una función, podrá realizar una llama a la misma desde cualquier Línea de tiempo, incluida la Línea de tiempo de una película que ha sido cargada.
Se puede pensar en una función como si fuera una “caja negra”: al realizar una llama a una función, se deberá proporcionar con entrada (argumentos). La función realizará alguna operación y después generará un resultado (un valor de retorno). Una función escrita correctamente debe incluir comentarios bien situados acerca de los valores de entrada, su resultado y su propósito. De este modo, el usuario de la función no tendrá que entender exactamente cómo actúa la función.
Definición de una función
Las funciones, al igual que las variables, están vinculadas al clip de película que las define. Cuando se vuelve a definir una función, la nueva definición sustituye a la definición anterior.
Para definir una función, utilice la acción la función, los argumentos que va a pasar a la función y las sentencias de ActionScript que indican lo que hace la acción.
A continuación se muestra una función llamada Circle con el argumento
radius:
function Circle(radius) {
this.radius = radius; this.area = Math.PI * radius * radius;
}
function seguida del nombre de
Nota:
La palabra clave this, utilizada en el cuerpo de una función, hace referencia al clip de película al que pertenece la función.
También puede definir la función creando una expresión literal de función. Una expresión literal de función es una función sin nombre que se declara en una expresión en lugar de en una sentencia. Puede utilizar la expresión literal de una función para definir una función, para devolver su valor y asignarlo a una variable en una expresión, como se muestra a continuación:
area = (function () {return Math.PI * radius *radius;})(5);
Capítulo 278
Pasar argumentos a una función
Los argumentos son los elementos sobre los que una función ejecuta su código. (En este manual, los términos argumento y parámetro pueden intercambiarse.) Por ejemplo, la función siguiente toma los argumentos initials y finalScore:
function fillOutScorecard(initials, finalScore) {
scorecard.display = initials; scorecard.score = finalScore;
}
Cuando se llama a la función, los argumentos que ésta necesita deberán pasarse a la misma. La función sustituye los valores pasados por los argumentos en la definición de la función. En este ejemplo, scorecard es el nombre de instancia de un clip de película; display y score son campos de texto de entrada en la instancia. La siguiente llamada a una función asigna a la variable display el valor "JEB" y a la variable score el valor 45000:
fillOutScorecard("JEB", 45000);
El argumento initials en la función fillOutScorecard es similar a una variable local, existe mientras que se llama a la función y deja de existir cuando se sale de la función. Si omite los argumentos durante la llamada a una función, los argumentos omitidos se pasan como undefined. Si introduce argumentos de más en una llamada a una función que no son necesarios para la declaración de la función, éstos se ignorarán.
Utilización de variables locales en una función
Las variables locales son herramientas muy valiosas para organizar el código y hacer que sea más sencillo de entender. Cuando una función utiliza variables locales, la función puede ocultar sus variables de todos los demás scripts de la película, las variables locales tienen su ámbito en el cuerpo de la función y se destruyen cuando se sale de la función. Cualquiera de los argumentos que se pasen a una función también se tratarán como variables locales.
Nota:
Si modifica las variables locales de una función, utilice los comentarios de script para documentar estas modificaciones.
Programación de Scripts en ActionScript 79
Devolución de valores de una función
Puede utilizar la función
return detiene la función y la sustituye con el valor de la acción return. Si Flash
return para devolver valores de las funciones. La acción
no encuentra una acción return antes del final de una función, devolverá una cadena vacía. Por ejemplo, la siguiente función devuelve el cuadrado del argumento x:
function sqr(x) {
return x * x;
}
Algunas funciones realizan una serie de tareas sin devolver un valor. Por ejemplo, la siguiente función inicializa una serie de variables globales:
function initialize() {
boat_x = _root.boat._x; boat_y = _root.boat._y; car_x = _root.car._x; car_y = _root.car._y;
}
Llamada a una función
Para invocar una función utilizando el panel Acciones en Modo Normal, utilice la acción evaluate. Pase los argumentos necesarios entre paréntesis. Puede llamar a una función de cualquier Línea de tiempo desde cualquier Línea de tiempo, incluida una película que ha sido cargada. Por ejemplo, la siguiente sentencia invoca a la función sqr del clip de película MathLib de la Línea de tiempo principal, le pasa el argumento 3 y almacena el resultado en la variable temp:
var temp = _root.MathLib.sqr(3);
En Flash 4, para simular la llamada a una función podría escribir un script en un fotograma después del final de la película e invocarle pasando el nombre de la etiqueta del fotograma a la acción call. Por ejemplo, si el script que inicializó las variables se encontraba en un fotograma con la etiqueta initialize, la llamada se realizaría como se muestra a continuación:
call("initialize");
Este tipo de script no era una verdadera función ya que no podría aceptar argumentos y no podría devolver un valor. Aunque la acción call aún funciona en Flash 5, no se recomienda su utilización.
Capítulo 280

Utilización de objetos predefinidos

Puede utilizar los objetos predefinidos de Flash para acceder a ciertos tipos de información. La mayoría de los objetos predefinidos tienen métodos (funciones asignadas a un objeto) que puede llamar para devolver un valor o para realizar una acción. Por ejemplo, el objeto Date devuelve información del reloj del sistema y el objeto Sound le permite controlar los elementos de sonido de su película.
Algunos objetos predefinidos tienen propiedades cuyos valores pueden ser leídos por la misma. Por ejemplo, el objeto Key tiene valores constantes que representan teclas del teclado. Cada objeto tiene sus propias características y capacidades que pueden utilizarse en su película.
A continuación se muestran los objetos predefinidos de Flash:
Array
Boolean
Color
Date
Key
Math
MovieClip
Number
Object
Selection
Sound
String
XML
XMLSocket
Las instancias de clip de película se representan como objetos en ActionScript. Las llamadas a los métodos de clip de película predefinidos se pueden efectuar del mismo modo que como llamaría a los métodos de cualquier otro objeto de ActionScript.
Si desea obtener información detallada sobre cada objeto, consulte el Capítulo 7, “Diccionario de ActionScript”.
Programación de Scripts en ActionScript 81
Creación de un objeto
Existen dos modos de crear un objeto: el operador de objeto (
{}). Puede utilizar el operador new para crear un objeto desde una clase
new y el operador inicializador
de objetos predefinidos o desde una clase de objetos definidos personalizados. Puede utilizar el operador inicializador de objeto ({}) para crear un objeto del tipo genérico Object.
Para utilizar el operador new a fin de crear un objeto, deberá utilizarlo con una función constructor. (Una función constructor es sencillamente una función cuyo único propósito es crear un cierto tipo de objeto.) Los objetos predefinidos de ActionScript son en esencia funciones constructor escritas previamente. El objeto nuevo instancia, o crea, una copia del objeto y le asigna todas las propiedades y métodos de ese objeto. Esto es similar a arrastrar un clip de película desde la Biblioteca hasta el Escenario en una película. Por ejemplo, las siguientes sentencias instancian un objeto Date:
currentDate = new Date();
Puede acceder a los métodos de algunos objetos predefinidos sin instanciarlos. Por ejemplo, la siguiente sentencia llama al método del objeto Math random:
Math.random();
Cada objeto que necesite una función constructor tiene su elemento correspondiente en la caja de herramientas del panel Acciones, por ejemplo,
new Color, new Date, new String, y así sucesivamente.
Para crear un objeto con el operador new en Modo Normal:
1 Seleccione setVariable
2 Introduzca un nombre de variable en el campo Nombre.
3 Introduzca new Object, new Color, y así sucesivamente en el campo Valor.
Introduzca cualquiera de los argumentos necesarios para la función constructor entre paréntesis.
4 Marque el cuadro Expresión en el campo Valor.
Si no activa el cuadro Expresión, todo el valor será un literal de cadena.
En el siguiente código, el objeto c se crea desde el constructor Color:
c = new Color(this);
Nota:
Un nombre de objeto es una variable con el tipo de datos de objeto que se le ha asignado.
Capítulo 282
Acceso a un método en Modo Normal:
1 Seleccione la acción evaluate.
2 Introduzca el nombre del objeto en el campo Expresión.
3 Introduzca una propiedad del objeto en el campo Expresión.
Utilización del operador inicializador de objeto ({}) en Modo Normal:
1 Seleccione la acción setVariable.
2 Introduzca el nombre en el campo Variable, este es el nombre del objeto nuevo.
3 Introduzca los pares nombre de propiedad y valor separados por dos puntos
dentro del operador inicializador de objeto ({}).
Por ejemplo, en esta sentencia los nombres de propiedad son radius y area y sus valores son 5 y el valor de una expresión:
myCircle = {radius: 5, area:(pi * radius * radius)};
Los paréntesis hacen que la expresión se evalúe. El valor que se devuelve es el valor de la variable area.
También puede anidar los inicializadores de matriz y de objeto, como en esta sentencia:
newObject = {name: "John Smith", projects: ["Flash", "Dreamweaver"]};
Si desea obtener información detallada sobre cada objeto, consulte el Capítulo 7, “Diccionario de ActionScript”.
Acceso a las propiedades del objeto
Utilice el operador punto (.) para acceder al valor de las propiedades en un objeto. El nombre del objeto se haya a la izquierda del punto y el nombre de la propiedad a la derecha. Por ejemplo, en la siguiente sentencia, myObject es el objeto y name es la propiedad:
myObject.name
Para asignar un valor a una propiedad en Modo Normal, utilice la acción
setVariable:
myObject.name = "Allen";
Para cambiar el valor de una propiedad, asigne un nuevo valor como se muestra a continuación:
myObject.name = "Homer";
También puede utilizar el operador de acceso a una matriz ([]) para acceder a las propiedades de un objeto. Consulte “Operadores punto y de acceso a una matriz” a pagina 69.
Programación de Scripts en ActionScript 83
Llamada a métodos de objeto
Puede llamar al método de un objeto utilizando el operador punto seguido por el método. Así, el siguiente ejemplo llama al método setVolume del objeto Sound:
s = new Sound(this); s.setVolume(50);
Para llamar al método de un objeto predefinido en Modo Normal, utilice la acción evaluate.
Utilización del objeto MovieClip
Puede utilizar los métodos del objeto predefinido MovieClip para controlar las instancias del símbolo del clip de película en el Escenario. El siguiente ejemplo dice a la instancia
dateCounter.play();
dateCounter que se ejecute:
Si desea obtener información detallada sobre el objeto MovieClip, consulte el Capítulo 7, “Diccionario de ActionScript”.
Utilización del objeto Array
El objeto Array es un objeto de ActionScript predefinido utilizado con frecuencia que almacena sus datos en propiedades numeradas en lugar de en propiedades con nombre. El nombre de un elemento de matriz se llama índice. Esto es muy útil para almacenar y recuperar ciertos tipos de información como una lista de estudiantes o una secuencia de movimientos en un juego.
Puede asignar elementos del objeto Array del mismo modo en que lo haría con la propiedad de cualquier objeto:
move[1] = "a2a4"; move[2] = "h7h5"; move[3] = "b1c3"; ... move[100] = "e3e4";
Para acceder al segundo elemento de la matriz, utilice la expresión move[2].
El objeto Array tiene una propiedad predefinida length que es el valor del número de elementos de la matriz. Cuando se asigna un elemento del objeto Array y el índice del elemento es un número entero positivo como index >= length,
length se actualiza automáticamente a index + 1.
Capítulo 284

Utilización de objetos personalizados

Puede crear objetos personalizados para organizar la información de sus scripts con el fin de almacenarlos y acceder a ellos fácilmente; para ello es necesario definir las propiedades y métodos del objeto. Después de crear un objeto maestro o “clase”, puede utilizar o “instanciar” copias (es decir, instancias) de ese objeto en una película. Esto le permite reutilizar el código y tener control sobre el tamaño del archivo.
Un objeto es un tipo de datos complejo que contiene cero o más propiedades. Cada propiedad tiene un nombre y un valor, como lo tiene una variable. Las propiedades están vinculadas al objeto y contienen los valores que pueden cambiarse y recuperarse. Estos valores pueden ser de cualquier tipo de datos: cadena, número, Booleano, clip de película o propiedades son varios tipos de datos:
customer.name = "Jane Doe" customer.age = 30 customer.member = true customer.account.currentRecord = 000609 customer.mcInstanceName._visible = true
La propiedad de un objeto también puede ser un objeto. En la línea 4 del ejemplo anterior, account es una propiedad del objeto customer y currentRecord es una propiedad del objeto account. El tipo de datos de la propiedad currentRecord es numérico.
Creación de un objeto
Puede utilizar el operador new para crear un objeto desde una función constructor. A una función constructor siempre se le da el mismo nombre que al tipo de objeto que está creando. Por ejemplo, una función constructor que creara un objeto de tipo cuenta se llamaría Account. La siguiente sentencia crea un nuevo objeto desde la función llamada MyConstructorFunction:
new MyConstructorFunction (argument1, argument2, ... argumentN);
Cuando se llama a MyConstructorFunction, Flash le pasa el argumento oculto
this, que es una referencia al objeto que está creando MyConstructorFunction.
Cuando define una función constructor, this le permite hacer referencia a los objetos que creará el constructor. Por ejemplo, a continuación se muestra una función constructor que crea un círculo:
function Circle(radius) {
this.radius = radius; this.area = Math.PI * radius * radius;
}
undefined. Las siguientes
Programación de Scripts en ActionScript 85
Las funciones constructor se usan con frecuencia para rellenar los métodos de un objeto.
function Area() {
this.circleArea = Math.PI * radius * radius;
}
Para utilizar un objeto en un script, deberá asignarlo a una variable. Para crear un nuevo objeto círculo con un radio de 5, utilice el operadornew para crear el objeto y asignarle una variable local myCircle:
var myCircle = new Circle(5);
Nota:
Los objetos tienen el mismo ámbito que la variable a la están asignados. Consulte “Ámbito de una variable” a pagina 61.
Definición de herencia
Todas las funciones tienen una propiedad prototype que se crea automáticamente cuando se define la función. Cuando utiliza una función constructor para crear un nuevo objeto, todas las propiedades y métodos de la propiedad prototype del constructor se convierten en propiedades y métodos de la propiedad __proto__ del nuevo objeto. La propiedad prototype indica los valores de la propiedad predeterminados para los objetos creados con esa función. Al hecho de pasar valores utilizando las propiedades __proto__ y
prototype se llama herencia.
La herencia se comporta de acuerdo a una jerarquía determinada. Cuando llama a la propiedad o al método de un objeto, ActionScript busca en el objeto para ver si existe tal elemento. Si no existe, ActionScript busca en la propiedad
__proto__ del objeto la información (object.__proto__). Si la propiedad
llamada no es una propiedad de objeto __proto__, Actionscript busca en
object.__proto__.__proto__.
Es bastante común asociar métodos a un objeto asignándolos a la propiedad
prototype del objeto. Los siguientes pasos describen cómo definir un método
de ejemplo:
1 Defina la función constructor Circle, como se detalla a continuación:
function Circle(radius) {
this.radius = radius
}
Capítulo 286
2
Defina el método area del objeto Circle. El método area calculará el área del círculo. Puede utilizar un literal de función para definir el método
area y
establecer la propiedad área del objeto prototipo del círculo, como se detalla a continuación:
Circle.prototype.area = function () {
return Math.PI * this.radius * this.radius
}
3
Cree una instancia del objeto Circle, como se detalla a continuación:
var myCircle = new Circle(4);
4
Llame al método area del nuevo objeto myCircle, como se detalla a continuación:
var myCircleArea = myCircle.area()
ActionScript busca el objeto myCircle para el método area. Como el objeto no tiene un método area, se busca su objeto prototipo Circle.prototype para el métodoarea. ActionScript lo encuentra y lo llama.
También puede vincular un método a un objeto anexando el método a cada instancia individual del objeto, como se muestra en este ejemplo:
function Circle(radius) {
this.radius = radius this.area = function() {
return Math.PI * this.radius * this.radius
}
}
No se recomienda esta técnica. Es más eficiente utilizar el objeto prototype, ya que solamente una definición de area es necesaria y esa definición se copia automáticamente en todas las instancias creadas por la función Circle.
La propiedad prototype está admitida en la versión 5 de Flash Player y posteriores. Si desea obtener más información, consulte el Capítulo 7, “Diccionario de ActionScript”.
Programación de Scripts en ActionScript 87

Apertura de archivos de Flash 4

ActionScript ha cambiado substancialmente en la última versión de Flash 5. Ahora se trata de un lenguaje orientado a objetos con múltiples tipos de datos y sintaxis de punto. ActionScript de Flash4 solamente tenía un tipo de datos verdadero: cadena. Utilizaba diferentes tipos de operadores en expresiones para indicar si el valor debería ser tratado como una cadena o como un número. En Flash 5, puede utilizar un conjunto de operadores sobre todos los tipos de datos.
Cuando utiliza Flash 5 para abrir un archivo creado en Flash 4, Flash automáticamente convierte las expresiones de ActionScript para hacerlas compatibles con la nueva sintaxis de Flash 5. Verá el siguiente tipo de datos y las conversiones de operador en su código de ActionScript:
El operador = en Flash 4 se utilizó para la igualdad numérica. En Flash 5, == es
el operador de igualdad y = es el operador asignado. Cualquiera de los operadores = en los archivos de Flash 4 se convierte automáticamente en ==.
Flash realiza automáticamente conversiones de tipo para asegurar que los
operadores se comportan del modo esperado. Debido a la introducción de múltiples tipos de dato, los siguientes operadores tienen nuevos significados:
+, ==, !=, <>, <, >, >=, <=
En ActionScript de Flash 4, estos operadores siempre eran operadores
numéricos. En Flash 5, se comportan de modo diferente dependiendo de los tipos de datos de los operandos. Para evitar cualquier diferencia semántica en los archivos importados, la función Number se inserta alrededor de todos los operandos de estos operadores. (Los números constantes evidentemente ya son números, de modo que no se incluyen entre Number).
En Flash 4, la secuencia de escape\n generaba un carácter de retorno de carro
(ASCII 13). En Flash 5, para cumplir el estándar ECMA-262, \n genera un carácter de avance de línea (ASCII 10). Una secuencia \n en los archivos FLA de Flash 4 se convierte automáticamente en \r.
El operador & en Flash 4 se utilizaba para la suma de cadenas. En Flash 5, & es
el operador AND como bit. El operador de suma de cadenas ahora se llama
add. Cualquiera de los operadores & en los archivos de Flash 4 se convierten
automáticamente en operadores add.
Muchas de las funciones de Flash 4 no necesitan paréntesis de cierre, por
ejemplo, Get Timer, Set Variable, Stop y Play. Para crear una sintaxis coherente, la función getTimer de Flash 5 y todas las acciones ahora requieren paréntesis de cierre. Estos paréntesis se agregan automáticamente durante la conversión.
Capítulo 288
Cuando la función getProperty se ejecuta en un clip de película que no existe,
devuelve el valor
false en ActionScript de Flash 5. Flash soluciona este problema cuando
es convierte los archivos de Flash 4 introduciendo funciones Number en las comparaciones de igualdad. En el siguiente ejemplo, Number hace que
undefined se convierta en 0 de modo que la comparación sea efectiva:
getProperty("clip", _width) == 0 Number(getProperty("clip", _width)) == Number(0)
Nota:
Si ha utilizado cualquiera de las palabras clave de Flash 5 en el ActionScript de Flash 4, la sintaxis devolverá un error en Flash 5. Para solucionarlo, cambie el nombre de sus variables en todas las ubicaciones. Consulte “Palabras clave” a pagina 55.
undefined, no devuelve 0, en Flash 5. Y undefined == 0
Utilización de Flash 5 para crear contenidos de Flash 4
Si está utilizando Flash 5 para crear contenidos para Flash Player 4 (exportándolo como Flash 4), no podrá aprovechar las ventajas de las nuevas funciones presentes en ActionScript de Flash 5. Sin embargo, muchas de las nuevas características de ActionScript aún se encuentran disponibles. ActionScript de Flash 4 solamente tiene un tipo de datos primitivo básico que se utiliza tanto para la manipulación numérica como para manipulación de cadenas. Cuando es autor de una película para Flash Player 4, necesitará utilizar los operadores de cadena no aprobados situados en la categoría Operadores de cadena de la caja de herramientas.
Puede utilizar las siguientes características de Flash 5 cuando exporte al formato de archivo SWF de Flash 4.
El operador de acceso a objeto y a matriz ([]).
El operador de punto (.).
Los operadores lógicos, los operadores de asignación y los operadores de
incremento/decremento previo e incremento/decremento posterior.
El operador módulo (%), todos los métodos y propiedades del objeto Math.
Flash Player 4 no admite estos operadores y funciones originalmente. Flash 5 debe exportarlos como aproximaciones de series. Esto quiere decir que los resultados son solamente aproximados. Además, debido a la inclusión de aproximaciones de series en el archivo SWF, estas funciones ocupan más espacio en los archivos SWF de Flash 4 que en los archivos SWF de Flash 5.
Las acciones for, while, do while, break y continue.
Las acciones print y printAsBitmap.
Programación de Scripts en ActionScript 89
Las siguientes funciones de Flash 5 no pueden utilizarse en películas exportadas al formato de archivo SWF de Flash 4:
Funciones personalizadas
Soporte XML
Variables locales
Objetos predefinidos (excepto objetos Math)
Acciones de clip de película
Tipos de datos múltiples
eval con sintaxis de punto (por ejemplo,
eval("_root.movieclip.variable"))
return
new
delete
typeof
for...in
keycode
targetPath
escape
globalToLocal y localToGlobal
hitTest
isFinite y inNaN
parseFloat y parseInt
tunescape
_xmouse y _ymouse
_quality
Capítulo 290

CAPÍTULO 3

Interactividad con ActionScript

.............................................................................................................
Una película interactiva toma en cuenta a la audiencia. Mediante el teclado, el ratón o ambos, la audiencia puede acceder a distintas partes de las películas, mover objetos, introducir información, hacer clic en botones y llevar a cabo muchas otras operaciones interactivas.
Como desarrollador, usted crea su película interactiva con scripts, cuyas especificaciones establecen que se deberán ejecutar cuando se presenten eventos específicos. Los eventos que ocasionan que se accione un script se dan cuando la cabeza lectora llega a un fotograma, cuando se carga o descarga un clip de película o cuando el usuario hace clic con el ratón o presiona una tecla del teclado. ActionScript se utiliza para crear scripts que indican a Flash la acción que debe llevar a cabo cuando ocurra el evento.
Las siguientes acciones básicas son modos comunes de control de la navegación e interacción del usuario en una película:
Reproducción y detención de películas
Ajuste de la calidad de visualización de una película
Detención de todos los sonidos
Salto a fotogramas o a escenas
Salto a otras URL
Comprobación de carga de fotogramas
Carga y descarga de películas adicionales
Si desea obtener información detallada sobre estas acciones, consulte
Utilización de Flash.
3
91
Si desea crear una interactividad de mayor nivel de complejidad, es necesario que comprenda las siguientes técnicas:
Creación de un cursor personalizado
Obtención de la posición del ratón
Captura de presión de una tecla
Creación de un campo de texto desplazable
Establecimiento de los valores del color
Creación de controles de sonido
Detección de colisiones

Creación de un cursor personalizado

Para ocultar el cursor estándar (es decir, la representación en pantalla del puntero del ratón), puede utilizar el método hide del objeto predefinido Mouse. Para utilizar un clip de película como el cursor personalizado, puede utilizar la acción startDrag.
Acciones asociadas a un clip de película para crear un cursor personalizado
Capítulo 392
Para crear un cursor personalizado:
1 Cree un clip de película para utilizarlo como cursor personalizado.
2 Seleccione el clip de película en el Escenario.
3 Seleccione Ventana > Acciones para abrir el panel Acciones de objeto.
4 En la lista de la Caja de herramientas, seleccione Objetos; después seleccione
Mouse y arrastre hide a la ventana Script.
El código deberá ser similar al siguiente:
onClipEvent(load){
Mouse.hide();
}
5
En la lista de la Caja de herramientas, seleccione Acciones; después arrastre
startDrag a la ventana Script.
6 Active el cuadro Bloquear ratón al centro.
El código deberá ser similar al siguiente:
onClipEvent(load){
Mouse.hide() startDrag(this, true);
}
7
Seleccione Control > Probar película para utilizar el cursor personalizado.
Los botones seguirán funcionado cuando utilice un cursor personalizado. Es una buena idea colocar el cursor personalizado en la capa superior de la Línea de tiempo de modo que se mueva por encima de los botones y de otros objetos cuando desplace el ratón por la película.
Si desea obtener más información sobre los métodos del objeto Mouse, consulte el Capítulo 7, “Diccionario de ActionScript”.
Interactividad con ActionScript 93

Obtención de la posición del ratón

Puede utilizar las propiedades _xmouse e _ymouse para encontrar la ubicación del puntero del ratón (cursor) en una película. Cada Línea de tiempo tiene una propiedad _xmouse e _ymouse que devuelven la ubicación del ratón dentro de su sistema de coordenadas.
Las propiedades _xmouse e _ymouse en la Línea de tiempo principal y en la Línea de tiempo de un clip de película
La siguiente sentencia podría colocarse en cualquier Línea de tiempo de la película
_level0 para que devuelva la posición _xmouse en la Línea de tiempo principal:
x_pos = _root._xmouse;
Para determinar la posición del ratón dentro de un clip de película, puede utilizar el nombre de instancia del clip de película. Por ejemplo, la siguiente sentencia podría colocarse en cualquier Línea de tiempo de la película _level0 para que devuelva la posición
y_pos = _root.myMovieClip._ymouse
Capítulo 394
_ymouse en la instancia myMovieClip:
También puede determinar la posición del ratón en un clip de película utilizando las propiedades _xmouse e _ymouse en una acción de clip, como se muestra a continuación:
onClipEvent(enterFrame){
xmousePosition = _xmouse; ymousePosition = _ymouse;
}
Las variables x_pos e y_pos se utilizan como contenedores para guardar los valores de las posiciones del ratón. Puede utilizar estas variables en cualquier script de su película. En el siguiente ejemplo, los valores de x_pos e y_pos se actualizan cada vez que el usuario mueve el ratón.
onClipEvent(mouseMove){
x_pos = _root._xmouse; y_pos = _root._ymouse;
}
Si desea obtener más información sobre las propiedades _xmouse e _ymouse, consulte el Capítulo 7, “Diccionario de ActionScript”.

Captura de presión de una tecla

Puede utilizar los métodos del objeto predefinido Key para detectar la ultima tecla que ha sido presionada por el usuario. El objeto Key no requiere una función constructora, para utilizar sus métodos, simplemente llame al propio objeto, como se muestra en el siguiente ejemplo:
Key.getCode();
Puede obtener códigos de tecla virtuales o valores ASCII de la tecla que ha sido presionada:
Para obtener el código de tecla virtual de la última tecla presionada, utilice
el método getCode.
Para obtener el valor ASCII de la última tecla presionada, utilice el
método getAscii.
Se asigna un código de tecla virtual a cada tecla física del teclado. Por ejemplo, la tecla de flecha izquierda tiene el código virtual 37. Utilizando el código de tecla virtual, puede asegurarse de que los controles de su película son los mismos en cualquier teclado sin tener en cuenta el lenguaje o la plataforma.
Los valores ASCII (código americano estándar para intercambio de información) se asignan a los primeros 127 caracteres de todos los conjuntos de caracteres. Los valores ASCII proporcionan información sobre un carácter de la pantalla. Por ejemplo, la letra “A” y la letra “a” tiene diferentes valores ASCII.
Interactividad con ActionScript 95
Comunmente se utiliza Key.getCode en un controlador onClipEvent. Pasando
keyDown como parámetro, el controlador ordena a ActionScript que compruebe el
valor de la última tecla presionada sólo cuando realmente se presiona la tecla. Este ejemplo usa
Key.getCode en una sentencia if para crear controles de navegación
para la nave espacial.
Para crear controles de teclado para una película:
1 Decida qué teclas va a utilizar y determine sus códigos virtuales utilizando
alguno de los siguientes métodos:
Consulte la lista de códigos de tecla del Apéndice B, “Teclas del teclado y
valores de códigos de tecla”.
Utilice una constante de objeto Key. (En la lista de la Caja de herramientas,
seleccione Objetos y a continuación Key. Las constantes de la lista aparecen en mayúsculas).
Asigne la siguiente acción de clip, después seleccione Control > Probar película
y presione la tecla que desee.
onClipEvent(keyDown) {
trace(Key.getCode());
}
2
Seleccione un clip de película en el Escenario.
3 Seleccione Ventana > Acciones.
4 Haga doble clic sobre la acción onClipEvent en la categoría Acciones de la caja
de herramientas.
5 Seleccione el evento Key down en el panel de parámetros.
6 Haga doble clic sobre la acción if en la categoría Acciones de la caja
de herramientas.
7 Haga clic sobre el parámetro Condition, seleccione Objects y después
Key y getCode.
8 Haga doble clic sobre el operador de igualdad (==) en la categoría Operadores
de la caja de herramientas.
Capítulo 396
9
Introduzca el código de tecla virtual a la derecha del operador de igualdad.
El código deberá ser similar al siguiente:
onClipEvent(keyDown) {
if (Key.getCode() == 32) { }
}
10
Seleccione una acción a llevar a cabo si se presiona la tecla correcta.
Por ejemplo, la siguiente acción hace que la Línea de tiempo principal vaya al siguiente fotograma cuando se presiona la Barra espaciadora (32).
onClipEvent(keyDown) {
if (Key.getCode() == 32) {
nextFrame();
}
}
Si desea obtener más información sobre los métodos del objeto Key, consulte el Capítulo 7, “Diccionario de ActionScript”.

Creación de un campo de texto desplazable

Puede utilizar las propiedades scroll y maxscroll para crear un campo de texto desplazable.
En el panel Opciones de texto, puede asignar una variable a cualquier campo de texto establecido como Introducción de texto o Texto dinámico. El campo de texto actúa como una ventana que indica el valor de esa variable.
Cada variable asociada con un campo de texto tiene una propiedad scroll y una propiedad maxscroll. Puede utilizar estas propiedades para desplazar texto en un campo de texto. La propiedad scroll devuelve el número de la línea superior visible en un campo de texto y puede establecerla o recuperarla. La propiedad maxscroll devuelve la línea superior visible de un campo de texto cuando la línea inferior está visible, puede leer, pero no establecer esta propiedad.
Interactividad con ActionScript 97
Por ejemplo, suponga que tiene un campo de texto que dispone de cuatro líneas. Si este campo contiene la variable
speech que tiene nueve líneas de texto,
solamente cuatro de las líneas se visualizarían en el campo de texto, como se muestra en el recuadro sólido:
Propiedad scroll
Propiedad maxscroll
Campo de texto visible
Puede acceder a estas propiedades utilizando la sintaxis de punto, como se muestra a continuación:
textFieldVariable.scroll myMovieClip.textFieldVariable.scroll textFieldVariable.maxscroll myMovieClip.textFieldVariable.maxscroll
Para crear un campo de texto con desplazable:
1 Arrastre un campo de texto al Escenario.
2 Seleccione Ventana > Paneles > Opciones de texto.
3 Elija Introducción de texto en el menú emergente.
4 Introduzca el nombre de variable text en el campo Variable.
5 Arrastre la esquina inferior derecha del campo de texto para cambiar el tamaño
del campo de texto.
6 Seleccione Ventana > Acciones.
Capítulo 398
7
Seleccione el fotograma 1 en la Línea de tiempo principal y asigne una acción
set variable que establezca el valor de text.
No aparecerá texto en el campo hasta que se haya establecido la variable. Por lo tanto, aunque puede asignar esta acción a cualquier fotograma, botón o clip de película, es buena idea asignar la acción al fotograma 1 en la Línea de tiempo principal, como se muestra a continuación:
8 Seleccione Ventana > Bibliotecas comunes > Botones y arrastre un botón
hasta el Escenario.
9 Pulse Alt (en Windows) o bien Opción (en Macintosh) y arrastre el botón
para crear una copia.
10 Seleccione el botón superior y elija Ventana > Acciones.
11 Arrastre la acción set variables desde la caja de herramientas hasta la
ventana Script en el panel Acciones.
12 Introduzca text.scroll en el cuadro Variable.
13 Introduzca text.scroll -1 en el cuadro Valor y active la casilla de
verificación Expresión.
14 Seleccione el botón de flecha hacia abajo y asigne la siguiente acción
set variables:
text.scroll = text.scroll+1;
15
Seleccione Control > Probar película para comprobar el campo de texto desplazable.
Si desea obtener más información sobre las propiedades scroll y maxscroll, consulte el Capítulo 7, “Diccionario de ActionScript”.
Interactividad con ActionScript 99

Establecimiento de los valores de color

Puede utilizar los métodos del objeto predefinido Color para ajustar el color de un clip de película. El método setRGB asigna valores hexadecimales RGB (rojo, verde, azul) al objeto y el método setTransform establece el porcentaje de valores de desplazamiento para los componentes rojo, verde, azul y transparencia (alfa) de un color. El siguiente ejemplo utiliza setRGB para cambiar el color de un objeto basándose en la información introducida por el usuario.
La acción del botón crea un objeto de color y cambia el color de la camiseta basándose en la información introducida por el usuario.
Para utilizar el objeto Color, necesita crear una instancia del objeto y aplicarla a un clip de película.
Para establecer el valor de color de un clip de película:
1 Seleccione un clip de película en el Escenario y elija Ventana >
Paneles > Instancia.
2 Introduzca el nombre de instancia colorTarget en el cuadro Nombre. 3 Arrastre un campo de texto al Escenario. 4 Seleccione Ventana > Paneles > Opciones de texto y asígnele el nombre
de variable input.
5 Arrastre un botón al Escenario y selecciónelo.
6 Seleccione Ventana > Acciones.
Capítulo 3100
Loading...