Final action script

Introduction to ActionScript-1
Introduction to ActionScript
School of Education Technology
Jadavpur University
Overview
ActionScript, Flash's scripting language, adds interactivity to a movie. You can set up
your movie so that user events, such as button clicks and keypresses, trigger scripts
that tell the movie what action to perform. For example, you can write a script that
tells Flash to load different movies into the Flash Player depending on which
navigation button a user chooses.
Think of ActionScript as a tool that allows you to create a movie that behaves exactly
as you want. You don't need to understand every possible use of the tool to begin
scripting; if you have a clear goal, you can start building scripts with simple actions.
You can incorporate new elements of the language as you learn them to accomplish
more complicated tasks.
Actions panel
The Actions panel lets you create and edit actions for an object or frame using two
different editing modes. You can select prewritten actions from the Toolbox list, drag
and drop actions, and use buttons to delete or rearrange actions. In Normal Mode
you can write actions using parameter (argument) fields that prompt you for the
correct arguments. In Expert Mode you can write and edit actions directly in a text
box, much like writing script with a text editor.
To display the Actions panel:
Choose Window > Actions.
Selecting an instance of a button or movie clip makes the Actions panel active. The
Actions panel title changes to Object Actions if a button or movie clip is selected, and
to the Frame Actions panel if a frame is selected.
To select an editing mode:
1 With the Actions panel displayed, click the arrow in the upper right corner of the
panel to display the pop-up menu.
2 Choose Normal Mode or Expert Mode from the pop-up menu.
Each script maintains its own mode. For example, you can script one instance of a
button in Normal Mode, and another in Expert Mode. Switching between the
selected button then switches the panel's mode state.
Normal Mode
School of Education Technology, Jadavpur University
1of 37

In Normal Mode you create actions by selecting actions from a list on the left side of
the panel, called the Toolbox list. The Toolbox list contains Basic Actions, Actions,
Operators, Functions, Properties, and Objects categories. The Basic Actions
category contains the simplest Flash actions and is only available in Normal Mode.
The selected actions are listed on the right side of the panel, in the Actions list. You
can add, delete, or change the order of action statements; you can also enter
parameters (arguments) for actions in parameter fields at the bottom of the panel.
In Normal Mode you can use the controls in the Actions panel to delete or change the
order of statements in the Actions list. These controls are especially useful for
managing frame or button actions that have several statements.
The Actions panel in Normal Mode.
To select an action:
1 Click an Actions category in the toolbox to display the actions in that category.
2 Double-click an action or drag it to the Script window.
To use the Parameters fields:
2of 37

1 Click the Parameters button in the lower right corner of the Actions panel to display
the fields.
2 Select the action and enter new values in the Parameters fields to change
parameters of existing actions.
To insert a movie clip target path:
1 Click the Target Path button in the lower right corner of the Actions panel to
display the Insert Target Path dialog box.
2 Select a movie clip from the display list.
To move a statement up or down the list:
1 Select a statement in the Actions list.
2 Click the Up or Down Arrow buttons.
To delete an action:
2 Click the Delete (-) button.
To change the parameters of existing actions:
2 Enter new values in the Parameters
fields.
To resize the Toolbox or Actions list, do one of the following:
Drag the vertical splitter bar that appears between the Toolbox and Actions list.
Double-click the splitter bar to collapse the Toolbox list; double-click the bar again
to redisplay the list.
Click the Left or Right Arrow button on the splitter bar to expand or collapse the
list.
When the Toolbox list is hidden, you can still access its items using the Add (+)
button in the upper left of the Actions panel.
Expert Mode
In Expert Mode you create actions by entering ActionScript into the text box on the
right side of the panel or by selecting actions from the Toolbox list on the left. You
3of 37

edit actions, enter parameters for actions, or delete actions directly in the text box,
much like creating script in a text editor.
Expert Mode lets advanced ActionScript users edit their scripts with a text editor, as
they would JavaScript or VBScript. Expert Mode differs from Normal Mode in these
ways:
Selecting an item using the Add (+) button or Toolbox list inserts the item in the
text-editing area.
No parameter fields appear.
In the button panel, only the Add (+) button works.
The Up and Down Arrow buttons remain inactive.
The Actions panel in Expert Mode
Switching between editing modes
Changing editing modes while writing a script can change the formatting of the script.
For that reason, it is best to use one editing mode per script.
When you switch from Normal to Expert Mode, indentation and formatting is
maintained. Although you can convert Normal Mode scripts with errors to Expert
Mode, you cannot export the scripts until the errors are fixed.
Switching from Expert to Normal Mode is slightly more complex:
When you switch to Normal Mode, Flash reformats the script and strips any white
space and indentation you've added.
If you switch to Normal Mode and then back to Expert Mode, Flash reformats the
script according to its appearance in Normal Mode.
4of 37

Expert Mode scripts containing errors cannot be exported or converted to Normal
Mode; if you try to convert the script, you'll receive an error message.
To set an editing mode preference:
1 Choose Edit > Preferences.
2 Select the General tab
3 In the Actions Panel section, select Normal Mode or Expert Mode from the pop-up
menu.
Assigning actions to objects
You can assign an action to a button or a movie clip to make an action execute when
the user clicks a button or rolls the pointer over it, or when the movie clip loads or
reaches a certain frame. You assign the action to an instance of the button or movie
clip; other instances of the symbol aren't affected.
When you assign an action to a button, you must nest the action inside an
on(mouse event) handler and specify the mouse or keyboard events that trigger
the action. When you assign an action to a button in Normal Mode, the on(mouse
event) handler is automatically inserted.
When you assign an action to a movie clip, you must nest the action inside an
onClipEvent handler and specify the clip event that triggers the action. When you
assign an action to a movie clip in Normal Mode, the on(mouse event) handler is
automatically inserted.
The following instructions describe how to assign actions to objects using the Actions
panel in Normal Mode.
Once you've assigned an action, use the Control > Test Movie command to test
whether it works. Most actions won't work in Editing Mode.
To assign an action to a button or movie clip:
1 Select a button or movie clip instance and choose Window > Actions.
If the selection is not a button, a movie clip instance, or a frame, or if the selection
includes multiple objects, the Actions panel is dimmed.
2 Choose Normal Mode
3 To assign an action, do one of the following:
Click the Actions folder in the Toolbox list on the left side of the Actions panel.
Double-click an action to add it to the Actions list on the right side of the panel.
Drag an action from theToolbox list to the Actions list.
Click the Add (+) button and choose an action from the pop-up menu.
Use the keyboard shortcut listed next to each action in the pop-up menu.
5of 37

Selecting an object from the toolbox in Normal Mode
4 In the Parameters fields at the bottom of the panel, select parameters for the
action as needed.
Parameters vary depending on the action you choose. For detailed information on
the required parameters for each action, see the ActionScript dictionary:
Overview. To insert a Target path for a movie clip into a Parameter field, click the
Target Path button in the lower right corner of the Actions panel.
5 Repeat steps 3 and 4 to assign additional actions as necessary.
To test an object action:
Choose Control > Test Movie.
Assigning actions to frames
To make a movie do something when it reaches a keyframe, you assign a frame
action to the keyframe. For example, to create a loop in the Timeline between frames
20 and 10, you would add the following frame action to frame 20:
gotoAndPlay (10);
It's a good idea to place frame actions in a separate layer. Frames
with actions display a small a in the Timeline.
An "a" in a keyframe indicates a frame action.
Once you've assigned an action, choose Control > Test Movie to test whether it
works. Most actions won't work in Editing Mode.
6of 37

