Regardless of what interactive authoring tool you use (Adobe Dreamweaver, Adobe Flash, Macromedia Director, and so on), you can't begin any production work until you have a clear idea of the product. What is it that you are setting out to do? At this point in the process, you should use natural language to describe your problems; that is, define your objective (or problem) in a way that you understand it. For example, let's say that you want to make a quiz. You'll have to run through a list of goals for that interactive product:

Other questions, of course, could help define what your product will encompass. Don't try to start Flash production without setting some project parameters for yourself.

After you have defined the boundaries for the project, you can start to map the process with which your product will operate. This step involves the procedure of the experience (in other words, how the person will use the product you are creating). With the quiz example, you might clarify the solution as:

The preceding eight steps are similar to a process flowchart, as we discussed in Chapter 3, "Planning Flash Projects." In real-life production, you would want to clarify Step 8 for each question in the same amount of detail as Steps 5 through 7 did. As you can see, once you start to map the interactive experience, you'll have a much better starting point for your scripting work. Notice that we're already using logic, with our if statements in Steps 6 and 7. We're also determining object properties such as _visible in Step 4. While you may not know all the ActionScript involved with starting a timer, you know that you have to learn how time can be measured in a Flash movie.

After you have created a process for the movie to follow, you can start to convert each step into a format that Flash can use. This step will consume much of your time as you look up concepts and keywords in this book, the Flash ActionScript Bible series (Wiley), or Adobe's updated Help panel that ships with Flash CS3. It's likely that you won't be able to find a prebuilt Flash movie example to use as a guide, or if you do, that you'll need to customize it to suit the particular needs of your project. For the quiz example, we could start to translate the solution as:

Although there is more than one way we could have translated this into ActionScript-like syntax, you'll notice that a few key concepts are presented in the translation: where events occur (frames or buttons), and which elements (for example, Button symbols or MovieClip instances) are involved.

Most important, you'll notice that we used the same procedure for both the True and the False buttons. Even though we could hardwire the answer directly in the Button actions, we would have to change our Button actions for each question. By placing the same logic within each Button instance, we have only to change the value of the answer variable from frame to frame (or from question to question).

Granted, this example was already translated for you, and 90 percent of your scripting woes will be in the translation process — before you even have a testable Flash movie. You need to learn the basic terminology and syntax of the ActionScript language before you can start to write the scripting necessary for Steps 1 to 7. And that's exactly what the rest of this chapter (and the rest of Part VII) begins to teach you.

All of the ActionScript commands are found in the Flash interface in the Action booklets or plus (+) button menu of the Actions panel. However, assembling actions with one another is not something Flash CS3 automatically performs unless you use the Behaviors panel to add interactive functionality to your movie elements. Although it is beyond the scope of this chapter to fully explain fundamental programming principles, we can give you a sense of the whole of ActionScript by providing an organized reference to each of its parts.