The following instructions describe how to assign frame actions using the Actions
panel in Normal Mode.
To assign an action to a keyframe:
1 Select a keyframe in the Timeline and choose Window > Actions.
If a selected frame is not a keyframe, the action is assigned to the previous
keyframe. If the selection is not a frame, or if the selection includes multiple
keyframes, the Actions panel is dimmed.
2 Choose Normal Mode from the pop-up menu at the upper right of the Frame
Actions panel.
3 To assign an action, do one of the following:
Click the Actions folder in the Toolbox list on the left side of the Actions panel.
Double-click an action to add it to the Actions list on the right side of the panel.
Drag an action from theToolbox list to the Actions list.
Click the Add (+) button and choose an action from the pop-up menu.
Use the keyboard shortcut listed next to each action in the pop-up menu.
In the Parameters fields at the bottom of the panel, select parameters for the
action as needed.
4 To assign additional actions, select another keyframe and repeat step 3.
To test a frame action:
Choose Control > Test Movie.
Writing scripts with ActionScript:
Overview
When you create scripts in ActionScript, you can choose the level of detail you want
to use. To use simple actions, you can use the Actions panel in Normal Mode and
build scripts by choosing options from menus and lists. However, if you want to use
7of 37

ActionScript to write more powerful scripts, you must understand how ActionScript
works as a language.
Like other scripting languages, ActionScript consists of components, such as
predefined objects and functions, and it allows you to create your own objects and
functions. ActionScript follows its own rules of syntax, reserves keywords, provides
operators, and allows you to use variables to store and retrieve information.
ActionScript's syntax
The following are general rules that apply to all ActionScript.
Dot syntax
In ActionScript, a dot (.) is used to indicate the properties or methods related to an
object or movie clip. It is also used to identify the target path to a movie clip or
variable. A dot syntax expression begins with the name of the object or movie clip
followed by a dot, and ends with the property, method, or variable you want to
specify.
For example, the _x movie clip property indicates a movie clip's x axis position on the
Stage. The expression ballMC._x refers to the _x property of the movie clip
instance ballMC.
As another example, submit is a variable set in the movie clip form which is
nested inside the movie clip shoppingCart. The expression
shoppingCart.form.submit = true sets the submit variable of the instance
form to true.
Expressing a method of an object or movie clip follows the same pattern. For
example, the play method of the ballMC instance(a movie clip) moves the
playhead in the Timeline of ballMC, as in the following statement:
ballMC.play();
Dot syntax also uses two special aliases, _root and _parent. The alias _root
refers to the main Timeline. You can use the _root alias to create an absolute
target path. For example, the following statement calls the function
buildGameBoard in the movie clip functions on the main Timeline:
_root.functions.buildGameBoard();
You can use the alias _parent to refer to a movie clip in which the current movie
clip is nested. You can use _parent to create a relative target path. For example, if
the movie clip dog is nested inside the movie clip animal, the following statement
on the instance dog tells animal to stop:
_parent.stop();
Slash syntax
8of 37

Slash syntax was used in Flash 3 and 4 to indicate the target path of a movie clip or
variable. This syntax is still supported by the Flash 5 Player, but its use is not
recommended. Slash syntax was most commonly used with the tellTarget action,
whose use is also no longer recommended. The with action is now preferred over
tellTarget because it is more compatible with dot syntax.
Curly braces
ActionScript statements are grouped together into blocks with curly braces ({ }), as
in the following script:
on(release) {
myDate = new Date();
currentMonth = myDate.getMonth();
}
Semicolons
An ActionScript statement is terminated with a semicolon, but if you omit the
terminating semicolon, Flash will still compile your script successfully. For example,
the following statements are terminated with semicolons:
column = passedDate.getDay();
row = 0;
The same statements could be written without the terminating semicolons:
column = passedDate.getDay()
row = 0
Parentheses
When you define a function, place any arguments inside parentheses:
function myFunction (name, age, reader){
...
}
When you call a function, include any arguments passed to the function in
parentheses, as shown here:
myFunction ("Steve", 10, true);
You can also use parentheses to override ActionScript's order of precedence or to
make your ActionScript statements easier to read.
You also use parentheses to evaluate an expression on the left side of a dot in dot
syntax. For example, in the following statement, the parentheses cause new
color(this) to evaluate and create a new color object:
onClipEvent(enterFrame) {
(new Color(this)).setRGB(0xffffff));
}
9of 37

If you didn't use parentheses, you would need to add a statement to the code to
evaluate it:
myColor = new Color(this);
myColor.setRGB(0xffffff);
}
Uppercase and lowercase letters
Only keywords in ActionScript are case sensitive; with the rest of ActionScript, you
can use uppercase and lowercase letters however you want. For example, the
following statements are equivalent:
cat.hilite = true;
CAT.hilite = true;
However, it's a good habit to follow consistent capitalization conventions, to make it
is easier to identify names of functions and variables when reading ActionScript
code.
If you don't use correct capitalization with keywords, your script will have errors.
When Colored Syntax is turned on in the Actions panel, keywords written with the
correct capitalization are blue.
Comments
In the Actions panel, use the comment statement to add notes to a frame or button
action when you want to keep track of what you intended an action to do. Comments
are also useful for passing information to other developers if you work in a
collaborative environment or are providing samples.
When you choose the comment action, the characters // are inserted into the script.
Even a simple script is easier to understand if you make notes as you create it:
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 ();
}
Comments appear in pink in the Script window. They can be any length without
affecting the size of the exported file, and they do not need to follow rules for
ActionScript syntax or keywords.
Keywords
ActionScript reserves words for specific use within the language, so you can't use
them as variable, function, or label names. The following table lists all ActionScript
keywords:
10of 37

break for new var
continue function return void
delete if this while
else in typeof with
Constants
A constant is a property whose value never changes. Constants are listed in the
Actions toolbox and in the ActionScript dictionary: Overview in all uppercase letters.
For example, the constants BACKSPACE, ENTER, QUOTE, RETURN, SPACE, and TAB
are properties of the Key object and refer to keyboard keys. To test whether the user
is pressing the Enter key, use the following statement:
if(keycode() == Key.ENTER) {
alert = "Are you ready to play?"
controlMC.gotoAndStop(5);
}
Data types
A data type describes the kind of information a variable or ActionScript element can
hold. There are two kinds of data types: primitive and reference. The primitive data
types—string, number, and Boolean—have a constant value and, therefore, can hold
the actual value of the element they represent. The reference data types—movie clip
and object—have values that can change and, therefore, contain references to the
actual value of the element. Variables containing primitive data types behave
differently in certain situations than those containing reference types.
Each data type has its own rules as listed here.
String
A string is a sequence of characters such as letters, numbers, and punctuation
marks. You enter strings in an ActionScript statement by enclosing them in single or
double quotation marks. Strings are treated as characters instead of as variables. For
example, in the following statement, "L7" is a string:
favoriteBand = "L7";
You can use the addition (+) operator to concatenate, or join, two strings.
ActionScript treats spaces at the beginning or end of a string as a literal part of the
string. The following expression includes a space after the comma:
greeting = "Welcome," + firstName;
Although ActionScript does not distinguish between uppercase and lowercase in
references to variables, instance names, and frame labels, literal strings are case
11of 37

sensitive. For example, the following two statements place different text into the
specified text field variables, because "Hello" and "HELLO" are literal strings.
invoice.display = "Hello";
invoice.display = "HELLO";
To include a quotation mark in a string, precede it with a backslash character (). This
is called "escaping" a character. There are other characters that cannot be
represented in ActionScript except by special escape sequences. The following table
provides all the ActionScript escape characters:
Escape sequence Character
b Backspace character (ASCII 8)
f Form-feed character (ASCII 12)
n Line-feed character (ASCII 10)
r Carriage return character (ASCII 13)
t Tab character (ASCII 9)
" Double quotation mark
' Single quotation mark
Backslash
000 - 377 A byte specified in octal
x00 - xFF A byte specified in hexadecimal
u0000 - uFFFF A 16-bit Unicode character specified in hexadecimal
Number
The number data type is a double-precision floating-point number. You can
manipulate numbers using the arithmetic operators addition (+), subtraction (-),
multiplication (*), division (/), modulo (%), increment (++), and decrement (--). You
can also use methods of the predefined Math object to manipulate numbers. The
following example uses the sqrt (square root) method to return the square root of
the number 100:
Math.sqrt(100);
Boolean
12of 37

A Boolean value is one that is either true or false. ActionScript also converts the
values true and false to 1 and 0 when appropriate. Boolean values are most often
used with logical operators in ActionScript statements that make comparisons to
control the flow of a script. For example, in the following script, the movie plays if the
variable password is true:
if ((userName == true) && (password == true)){
play();
}
}
Object
An object is a collection of properties. Each property has a name and a value. The
value of a property can be any Flash data type, even the object data type. This
allows you to arrange objects inside each other, or "nest" them. To specify objects
and their properties, you use the dot (.) operator. For example, in the following code,
hoursWorked is a property of weeklyStats, which is a property of employee:
employee.weeklyStats.hoursWorked
You can use ActionScript's predefined objects to access and manipulate specific
kinds of information. For example, the Math object has methods that perform
mathematical operations on numbers you pass to them. This example uses the sqrt
method:
squareRoot = Math.sqrt(100);
The ActionScript MovieClip object has methods that let you control movie clip symbol
instances on the Stage. This example uses the play and nextFrame methods:
mcInstanceName.play();
mc2InstanceName.nextFrame();
You can also create your own objects so that you can organize information in your
movie. To add interactivity to a movie with ActionScript, you'll need many different
pieces of information: for example, you might need a user's name, the speed of a
ball, the names of items in a shopping cart, the number of frames loaded, the user's
zip code, and which key was pressed last. Creating custom objects allows you to
organize this information into groups, simplify your scripting, and reuse your scripts.
Movie clip
Movie clips are symbols that can play animation in a Flash movie. They are the only
data type that refers to a graphical element. The movie clip data type allows you to
control movie clip symbols using the methods of the MovieClip object. You call the
methods using the dot (.) operator, as shown here:
myClip.startDrag(true);
parentClip.childClip.getURL( "http://www.macromedia.com/support/" +
product);
13of 37

variables
A variable is a container that holds information. The container itself is always the
same, but the contents can change. By changing the value of a variable as the movie
plays, you can record and save information about what the user has done, record
values that change as the movie plays, or evaluate whether some condition is true or
false.
It's a good idea always to assign a variable a known value the first time you define
the variable. This is known as initializing a variable and is often done in the first frame
of the movie. Initializing variables makes it easier to track and compare the variable's
value as the movie plays.
Variables can hold any type of data: number, string, Boolean, object, or movie clip.
The type of data a variable contains affects how the variable's value changes when it
is assigned in a script.
Typical types of information you can store in a variable include a URL, a user's
name, the result of a mathematical operation, the number of times an event occurred,
or whether a button has been clicked. Each movie and movie clip instance has its
own set of variables, with each variable having its own value independent of
variables in other movies or movie clips.
Naming a variable
A variable's name must follow these rules:
It must be an identifier.
It cannot be a keyword or a Boolean literal (true or
false).
It must be unique within its scope.
Typing a variable
In Flash, you do not have to explicitly define a variable as holding either a number, a
string, or other data type. Flash determines the data type of a variable when the
variable is assigned:
x = 3;
In the expression x = 3, Flash evaluates the element on the right side of the
operator and determines that it is of type number. A later assignment may change
the type of x; for example, x = "hello" changes the type of x to a string. A
variable that hasn't been assigned a value has a type of undefined.
ActionScript converts data types automatically when an expression requires it. For
example, when you pass a value to the trace action, trace automatically converts
the value to a string and sends it to the Output window. In expressions with
14of 37

operators, ActionScript converts data types as needed; for example, when used with
a string, the + operator expects the other operand to be a string:
"Next in line, number " + 7
ActionScript converts the number 7 to the string "7" and adds it to the end of the first
string, resulting in the following string:
"Next in line, number 7"
When you debug scripts, it's often useful to determine the data type of an expression
or variable to understand why it is behaving a certain way. You can do this with the
typeof operator, as in this example:
trace(typeof(variableName));
To convert a string to a numerical value, use the Number function. To convert a
numerical value to a string, use the String function. See their individual entries in
ActionScript dictionary: Overview.
Scoping a variable
A variable's "scope" refers to the area in which the variable is known and can be
referenced. Variables in ActionScript can be either global or local. A global variable is
shared among all Timelines; a local variable is only available within its own block of
code (between the curly braces).
You can use the var statement to declare a local variable inside a script. For
example, the variables i and j are often used as loop counters. In the following
example, i is used as a local variable; it only exists inside the function 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;
}
}
}
Local variables can also help prevent name collisions, which can cause errors in your
movie. For example, if you use name as a local variable, you could use it to store a
user name in one context and a movie clip instance name in another; because these
variables would run in separate scopes, there would be no collision.
15of 37

It's good practice to use local variables in the body of a function so that the function
can act as an independent piece of code. A local variable is only changeable within
its own block of code. If an expression in a function uses a global variable, something
outside the function could change its value, which would change the function.
Variable declaration
To declare global variables, use the setVariables action or the assignment (=)
operator. Both methods achieve the same results.
To declare local variables, use the var statement inside the body of a function. Local
variables are scoped to the block, and expire at the end of the block. Local variables
not declared within a block expire at the end of their script.
To test the value of a variable, use the trace action to send the value to the Output
window. For example, trace(hoursWorked) sends the value of the variable
hoursWorked to the Output window in test-movie mode. You can also check and
set the variable values in the Debugger in test-movie mode
Using variables in a script
You must declare a variable in a script before you can use it in an expression. If you
use an undeclared variable, as in the following example, the variable's value will be
undefined and your script will generate an error:
getURL(myWebSite);
myWebSite = "http://www.shrimpmeat.net";
The statement declaring the variable myWebSite must come first so that the variable
in the getURL action can be replaced with a value.
You can change the value of a variable many times in a script. The type of data that
the variable contains affects how and when the variable changes. Primitive data
types, such as strings and numbers, are passed by value. This means that the actual
content of the variable is passed to the variable.
In the following example, x is set to 15 and that value is copied into y. When x is
changed to 30, the value of y remains 15 because y doesn't look to x for its value; it
contains the value of x that it was passed.
var x = 15;
var y = x;
var x = 30;
As another example, the variable in contains a primitive value, 9, so the actual value
is passed to the sqrt function and the returned value is 3:
function sqrt(x){
return x * x;
16of 37

}
var in = 9;
var out = sqr(in);
The value of the variable in does not change.
Operators
An expression is any statement that Flash can evaluate that will return a value. You
can create an expression by combining operators and values, or by calling a function.
When you write an expression in the Actions panel in Normal Mode, make sure the
Expression box is checked in the Parameters panel, otherwise the field will contain
the literal value of a string.
Check the Expression box next to a field to create an expression
Operators are characters that specify how to combine, compare, or modify the values
of an expression. The elements that the operator performs on are called operands.
For example, in the following statement, the + operator adds the value of a numeric
literal to the value of the variable foo; foo and 3 are the operands:
foo + 3
Operator precedence
When two or more operators are used in the same statement, some operators take
precedence over others. ActionScript follows a precise hierarchy to determine which
operators to execute first. For example, multiplication is always performed before
addition; however, items in parentheses take precedence over multiplication. So,
without parentheses, ActionScript performs the multiplication in the following example
first:
total = 2 + 4 * 3;
The result is 14.
But when parentheses surround the addition operation, ActionScript performs the
addition first:
total = (2 + 4) * 3;
The result is 18.
17of 37