In the Actions panel, you can cut, copy, and paste code within the Script pane from one area of your movie to another using Ctrl+X (

Using Esc Shortcut Keys for actions

In Flash CS3, you can choose to show or hide shortcut keys in the Actions panel. In the options menu of the Actions panel, choose Esc Shortcut Keys (if it's not already checked). Now, click the plus (+) menu of the Actions panel to access ActionScript commands. Notice that shortcut keys are defined after the name of the command. Note that the Mac version of Flash CS3 only shows the shortcut keys in the action booklets, not in the plus (+) menu.

For example, loadMovie(), in the Global Functions

Most shortcut keys have been created for ActionScript 1.0 and 2.0 compatible actions.

Don't know what the methods of the Sound object are? Need to see if the getVersion() function will work in a Flash Player 4–compatible movie? Flash CS3 has conveniently nested everything related to help documentation in the Help panel. Among other items, the updated Help panel contains all the syntax of the ActionScript language. You can access the Help panel in a few ways:

We'll quickly show you how to use the new Help panel in an actual Flash document:

You can select other actions from the left pane of the Help panel and view their descriptions.

So why all the fuss about ActionScript now? Let's make one thing clear right away: For most Flash designers and developers, or rather for most of the work that's done in Flash, the graduation of ActionScript 1.0 to 2.0, may mean next to nothing at all. This isn't to say that ActionScript 2.0 should be ignored or is not a monumental leap forward for Flash programming — we simply want to calm or allay any fears you might have after reading about ActionScript 2.0 from other sources. If you've used ActionScript in Flash versions prior to MX 2004, then ActionScript 1.0 refers to the coding styles that those versions of the application used.

ActionScript 2.0 introduced a couple of major structural changes to the way in which you can code Flash ActionScript. To begin with, it uses strong data typing. You'll learn more about data typing in Chapter 26, "Using Functions and Arrays," but for now, know that ActionScript 2.0 imposes some rules on how you can assign values to variables, functions, and other objects in your code. Unless you're creating code that uses custom classes and object-oriented programming concepts such as inheritance and prototypes, you won't really need to worry about whether your code will work as ActionScript 2.0 code. Another big change with ActionScript 2.0 is case-sensitivity. Prior to Flash Player 7, most ActionScript terms were case-insensitive, meaning you could refer to object references or variables with varying cases, such as:

var firstName = "Robert";
var lastName = "Reinhardt";
var fullName = firstName + " " + lastName;

var contactName:String = "Joseph Farnsworth";
var contactStreet:String = "675 Locust Street";
var contactCity:String = "Chicago";
var contactState:String = "IL";
var contactPhone:String = "312-555-1342";
var contactEmail:String = "[email protected]";

#include "contact.as"

#include "contact.as";

In ActionScript 1.0, you could have used the following code as the last line, without receiving an error:

var fullName = firstname + " " + lastname;

However, in ActionScript 2.0, that same line of code would be incorrect because firstname and lastname are not using the same case as the original variables.

Why should the distinction between ActionScript 1.0 and 2.0 even be an issue? For starters, when you publish a Flash movie for Flash Player 6, 7, or 8, you need to decide how Flash CS3 will compile the ActionScript code in your document. In the Publish Settings dialog box, you can choose which ActionScript version to publish in the Flash tab. Unless directed otherwise, you publish most of the Flash movies for Part VII of this book as ActionScript 2.0, even though it pretty much looks and feels like ActionScript 1.0.

In programmer speak, a string is any combination of alphanumeric characters. By themselves, they have no meaning. It is up to you to assign something meaningful to them. For example, giving a variable the name firstName doesn't mean much. You need to assign a value to the variable firstName to make it meaningful, and you can do something with it. For example, if firstName = "Susan", you could make something specific to "Susan" happen.

You can also use much simpler name/value pairs, such as i = 0, to keep track of counts. If you want a specific Movie Clip animation to loop only three times, you can increment the value of i by 1 (for example, i = i + 1, i += 1, and i ++ all do the same thing) each time the animation loops back to the start. Then, you can stop the animation when it reaches the value of 3.

Flash uses the term expression to refer to two separate kinds of code fragments in ActionScript. An expression is either a phrase of code used to compare values in a Conditional or a Loop (these are known as conditional expressions), or a snippet of code that is interpreted at runtime (these are known as numeric expressions and string expressions). We discuss conditional expressions later in this chapter.

Numeric and string expressions are essentially just segments of ActionScript code that are dynamically converted to their calculated values when a movie runs. For instance, suppose you have a variable, y, set to a value of 3. In the statement x = y + 1, the y + 1 on the right side of the equal sign is an expression. Hence, when the movie runs, the statement x = y + 1 actually becomes x = 4, because the value of y (which is 3) is retrieved (or "interpreted") and the calculation 3 + 1 is performed. Numeric and string expressions are an extremely potent part of ActionScript because they permit most of the parameters used in actions to be based on mathematical calculations and external variables rather than requiring fixed information. Consider these two examples:

As we mentioned in an earlier section, to change all the URLs in your movie from a staging server to a live server, you'd just have to change the value of the server variable. So, to change the latter example's code for a live Web server, you'd simply change the serverName variable, as the following code demonstrates:

var serverName = "http://www.flashsupport.com/";

All of the other lines of code would stay the same, because you only need to change the server location for the live Web site.

Anywhere that you see the word "expression" in any action options, you can use an interpreted ActionScript expression to specify the value of the option.

To use a string inside an expression, simply add quotation marks around it. Anything surrounded by quotation marks is taken as a literal string. For example, the conditional if (status == ready) wrongly checks whether the value of the variable status is the same as the value of the nonexistent variable ready. The correct conditional would check whether the value of status is the same as the string "ready" by quoting it, as in if (status == "ready").

You can even have expressions that indirectly refer to previously established variables. In ActionScript, you can use the dot syntax (and array access operators) to indirectly refer to variables, or you can use Flash 4's eval() function (to maintain backward compatibility).

We like to use the phrase "setting and getting" to help beginners understand how equations and expressions work in ActionScript code. An equation is any line of code that sets an object or variable to a new value. The order of syntax terms can be confusing to designers and developers new to code writing. Do you specify a value first? How do you know where to insert the equal sign (=)? If you remember the phrase "setting and getting," you'll know how to write basic equations. The variable you want to set (or assign a new value) is always on the left side of the equation, while the new value is always on the right:

what you want to set = the value you want to get

For example, if you wanted to set a variable named currentTime to the amount of time that has elapsed since the Flash movie started playing in the Flash Player, you would place currentTime on the left side of the equation and place the actual value of the time on the right side:

current time in the movie = the number of milliseconds that have elapsed

Translated into actual code, this would be:

var currentTime = getTimer();

Again, another important aspect of variables to remember is that the name of a variable is quite arbitrary. What we called currentTime could just as well be named myTime, movieTime, elapsedTime — or whatever you want to call it. As long as you consistently refer to your variable's name in subsequent ActionScript code, everything will work as expected.

In most scripting languages, you usually don't have to declare a variable without its value; that is, you don't need to say variable firstName and then address it again with a value. In Flash ActionScript, you don't need to pre-establish a variable in order to invoke it.

If you want to create a variable on the fly from a Movie Clip to the Main Timeline, you can. Most variables that you use in Flash will be declared in a timeline's keyframes. We'll show you how to create a couple of simple variables in a Flash document:

As you can see in this example, the firstName variable is shown at _level0, which is the _root of the current Flash movie. All variables belong to a specific timeline or object.

Since Flash 4, text can be specified as text fields. A text field can be used as a dynamic text container whose content can be updated via ActionScript and/or the intervention of a server-side script (known in Flash CS3 as Dynamic text), or it can accept input from the user (known in Flash CS3 as Input text).

You can access a text field's properties by selecting the text field and opening the Property inspector. In the inspector, you can define the parameters of the text object, including its Var (for Variable) name and instance name.

An Input text field is editable when the Flash movie is played in the Flash Player; the user can type text into the text field. This newly typed text becomes the value of the text field's Var name, or the text property of the text field. On a login screen, you can create an Input text field with an instance name loginField, where the user enters his or her name, such as Joe. In ActionScript, this would be received as loginField.text = "Joe". Any text that you type into a text field during the authoring process will be that property's initial value.

To review this process of text fields and variable names, let's create a simple example:

This simple exercise demonstrates how the Var assignment of a TextField object differs from the instance name assignment. In ActionScript 1.0 or 2.0, the actual text displayed in the TextField object can be accessed in two ways: as a variable called firstName_var or as a property of the TextField object, tFirstName.text. Dynamic text fields behave in the same manner as well.

The most common way to create a variable is to type the variable's name and value in the Script pane of the Actions panel, on a specific timeline's keyframe. Most basic variables will have values that are string literals.

You can also establish variables by loading them from an external source, such as a text file located on your Web server or even through a database query or a server-side script. By using the loadVariables() action, you can load variables in this fashion. There are three primary parameters for the loadVariables() action: URL, target, and variables:

loadVariables(url, target, [,variables]);

The variables parameter is optional. In the Help panel pages in the ActionScript Dictionary, any parameters displayed with surrounding left and right brackets ( [ ] ) are optional.

URL specifies the source of the variables to be loaded. This can be a relative link to the variable source (you don't need to enter the full path of the resource). You can specify whether this URL value is a literal value ("http://www.theMakers.com/cgi-bin/search.cfm") or an expression that uses a variable or a combination of variables (serverURL + scriptPath + scriptApp). If you want to point to a specific file, type its relative path and name here. If you want to access a database that returns dynamic data, insert the path to the script, such as "http://www.domain.com/cgi-bin/search.pl".

The target parameter determines where the variables are to be loaded. You can send the name/value pairs to a level or a timeline target. If you want the variables to be available on the Main Timeline, use _root or _level0. You can also specify a Movie Clip target using a relative or absolute address. To load to the current Movie Clip (the one initiating the loadVariables action), use the target this.

The last option is variables, and this parameter specifies whether you are sending and loading (in other words, receiving) variables. If you want to load variables from a static source, such as a text file, you should omit this parameter. If you are sending a query to a database-driven engine, then you may need to specify either "GET" or "POST". Note that the use of loadVariables() in the GET or POST method means that you are sending variables declared on the active timeline to the specified URL, which, in turn, will send name/value pairs back to the Flash movie.

The formatting of name/value pairs is standard URL-encoded text. If you want to encode name/values in a text file (or a database), you need to use the following format:

variable=value&variable=value...

Basically, in URL-encoded text, name/value pairs are joined by an ampersand (&). To join multiple terms in a value, use the plus (+) symbol to add a single whitespace character between the terms, as in:

name1=Joe+Smith&name2=Susan+Deboury

You can also send variables to a URL by using the getURL() action. Any name/value pairs that are declared on the active timeline will be sent along with the getURL() action if a variable send method is defined (GET or POST). Note that getURL() is only used to send variables out of a Flash movie — it will not retrieve or load any subsequent name/value pairs. If you use a getURL() action on a Movie Clip timeline as follows:

var firstName = "Robert";
getURL("/cgi-bin/form.cgi", "_blank", "GET");

the Flash movie will send the following request to your server:

http://www.server.com/cgi-bin/form.cgi?firstName=Robert;

The output of the form.cgi script would be opened in a new browser window ("_blank").

You can also send variables to Flash movies in the <embed> and <object> tags that call the Flash movie. In the src attribute of <embed> or the param name="movie" subtag of the <object> tag, attach the name/value pairs to the end of the Flash movie filename, separated by a question mark (?).

<object ... >
<param name="movie" value="flash.swf?name=Rob" />
<embed src="flash.swf?name=Rob" ... />

This method works with Flash Player 4 or later movies. However, Flash Player 6 and higher can recognize the HTML attribute flashvars. Now, you can specify longer strings of name/value pairs that will be declared in the Flash movie as soon as it loads into the Flash Player. The previous method that we showed is limited to strings that are about 1,024 characters long (depending on the Web browser), which include the movie's full URL. With the newer flashvars attribute, you don't need to rely on the URL of the movie. Here's an example of declaring a few variables with the flashvars attribute:

<object ...>
<param name="movie" name="flash.swf" />
<param name="flashvars"
   name="firstName=Gregory&lastName=Smith&address=1234+Hollywood+Way" />
<embed src="flash.swf"
flashvars="firstName=Greg&lastName=Smith&street=1234+Broadway" ... />

In practical use, you would not likely hard code the name/value pairs directly into the HTML document. You can use client-side JavaScript or server-side scripting (such as PHP, ASP.NET, or ColdFusion) to dynamically "write" the name/value pairs into the HTML document before it is served to the user's Web browser.

Operators perform combinations, mathematical equations, and value comparisons. See Table 24.1 for a list of common operators in the ActionScript language.

if (results > 1)
name = "Robert";
_root["name_" + i] = "Ezra";

var fullName = firstName + " " + lastName;

set ("fullName", firstName add " " add lastName);

// Flash Player 5 and later syntax below

if (results > 1 && newResults < 10){
   // do something...
}

// Flash Player 4 syntax below

if (results > 1 and newResults < 10){
   // do something...
}

Conditions lie at the heart of logic. To create an intelligent machine (or application), you need to create a testing mechanism. This mechanism (called a conditional) needs to operate on rather simple terms. Remember the true/false tests you took in grade school? if/else statements work on a similar principle: If the condition is true, execute a set of actions. If the condition is false, disregard the enclosed actions and continue to the next condition or action.

You can simply create isolated if statements that do not employ else (or else if) statements. Solitary if statements are simply ignored if the condition is false. else statements are used as a default measure in case the tested condition proves false. else if statements continue to test conditions if the previous if (or else if) was false. Refer to the following examples for more insight.

In production, you could have an if/else structure that assigned the value of one variable based on the value of another, such as:

if (x == 1){
   name = "Margaret";
} else if (x == 2){
   name = "Michael";
} else {
   name = "none";
}

You can add an if statement in ActionScript by choosing the if action from the plus (+) button in the toolbar of the Actions panel, or by selecting it from the Statements

You can join two conditions using logical compound operators such as and (&&), or (||), or not (!), as in:

if (results >1 && newResults < 10){
     gotoAndPlay ("end");
} else if (results > 1 ! newResults < 10) {
     gotoAndPlay ("try_again");
}

In this sample code, the first if statement has two expressions — both need to be true in order for the gotoAndPlay("end"); code to execute. If both are not true, the else if condition executes. If the first condition is true and the second condition is not true, the gotoAndPlay("try_again"); code executes. If neither the if nor the else if condition is true, then no code is executed.

We'll take a look at a step-by-step example of if statements in the exercise at the end of this chapter.

In ActionScript, you can also use switch() and case statements. switch() and case can replace extended if and else if actions. Instead of declaring a true/false expression (as with if statements), switch() uses an expression that can return any value — you are not limited to true and false conditions with switch(). In pseudo-code, a switch() code structure looks like this:

test a value
   if the value equals this expression
      then execute this code
   if the value equals this expression
      then execute this code
   if none of the expressions match the value
      then execute this code
end test

In the previous code example, one or more if statements (called case clauses) can execute. Meaning, the tested value can execute more than one segment of code nested within the clauses. You could translate the previous pseudo-code into the following ActionScript code:

var currentFrame = _root._currentframe;
switch(currentFrame){
   case 10:
      helpBox.gotoAndStop("products");
   case 20:
      helpBox.gotoAndStop("services");
   case 30:
      helpBox.gotoAndStop("contact");
   default:
      helpBox.gotoAndStop("error");
}

In the previous code example, although it's only possible for currentFrame to equal one value, the default clause will also execute — regardless of the value of currentFrame. However, you may not want to execute the default clause (or multiple case clauses). In this situation, you need to use the break action to "escape" the switch() action. The break action prevents subsequent clauses from being evaluated.

In the following code, only one clause can execute:

var currentFrame = _root._currentframe;
switch(currentFrame){
   case 10:
      helpBox.gotoAndStop("products");
      break;
   case 20:
      helpBox.gotoAndStop("services");
      break;
   case 30:
      helpBox.gotoAndStop("contact");
      break;
   default:
      helpBox.gotoAndStop("error");
}

You can use switch() actions for many other situations. If you wanted to make a card game in Flash, you could use a switch() expression to pick a card suit based on a random number:

1.  var suitNum = Math.round(Math.random()*3);
2.  switch(suitNum){
3.     case 0:
4.        suit = "diamonds";
5.        break;
6.     case 1:
7.        suit = "spades";
8.        break;
9.     case 2:
10.       suit = "hearts";
11.       break;
12.    case 3:
13.       suit = "clubs";
14.       break;
15. }
16. cardFace.gotoAndStop(suit);

In this code, a random number is picked (line 1) and used as an expression in the switch() action (line 2). The random number (represented as a variable named suitNum) will then be matched to a case clause. The matching clause will set a variable named suit to equal a specific card suit and exit the switch() action (lines 3 through 15). A Movie Clip instance named cardFace will go to and stop on a frame named after one of the card suits (line 16).

A loop is a container for a statement or series of statements repeated as long as a specified condition exists. A basic loop has three parts: the condition, the list of statements to be repeated, and a counter update. There are four types of loops in ActionScript:

Each of these loop types has a specific use. Depending on the repetitive actions you wish to loop, you need to decide how best to accommodate your code with loop actions.

var count = 1;  // Initial variable
while (count <= 10){  // Condition
  _root["clip_" + count]._xscale = 100/count; // Statements to be repeated
  count = count + 1; // Counter update
}   // Termination of loop

count = 1;  // Initial variable
do {  // do loop
  // Statements to be repeated
  _root["clip_" + count]._xscale = 100/count;
  count = count + 1; // Counter update
} while (count <= 1); // Condition

for(i = 1; i <= 10; i++){ // Initial variable value, condition, and update
  _root["clip_" + i]._xscale = 100/i; // Statements to be repeated
}  // Termination of loop

// Placeholder and object
for(name in _root){
  // Check the data type of the object
  if(_root[name] instanceof MovieClip){
    // Statements to be repeated
   _root[name]._xscale = 50;
  } // end if statement
} // Termination of loop

count = 1;
while(count <= 10){
     path = eval("_root.clip_" + count);
     tellTarget(path){
          play();
     }
     count++;
}

for(name in nestAnim){
     nestAnim[name].play();
}

nestAnim[*].play();

var count = 1;
while(count <= upperLimit){
   if(count > 10){
      break;
   }
   _root["clip_" + count]._visible = false;
   count++;
}

count = 1;
while(count <= 10){
  if(count == 5){
    count++;
    continue;
  }
  _root["clip_" + count]._visible = false;
  count++;
}

Adding a loop to your actions list

To create a loop, add one of the loop-type actions in the Actions panel, using the plus (+) button in the toolbar of the panel (or selecting it from the Statements

Loops in ActionScript are not appropriate for running background processes that listen for conditions to become true elsewhere in the movie. While a loop is in progress, the screen is not updated and no mouse events are captured, so most Flash actions are effectively not executable from within a loop. Loop actions are best suited to abstract operations such as string handling (for example, to check each letter of a word to see whether it contains an @ symbol) and dynamic variable assignment.

You should create loops to execute repetitive actions over time, which affect tangible objects in the movie, as repeating frames in Movie Clips. To create a permanently running process, make a Movie Clip with two keyframes. On the first frame, call the subroutine or add the statements that you want to execute; on the second frame use a gotoAndPlay(1); action to return to the first frame. Alternatively, you can use the onClipEvent(enterFrame), onEnterFrame() handler, or setInterval() function to execute repetitive actions.

Properties are characteristics (such as width and height) of movies and Movie Clips that can be retrieved and set. You can use variables to store the current value of a given property, such as:

var xPos = _root._xmouse;

which stores the current X position of the mouse pointer (relative to the Stage coordinates of the Main Timeline) in the variable xPos.

ActionScript contains a number of native programming commands known as functions. Among others, these functions include getTimer(), getVersion(), parseFloat(), parseInt(), escape(), and unescape(). It's beyond the scope of this chapter (and this book) to discuss the practical use of every new function and ActionScript element in Flash CS3. We do, however, discuss many built-in functions throughout this part of the book.

Whether they're called functions, subroutines, or methods, most programming languages provide a mechanism for programmers to create self-contained code modules that can be executed from anywhere in a program. ActionScript supports subroutines by using the ActionScript function constructor. You can create functions on any timeline, and, just like Movie Clip instances, functions have absolute or relative paths that must be used to invoke them. For example, if you have the following function on a Movie Clip named functions_mc, located on the Main Timeline:

function makeDuplicate(target, limit){
   for(var i=1; i<=limit; i++){
     _root[target].duplicateMovieClip(target + "_" + i, i);
   }
}

then to invoke it from another timeline, you would execute it as follows:

_root.functions_mc.makeDuplicate("clip",5);

Executing it creates five duplicates of the Movie Clip instance named clip, naming the duplicates clip_1, clip_2, clip_3, clip_4, and clip_5.