Operator List
This table lists all of Action Script operators and their associativity, from highest to
lowest precedence.
Operator Description Associativity
Highest Precedence
+ Unary plus Right to left
- Unary minus Right to left
~ Bitwise one's complement Right to left
! Logical NOT Right to left
not Logical NOT (Flash 4 style) Right to left
++ Post-increment Left to right
-- Post-decrement Left to right
( ) Function call Left to right
[ ] Array element Left to right
. Structure member Left to right
++ Pre-increment Right to left
-- Pre-decrement Right to left
new Allocate object Right to left
delete Deallocate object Right to left
typeof Type of object Right to left
void Returns undefined value Right to left
* Multiply Left to right
/ Divide Left to right
% Modulo Left to right
+ Add Left to right
add String concatenation (formerly &) Left to right
- Subtract Left to right
<< Bitwise Left Shift Left to right
>> Bitwise Right Shift Left to right
>>> Bitwise Right Shift (Unsigned) Left to right
< Less than Left to right
<= Less than or equal to Left to right
> Greater than Left to right
>= Greater than or equal to Left to right
lt Less than (string version) Left to right
le Less than or equal to (string version) Left to right
gt Greater than (string version) Left to right
ge Greater than or equal to (string version) Left to right
== Equal Left to right
!= Not equal Left to right
eq Equal (string version) Left to right
ne Not equal (string version) Left to right
& Bitwise AND Left to right
^ Bitwise XOR Left to right
| Bitwise OR Left to right
&& Logical AND Left to right
and Logical AND (Flash 4) Left to right
|| Logical OR Left to right
or Logical OR (Flash 4) Left to right
?: Conditional Right to left
= Assignment Right to left
"*=, /=, %=, +=, -=, &=, |=, ^=, <<=, >>=, >>>=" Compound assignment Right to left
, Multiple evaluation Left to right
Lowest Precedence
18of 37

Operator associativity
When two or more operators share the same precedence, their associativity
determines the order in which they are performed. Associativity can either be left-to-
right or right-to-left. For example, the multiplication operator has an associativity of
left-to-right; therefore, the following two statements are equivalent:
total = 2 * 3 * 4;
total = (2 * 3) * 4;
Numeric operators
Numeric operators add, subtract, multiply, divide, and perform other arithmetic
operations. Parentheses and the minus sign are arithmetic operators. The
ActionScript's numeric operators are +, *, /, %, -, ++, --
Comparison operators
Comparison operators compare the values of expressions and return a Boolean
value (true or false). These operators are most commonly used in loops and in
conditional statements. In the following example, if variable score is 100, a certain
movie loads; otherwise, a different movie loads:
if (score == 100){
loadMovie("winner.swf", 5);
} else {
loadMovie("loser.swf", 5);
}
The comparison operators are: <, >, <=, >=
String operators
The + operator has a special effect when it operates on strings: it concatenates the
two string operands. For example, the following statement adds:
"Congratulations," to "Donna!":
"Congratulations, " + "Donna!"
The result is "Congratulations, Donna!" If only one of the + operator's
operands is a string, Flash converts the other operand to a string.
The comparison operators >, >=, <, and <= also have a special effect when
operating on strings. These operators compare two strings to determine which is first
in alphabetical order. The comparison operators only compare strings if both
operands are strings. If only one of the operands is a string, ActionScript converts
both operands to numbers and performs a numeric comparison.
Logical operators
Logical operators compare Boolean (true and false) values and return a third
Boolean value. For example, if both operands evaluate to true, the logical AND
operator (&&) returns true. If one or both of the operands evaluate to true, the
logical OR operator (||) returns false. Logical operators are often used in
conjunction with comparison operators to determine the condition of an if action.
For example, in the following script, if both expressions are true, the if action will
execute:
if ((i > 10) && (_framesloaded > 50)){
play();
}
The logical operators: &&, ||, !
19of 37

Bitwise operators
Bitwise operators internally manipulate floating-point numbers to change them into
32-bit integers, which are easier to work with. The exact bitwise operation performed
depends on the operator, but all bitwise operations evaluate each digit of a floating-
point number separately to compute a new value.
The bitwise operators: &, |, ^, ~, <<, >>, >>>
Equality and assignment operators
You can use the equality (==) operator to determine whether the values or identities
of two operands are equal. This comparison returns a Boolean (true or false)
value. If the operands are strings, numbers, or Boolean values, they are compared
by value. If the operands are objects or arrays, they are compared by reference.
You can use the assignment (=) operator to assign a value to a variable, as in the
following:
password = "Sk8tEr";
You can also use the assignment operator to assign multiple variables in the same
expression. In the following statement, the value of b is assigned to the variables c,
and d:
a = b = c = d;
You can also use compound assignment operators to combine operations.
Compound operators perform on both operands and then assign that new value to
the first operand. For example, the following two statements are equivalent:
x += 15;
x = x + 15;
The equality and assignment operators are: ==, !=, =, +=, -=, *=, %=, /=, <<=, >>=,
>>>=, ^=, |=, &=
Using actions
Actions are ActionScript's statements, or commands. Multiple actions assigned to the
same frame or object create a script. Actions can act independently of each other, as
in the following statements:
swapDepths("mc1", "mc2");
gotoAndPlay(15);
You can also nest actions by using one action inside another; this allows actions to
affect each other. In the following example, the if action tells the gotoAndPlay
action when to execute:
if (i >= 25) {
gotoAndPlay(10);
}
Actions can move the playhead in the Timeline (gotoAndPlay), control the flow of a
script by creating loops (do while) or conditional logic (if), or create new functions
and variables (function, setVariable). The following table lists all ActionScript
actions:
Actions
break evaluate include print stopDrag
call for loadMovie printAsBitmap swapDepths
comment for...in loadVariables removeMovieClip tellTarget
continue fsCommand nextFrame
nextScene
return toggleHighQuality
delete function on setVariable stopDrag
do...while getURL onClipEvent setProperty trace
duplicateMovieClip gotoAndPlay
gotoAndStop
play startDrag unloadMovie
else if prevFrame stop var
else if ifFrameLoaded prevScene stopAllSounds while
20of 37

For syntax and usage examples of each action, see individual entries in ActionScript
dictionary: Overview.
Target path
To use an action to control a movie clip or loaded movie, you must specify its name
and its address, called a target path. The following actions take one or more target
paths as arguments:
loadMovie
loadVariables
unloadMovie
setProperty
startDrag
duplicateMovieClip
removeMovieClip
print
printAsBitmap
tellTarget
For example, the loadMovie action takes the arguments URL, Location, and
Variables. The URL is the location on the Web of the movie you want to load. The
Location is the target path into which the movie will be loaded.
loadMovie(URL, Location, Variables);
The Variables argument is not required for this example.
The following statement loads the URL http://www.mySite.com/myMovie.swf
into the instance bar on the main Timeline, _root; _root.bar is the target path;
loadMovie("http://www.mySite.com/myMovie.swf", _root.bar);
In ActionScript you identify a movie clip by its instance name. For example, in the
following statement, the _alpha property of the movie clip named star is set to
50% visibility:
star._alpha = 50;
Make Editable Text Box
When you create a text box, you assign a variable to it. A variable is a fixed name for
a value that changes. The text box is like a window that displays the value for the
variable. You can use actions to pass the variable to other parts of the movie, to a
server-side application for storing in a database, and so on. You can also replace the
value of a variable by reading it from a server-side application or by loading it from
another part of the movie. You can manipulate the variable name of the text box as
normal variable. To assign some value to it write path.variable_name=value and to
retrieve the value use the path.variable name only where path is the hierarchical
reference .
Create an editable text box:
1 Do one of the following to create or select a text block:
Select the Text tool and drag to create a text block of the desired width and
height.
Click inside an existing text block.
2 Choose Window > Panels > Text Options.
3 Choose an option from the Text Type pop-up menu:
Choose Dynamic Text to create a text box that displays dynamically updating text.
Choose Input Text to create a text box in which users can input text.
Give a movie clip an instance name:
21of 37

1 Select the movie clip on the Stage.
2 Choose Window > Panels > Instance.
3 Enter an instance name in the Name
field.
Identify a loaded movie:
Use _levelX where X is the level number specified in the loadMovie action that
loaded the movie.
For example, a movie loaded into level 5 has the instance name _level5. In the
following example, a movie is loaded into level 5 and its visibility is set to false:
onClipEvent(load) {
loadMovie("myMovie.swf", 5);
}
_level5._visible = false;
}
Controlling flow in scripts
ActionScript uses if, for, while, do...while, and for...in actions to perform
an action depending on whether a condition exists.
Using "if" statements
Statements that check whether a condition is true or false begin with the term if.
If the condition exists, ActionScript executes the statement that follows. If the
condition doesn't exist, ActionScript skips to the next statement outside the block of
code.
To optimize your code's performance, check for the most likely conditions first.
The following statements test several conditions. The term else if specifies
alternative tests to perform if previous conditions are false.
if ((password == null) || (email == null)){
gotoAndStop("reject");
} else {
gotoAndPlay("startMovie");
}
Repeating an action
ActionScript can repeat an action a specified number of times or while a specific
condition exists. Use the while, do...while, for, and for...in actions to
create loops.
To repeat an action while a condition exists:
Use the while statement.
A while loop evaluates an expression and executes the code in the body of the loop
if the expression is true. After each statement in the body is executed, the
expression is evaluated again. In the following example, the loop executes four
times:
i = 4
while (i > 0) {
myMC.duplicateMovieClip("newMC" + i, i );
i --;
}
You can use the do...while statement to create the same kind of loop as a
while loop. In a do...while loop the expression is evaluated at the bottom of the
code block so the loop always runs at least once, as in the following:
i = 4
do {
22of 37

myMC.duplicateMovieClip("newMC" +i, i );
i --;
} while (i > 0);
To repeat an action using a built-in counter:
Use the for statement.
Most loops use a counter of some kind to control how many times the loop runs. You
can declare a variable and write a statement that increases or decreases the variable
each time the loop executes. In the for action, the counter and the statement that
increments the counter are part of the action, as in the following:
for (i = 4; i > 0; i--){
myMC.duplicateMovieClip("newMC" + i, i + 10);
}
Using predefined functions
A function is a block of ActionScript code that can be reused anywhere in a movie. If
you pass specific values called arguments to a function, the function will operate on
those values. A function can also return values. Flash has predefined functions that
allow you to access certain information and perform certain tasks, such as collision
detection (hitTest), getting the value of the last key pressed (keycode), and
getting the version number of the Flash Player hosting the movie (getVersion).
Calling a function
You can call a function in any Timeline from any Timeline, including a loaded movie.
Each function has its own characteristics and some require you to pass certain
values. If you pass more arguments than the function requires, the extra values are
ignored. If you don't pass a required argument, the empty arguments are assigned
the undefined data type, which can cause errors when you export a script. To call
a function, it must be in a frame that the playhead has reached.
Flash's predefined functions are listed in the following table:
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
String functions are not listed in the above table.
To call a function in Expert Mode:
Use the name of the function. Pass any required arguments inside parentheses.
The following example calls the initialize function which requires no arguments:
initialize();
23of 37

To call a function in Normal Mode:
Use the evaluate action. Enter the function name and any required arguments in
the Expression field.
Use the evaluate action to call a function in Normal Mode
To call a function on another Timeline use a target path. For example, to call the
function calculateTax that was declared in the instance functionsMovieClip,
use the following path:
_root.functionsMovieClip.calculateTax(total);
Note: Pass any arguments inside the parentheses.
For more information on each function, including deprecated string functions, see
individual entries in ActionScript dictionary: Overview.
Creating custom functions
You can define functions to execute a series of statements on passed values. Your
functions can also return values. Once a function is defined, it can be called from any
Timeline, including the Timeline of a loaded movie.
A function can be thought of as a "black box": when a function is called, it is provided
with input (arguments). It performs some operation and then generates output (a
return value). A well-written function has carefully placed comments about its input,
output, and purpose. This way, a user of the function does not need to understand
exactly how the function works.
Defining a function
Functions, like variables, are attached to the movie clip that defines them. When a
function is redefined, the new definition replaces the old definition.
To define a function, use the function action followed by the name of the function,
any arguments to be passed to the function, and the ActionScript statements that
indicate what the function does.
The following is a function named Circle with the argument radius:
function Circle(radius) {
this.radius = radius;
24of 37

this.area = Math.PI * radius * radius;}
The keyword this, used in a function body, is a reference to the movie clip
that the function belongs to.
You can also define a function by creating a function literal. A function literal is an
unnamed function that is declared in an expression instead of in a statement. You
can use a function literal to define a function, return its value, and assign it to a
variable in one expression, as in the following:
area = (function () {return Math.PI * radius *radius;})(5);
Passing arguments to a function
Arguments are the elements on which a function executes its code. (In this book, the
terms argument and parameter are interchangeable.) For example, the following
function takes the arguments initials and finalScore:
function fillOutScorecard(initials, finalScore) {
scorecard.display = initials;
scorecard.score = finalScore;
}
Returning values from a function
You can use the return action to return values from functions. The return action
stops the function and replaces it with the value of the return action. If Flash
doesn't encounter a return action before the end of a function, an empty string is
returned. For example, the following function returns the square of the argument x:
function sqr(x) {
return x * x;
}
Some functions perform a series of tasks without returning a value. For example, the
following function initializes a series of global variables:
function initialize() {
boat_x = _root.boat._x;
boat_y = _root.boat._y;
car_x = _root.car._x;
car_y = _root.car._y;
}
Calling a function
To invoke a function using the Actions panel in Normal Mode, you use the evaluate
action. Pass the required arguments inside parentheses. You can call a function in
any Timeline from any Timeline, including a loaded movie. For example, the following
statement invokes the function sqr in movie clip MathLib on the main Timeline,
passes it the argument 3, and stores the result in the variable temp:
var temp = _root.MathLib.sqr(3);
Using predefined objects
You can use Flash's predefined objects to access certain kinds of information. Most
predefined objects have methods (functions assigned to an object) that you can call
to return a value or perform an action. For example, the Date object returns
information from the system clock and the Sound object lets you control sound
elements in your movie.
Some predefined objects have properties whose values you can read. For example,
the Key object has constant values that represent keys on the keyboard. Each object
has its own characteristics and abilities that can be used in your movie.
The following are Flash's predefined objects:
25of 37

Movie clip instances are represented as objects in ActionScript. You can call
predefined movie clip methods just as you would call the methods of any other
ActionScript object.
Creating an object
There are two ways to create an object: the new operator and the object initializer
operator ({}). You can use the new operator to create an object from a predefined
object class, or from a custom defined object class. You can use the object initializer
operator ({}) to create an object of generic type Object.
To use the new operator to create an object, you need to use it with a constructor
function. (A constructor function is simply a function whose sole purpose is to create
a certain type of object.) ActionScript's predefined objects are essentially prewritten
constructor functions. The new object instantiates, or creates, a copy of the object
and assigns it all the properties and methods of that object. This is similar to dragging
a movie clip from the Library to the Stage in a movie. For example, the following
statements instantiate a Date object:
currentDate = new Date();
You can access the methods of some predefined objects without instantiating them.
For example, the following statement calls the Math object method random:
Math.random();
Each object that requires a constructor function has a corresponding element in the
Actions panel toolbox; for example, new Color, new Date, new String, and so
on.
To create an object with the new operator in Normal Mode:
1 Choose setVariable
2 Enter an identifier in the Name field.
3 Enter new Object, new Color, and so on in the Value field. Enter any
26of 37

arguments required by the constructor function in parentheses.
4 Check the Expression box of the Value field.
If you don't check the Expression box, the entire value will be a string literal.
In the following code, the object c is created from the constructor Color:
c = new Color(this);
An object name is a variable with the object data type assigned to it.
To access a method in Normal Mode:
1 Select the evaluate action.
2 Enter the name of the object in the Expression field.
3 Enter a property of the object in the Expression field.
To use the object initializer operator ({}) in Normal Mode:
1 Select the setVariable action.
2 Enter name in the Variable field; this is the name of the new object.
3 Enter the property name and value pairs separated by a colon inside the object
initializer operator ({}).
For example, in this statement the property names are radius and area and their
values are 5 and the value of an expression:
myCircle = {radius: 5, area:(pi * radius * radius)};
The parentheses cause the expression to evaluate. The returned value is the value
of the variable area.
Accessing object properties
Use the dot (.) operator to access the value of properties in an object. The name of
the object goes on the left side of the dot, and the name of the property goes on the
right side. For example, in the following statement, myObject is the object and name
is the property:
myObject.name
To assign a value to a property in Normal Mode, use the setVariable action:
myObject.name = "Allen";
To change the value of a property, assign a new value as shown here:
myObject.name = "Homer";
You can also use the array access operator ([]) to access the properties of an
object..
Calling object methods
You can call an object's method by using the dot operator followed by the method.
For example, the following example calls the setVolume method of the Sound
object:
s = new Sound(this);
s.setVolume(50);
To call the method of a predefined object in Normal Mode, use the evaluate action.
Using the MovieClip object
You can use the methods of the predefined MovieClip object to control movie clip
symbol instances on the Stage. The following example tells the instance
dateCounter to play:
dateCounter.play();
Array (object)
The Array object allows you to access and manipulate arrays. An array is an object
whose properties are identified by a number representing their position in the array.
This number is sometimes referred to as the index. All arrays are zero based, which
27of 37

means that the first element in the array is [0], the second element is [1], and so on.
In the following example, myArray contains the months of the year, identified by
number.
myArray[0] = "January"
myArray[1] = "February"
myArray[2] = "March"
myArray[3] = "April"
To create an Array object, use the constructor new Array. To access the elements
of an array use, the array access operator [ ].
Method Description Syntax Argument Example
concat Concatenates
the arguments
and returns
them as a new
array.
myArray.concat
(value0,value1,..
.valueN);
value0,...valueN Numbers,
elements, or strings to be
concatenated in a new array.
The following code concatenates three
arrays:
num1=[1,3,5];
num2=[2,4,6];
num3=[7,8,9];
nums=num1.concat(num2,num3)
join Joins all
elements of an
array into a
string.
myArray.join();
myArray.join(se
parator);
separator A character or string
that separates array elements in
the returned string. If you omit
this argument, a comma is used
as the default
a = new Array("aa","bb","cc")
// assigns "aa,bb,cc" to myVar1
myVar1=a.join();
// assigns "aa, bb, cc" to myVar2
myVar2=a.join(", ");
// assigns "aa + bb + cc" to myVar3
myVar3=a.join(" + ");
pop Removes the
last element of
an array, and
returns its
value.
myArray.pop(); None. The following code creates the
myPets array containing four
elements, then removes its last
element:
myPets = ["a", "b", "c", "d"];
popped = myPets.pop();
push Adds one or
more elements
to the end of an
array and
returns the
array's new
length.
myArray.push(v
alue,...);
value One or more values to
append to the array.
The following code creates the
myPets array containing two
elements, then adds two elements to it.
After the code executes, pushed
contains 4.
myPets = ["cat", "dog"];
pushed = myPets.push("bird", "fish");
reverse Reverses the
direction of an
array.
myArray.revers
e();
None. The following is an example of using
the Array.reverse method:
var numbers = [1, 2, 3, 4, 5, 6];
trace(numbers.join());
numbers.reverse();
trace(numbers.join());
Output:
1,2,3,4,5,6
6,5,4,3,2,1
shift Removes the
first element
from an array,
and returns its
value.
myArray.shift(); None. The following code creates the array
myPets and then removes the first
element from the array:
myPets = ["cat", "dog", "bird", "fish"];
shifted = myPets.shift();
The return value is cat.
slice Extracts a
section of an
array and
returns it as a
new array.
myArray.slice(s
tart, end);
start A number specifying the
index of the starting point for
the slice. If start is a negative
number, the starting point
begins at the end of the array,
where -1 is the last element.
end A number specifying the
index of the ending point for the
slice. If you omit this argument,
the slice includes all elements
from the start to the end of the
array. If end is a negative
number, the ending point is
specified from the end of the
array, where -1 is the last
element.
28of 37

sort Sorts an array
in place.
myArray.sort();
myArray.sort(or
derfunc);
orderfunc An optional
comparison function used to
determine the sorting order.
Given the arguments A and B,
the specified ordering function
should perform a sort as
follows:
• -1 if A appears before
B in the sorted
sequence
• 0 if A = B
1 if A appears after B in the
sorted sequence
The following example uses
Array.sort without specifying the
orderfunc argument:
var fruits = ["oranges", "apples",
"strawberries",
"pineapples", "cherries"];
trace(fruits.join());
fruits.sort();
trace(fruits.join());
Output:
oranges,apples,strawberries,pineapple
s,cherries
apples,cherries,oranges,pineapples,str
awberries
toString Returns a
string value
representing
the elements in
the Array
object.
myArray.toStrin
g();
None. The following example creates
myArray and converts it to a string:
myArray = new Array();
myArray[0] = 1;
myArray[1] = 2;
myArray[2] = 3;
myArray[3] = 4;
myArray[4] = 5;
trace(myArray.toString())
Output:
1,2,3,4,5
unshift Adds one or
more elements
to the
beginning of an
array and
returns the
array's new
length.
myArray.unshift
(value1,value2,..
.valueN);
value1,...valueN One or more
numbers, elements, or variables
to be inserted at the beginning
of the array.
Property Description Syntax Argument Example
length Returns the
length of the
array.
myArray.length; None. The following code explains how the
length property is updated:
//initial length is 0
//myArray.length is updated to 1
myArray[0] = 'a';
myArray[1] = 'b';
myArray[9] = 'c';
Constructor for the Array object
Syntax
new Array();
new Array(length);
new Array(element0, element1, element2,...elementN);
Arguments
length An integer specifying the number of elements in the array. In the case of
noncontiguous elements, the length specifies the index number of the last element in
the array plus 1. For more information, see the property Array.length.
element0...elementN A list of two or more arbitrary values. The values can be
numbers, names, or other elements specified in an array. The first element in an
array always has the index or position 0.
Description
Constructor; allows you to access and manipulate elements in an array. Arrays are
zero based and the elements are indexed by their ordinal number.
If you don't specify any arguments, a zero-length array is created.
29of 37

Example
The following example creates a new Array object with an initial length of 0:
The following example creates the new Array object Team, with an initial length of 4:
Team = new Array("Jody", "Mary", "Marcelle", "Judy");
The initial elements of the Team array are as follows:
myArray[0] = "Jody"
myArray[1] = "Mary"
myArray[2] = "Marcelle"
myArray[3] = "Judy"
Color (object)
The Color object allows you to set and retrieve the RGB color value and color
transform of movie clips. The Color object is supported by Flash 5 and later versions
of the Flash Player.
You must use the constructor new Color() to create an instance of the Color
object before calling the methods of the Color object.
Method summary for the Color object
getRGB Returns the
numeric RGB
value set by the
last setRGB call.
myColor.getRG
B();
None. The following code retrieves the RGB
value as a hexadecimal string:
value = (getRGB()).toString(16);
getTransform Returns the
transform
information set by
the last
setTransform call.
myColor.getTra
nsform();
None.
setRGB Specifies an RGB
color for the Color
object. Calling
this method
overrides any
previous settings
by the
setTransform
method.
myColor.setRG
B(0xRRGGBB);
0xRRGGBB The hexadecimal or
RGB color to be set. RR, GG,
and BB each consist of two
hexadecimal digits specifying
the offset of each color
component.
The following example sets the RGB
color value for the movie clip myMovie:
myColor = new Color(myMovie);
myColor.setRGB(0x993366);
setTransform Sets color
transform
information for a
Color object. The
colorTransformO
bject argument is
an object that you
create using the
generic Object
object with
parameters
specifying the
percentage and
offset values for
the red, green,
blue, and alpha
(transparency)
components of a
color, entered in a
0xRRGGBBAA
format.
myColor.setTra
nsform(colorTra
nsformObject);
colorTransformObject An object
created using the constructor of
the generic Object object,
specifying color transform
values for parameters. The
color transform object must
have the parameters ra, rb, ga,
gb, ba, bb, aa, ab, which are
explained below.
The parameters for a color
transformobject are defined as
follows:
ra is the percentage for the
red component (-100 to 100).
rb is the offset for the red
component (-255 to 255).
ga is the percentage for the
green component (-100 to 100).
gb is the offset for the green
ba is the percentage for the
blue component (-100 to 100).
bb is the offset for the blue
aa is the percentage for
alpha (-100 to 100).
The following example shows the
process of creating a new Color object
for a target movie, creating a color
transformobject with the parameters
defined above using the Object
constructor, and passing the color
transform object to a Color object
using the setTransform method.
//Create a color object called myColor
for the target myMovie
//Create a color transform object called
myColorTransfrom using
//the generic Object object
myColorTransform = new Object;
// Set the values for myColorTransform
myColorTransform = { ra: '50', rb: '244',
ga: '40', gb: '112', ba: '12', bb: '90', aa:
'40', ab: '70'}
//Associate the color transform object
with the Color object created for
myMovie
myColor.setTransform(myColorTransfo
rm);
30of 37

ab is the offset for alpha
(-255 to 255).
Constructor for the Color object
Syntax
new Color(target);
Arguments
target The name of the movie clip the new color is applied to.
Description
Constructor; creates a Color object for the movie clip specified by the target
argument.
Example
The following example creates a new Color object called myColor for the movie
myMovie:
Key (object)
The Key object is a top-level object that you can access without using a constructor.
Use the methods for the Key object to build an interface that can be controlled by a
user with a standard keyboard. The properties of the Key object are constants
representing the keys most commonly used to control games. See Appendix B,
"Keyboard Keys and Key Code Values," for a complete list of key code values.
Example
onClipEvent (enterFrame) {
if(Key.isDown(Key.RIGHT)) {
setProperty ("", _x, _x+10);
}
}
or
onClipEvent (enterFrame) {
if(Key.isDown(39)) {
setProperty("", _x, _x+10);
}
}
Method summary for the Key object
Method Description Syntax Argument
getAscii Returns the
ASCII value of
the last key
pressed.
Key.getAscii(); None.
getCode Returns the
virtual key
code of the
last key
pressed.
Key.getCode(); None.
isDown Returns true if
the key
specified in
the argument
is pressed.
Key.isDown(keycode); keycode The key
code value
assigned to a
specific key, or a
Key object
property
associated with a
specific key.
Appendix B,
"Keyboard Keys
and Key Code
Values," lists all of
the key codes
associated with the
keys on a standard
keyboard.
isToggled Returns true if Key.isToggled(keycode) keycode The key
31of 37

the Num Lock
or Caps Lock
key is
activated.
code for Caps Lock
(20) or Num Lock
(144).
Property summary for the Key object
All of the properties for the Key object are constants.
Property Description Syntax
BACKSPACE Constant associated with the key code value for the Backspace key (9). Key. BACKSPACE
CAPSLOCK Constant associated with the key code value for the Caps Lock key (20). Key. CAPSLOCK
CONTROL Constant associated with the key code value for the Control key (17). Key.CONTROL
DELETEKEY Constant associated with the key code value for the Delete key (46). Key. DELETEKEY
DOWN Constant associated with the key code value for the Down Arrow key (40). Key.DOWN
END Constant associated with the key code value for the End key (35). Key.END
ENTER Constant associated with the key code value for the Enter key (13). Key.ENTER
ESCAPE Constant associated with the key code value for the Escape key (27). Key.ESCAPE
HOME Constant associated with the key code value for the Home key (36). Key.HOME
INSERT Constant associated with the key code value for the Insert key (45). Key.INSERT
LEFT Constant associated with the key code value for the Left Arrow key (37). Key.LEFT
PGDN Constant associated with the key code value for the Page Down key (34). Key.PGDN
PGUP Constant associated with the key code value for the Page Up key (33). Key.PGUP
RIGHT Constant associated with the key code value for the Right Arrow key (39). Key.RIGHT
SHIFT Constant associated with the key code value for the Shift key (16). Key.SHIFT
SPACE Constant associated with the key code value for the Spacebar (32). Key.SPACE
TAB Constant associated with the key code value for the Tab key (9). Key.TAB
UP Constant associated with the key code value for the Up Arrow key (38). Key.UP
Mouse (object)
Use the methods of the Mouse object to hide and show the cursor in the movie. The
mouse pointer is visible by default, but you can hide it and implement a custom
cursor that you create using a movie clip.
Mouse method summary
Method Description Syntax Example
hide Hides the cursor in
the movie.
Mouse.hide();
The following code, attached to a
movie clip on the main Timeline, hides
the standard cursor and sets the x and
y positions of the customCursor movie
clip instance to the x and y mouse
positions in the main Timeline:
onClipEvent(enterFrame){
Mouse.hide();
customCursorMC_x =
_root._xmouse; customCursorMC_y
= _root._ymouse;}
show Displays the cursor
in the movie.
Mouse.show();
MovieClip (object)
The methods for the MovieClip object privide the same functionality as the standard
actions that target movie clips. There are also additional methods that provide
functionality that is not available using the standard actions listed in the Actions
category of the Actions panel. You do not need to use a constructor method in order
to call the methods of the MovieClip object; instead, you reference movie clip
instances by name, using the following syntax:
anyMovieClip.play();
32of 37

anyMovieClip.gotoAndPlay(3);
Method summary for the MovieClip object
attachMov
ie
creates a new
instance of a movie
in the library and
attaches it to the
movie specified by
anyMovieClip.
Use the
removeMovieC
lip or
unloadMovie
action or method to
remove a movie
attached with
attachMovie.
anyMovieClip.atta
chMovie(idNam
e, newname,
depth);
idName The name of the movie in
the library to attach. This is the
name entered in the Identifier field
in the Symbol Linkage Properties
dialog box.
newname A unique instance name
for the movie clip being attached.
depth An integer specifying the
depth level where the movie is
placed.
duplicate
MovieClip
creates an instance
of the specified
movie clip while the
movie is playing.
Duplicated movie
clips always start
playing at frame 1,
no matter what
frame the original
movie clip is on
when the
duplicateMovi
eClip method is
called. Variables in
the parent movie
clip are not copied
into the duplicate
movie clip. If the
parent movie clip is
deleted the
duplicate movie clip
is also deleted.
Movie clips added
with
duplicateMovi
eClip can be
deleted with
removeMovieC
lip action or
method.
anyMovieClip.dup
licateMovieClip(n
ewname,
depth);
newname A unique identifier for
the duplicate movie clip.
depth A number specifying the
depth level where the movie
specified is to be placed.
getBounds Returns the
minimum and
maximum x and y
coordinate values of
the MovieClip for the
target coordinate
space specified in
the argument. The
return object will
contain the
properties {xMin,
xMax, yMin,
yMax}. Use the
localToGlobal
and
globalToLocal
methods of the
MovieClip object to
convert the movie
anyMovieClip.get
Bounds(targe
tCoordinat
eSpace);
targetCoordinateSpace The target
path of the Timeline whose
coordinate space you want to use
as a reference point.
The following example
uses getBounds to
retrieve the bounding
box of the
myMovieClip
instance in the
coordinate space of the
main movie:
myMovieClip.getBounds
(._root);
33of 37

clip's local
coordinates to Stage
coordinates, or
Stage coordinates to
local coordinates
respectively.
getURL Retrieves a
document from a
URL.
anyMovieClip.get
URL(URL
[,window,
variables]
]);
URL The URL from which to
obtain the document.
window An optional argument
specifying the name, frame, or
expression specifying the window
or HTML frame that the document
is loaded into. You can also use
one of the following reserved
target names: _self specifies the
current frame in the current
window, _blank specifies a new
window, _parent specifies the
parent of the current frame, _top
specifies the top-level frame in the
current window.
variables An optional argument
specifying a method for sending
variables associated with the
movie to load. If there are no
variables, omit this argument;
otherwise, specify whether to load
variables using a GET or POST
method. GET appends the
variables to the end of the URL,
and is used for small numbers of
variables. POST sends the
variables in a separate HTTP
header and is used for long
strings of variables.
globalToL
ocal
Converts the point
object from Stage
coordinates to the
local coordinates of
the specified movie
clip.
anyMovieClip.glo
balToLocal(point)
;
point The name or identifier of an
object created with the generic
Object object specifying the x and
y coordinates as properties.
converts the global x
and y coordinates of the
point object to the
local coordinates of the
movie clip:
onClipEvent(mouseMov
e) {
point = new
object();
point.x =
_root._xmouse;
point.y =
_root._ymouse;
globalToLocal(point);
_root.out =
_xmouse + " === " +
_ymouse;
_root.out2 =
point.x + " === " +
point.y;
updateAfterEvent();
}
gotoAndPl
ay
Sends the playhead
to a specific frame
in the movie clip and
plays the movie.
anyMovieClip.got
oAndPlay(fram
e);
frame The frame number to which
the playhead will be sent.
gotoAndSt
op
Sends the playhead
to a specific frame
in the movie clip and
stops the movie.
anyMovieClip.got
oAndStop(fram
e);
frame The frame number to which
the playhead will be sent.
hitTest Returns true if anyMovieClip.hitT x The x coordinate of the hit area The following example
34of 37

bounding box of the
specified movie clip
intersects the
bounding box of the
target movie clip.
est(x, y,
shapeFlag);
anyMovieClip.hitT
est(target);
on the Stage.
y The y coordinate of the hit area
on the Stage.
The x and y coordinates are
defined in the global coordinate
space.
target The target path of the hit
area that may intersect or overlap
with the instance specified by
anyMovieClip. The target
usually represents a button or
text-entry field.
shapeFlag A Boolean value
specifying whether to evaluate the
entire shape of the specified
instance (true), or just the
bounding box (false). This
argument can only be specified if
the hit area is identified using x
and y coordinate arguments.
uses hitTest with the
x_mouse and
y_mouse properties
to determine whether the
mouse is over the
target's bounding box:
if
(hitTest( _root._xmouse,
_root._ymouse, false));
uses hitTest to
determine if the movie
clip ball overlaps or
intersects with the
movie clip square:
if(_root.ball,
hittest(_root.square)){
trace("ball
intersects
square");
}
loadMovie Loads the specified
movie into the
movie clip.
loadVaria
bles
Loads variables
from a URL or other
location into the
movie clip.
anyMovieClip.loa
dVariables(url,
variables);
url The absolute or relative URL
for the external file. The host for
the URL must be in the same
subdomain as the movie clip.
variables The method for
retrieving the variables. GET
appends the variables to the end
of the URL, and is used for small
numbers of variables. POST
sends the variables in a separate
HTTP header and is used for long
strings of variables
localToGl
obal
Converts a Point
object from the local
coordinates of the
movie clip to the
global Stage
coordinates.
nextFrame Sends the playhead
to the next frame of
the movie clip.
anyMovieClip.nex
tFrame();
play Plays the specified
movie clip.
anyMovieClip.pla
y();
prevFrame Sends the playhead
to the previous
frame of the movie
clip.
anyMovieClip.pre
vFrame();
removeMov
ieclip
Removes a movie
clip instance created
with the
duplicateMovi
eclip action, or the
duplicateMovi
eClip or
attachMovie
methods of the
MovieClip object.
anyMovieClip.rem
oveMovieClip();
startDrag Specifies a movie
clip as draggable
and begins dragging
the movie clip.
anyMovieClip.star
tDrag([lock,
left, right,
lock A Boolean value specifying
whether the draggable movie clip
is locked to the center of the
mouse position (true), or locked
35of 37

top,
bottom]);
to the point where the user first
clicked on the movie clip (false).
This argument is optional.
left, top, right, bottom Values
relative to the coordinates of the
movie clip's parent that specify a
constraint rectangle for the movie
clip. These arguments are
optional.
stop Stops the currently
playing movie.
anyMovieClip.sto
p();
stopDrag Stops the dragging
of any movie clip
that is being
dragged.
anyMovieClip.sto
pDrag();
swapDepth
s
Swaps the depth
level of specified
movie with the
movie at a specific
depth level.
unloadMov
ie
Removes a movie
loaded with
loadMovie.
Sound (object)
The Sound object allows you to set and control sounds in a particular movie clip
instance, or for the global Timeline, if you do not specify a target when creating a
new sound object. You must use the constructor new Sound to create an instance of
the Sound object before calling the methods of the Sound object.
The Sound object is only supported for the Flash 5 Player.
Method summary for the Sound object
Method Description
attachS
ound
Attaches the sound specified in the argument.
getPan Returns the value of the previous setPan call.
getTran
sform
Returns the value of the previous setTransform call.
getVolu
me
Returns the value of the previous setVolume call.
setPan Sets the left/right balance of the sound.
setTran
sform
Sets transform for a sound.
setVolu
me
Sets the volume level for a sound.
start Starts playing a sound from the beginning or, optionally, from an offset point set in the argument.
stop Stops the specified sound or all sounds currently playing.
Constructor for the Sound object
Syntax
new Sound();
new Sound(target);
Arguments
target The movie clip instance that the Sound object applies to. This argument is
optional.
Description
Method; creates a new Sound object for a specified movie clip. If you do not specify a
target, the Sound object controls all of the sounds in the global Timeline.
36of 37

Example
GlobalSound = new Sound();
MovieSound = new Sound(mymovie);
Handling Sounds(or Movie Clips) using ActionScript
Sound
i. Go to File > Import. The Import dialog box will appear. Browse for and select the
sound file(say 'world') you need and press the Open button. The sound file has been
imported into your Flash movie.
ii. Press Ctrl + L or go to Window > Library. The Flash Library will appear. You will
notice the sound file you just imported contained in the Library. Right click on the
sound file's name 'world' and select Linkage. The Symbol Linkage Properties dialog
box will appear:
[ the symbol linkage properties dialog box ]
iv. In the Symbol Linkage Properties dialog box, select the "Export this symbol" option.
Once you select the Export this symbol option, the Identifier field will be enabled. You
should enter a name that will uniquely identify this sound file. Let's simply identify the
sound file as "coolsound". Enter coolsound in the Identifier field:
[ the sound file has been given a unique identifier name ]
v. Once you entered coolsound for the Identifier value, press OK to close the Symbol
Linkage Properties dialog box.
i. Let's go back to the main timeline. Draw a button.
ii. Once you have created the button, right click on the button and select Actions. Copy
and paste the following section of code:
on (release) {
mySound = new Sound(this);
mySound.attachSound("coolsound");
mySound.start(0, 99);
}
viii. Save the FLA and preview the animation. Click the button you just created. If all went
well, you should hear the music play.
Movie Clip
Follow the above mentioned Step-ii to Step-v to make the movie clip available for action script
and then you can handle movie clip in runtime.
37of 37

Final action script

More Related Content

Similar to Final action script (20)

More from pavishkumarsingh (19)

Recently uploaded (20)

Final action script