…rest Parameter

The rest parameter is cool little parameter type in AS3. It allows for varying sizes of parameter lists to be passed into functions. Let’s look at a quick example:

In this example, we declare function called foo, which has two defined parameters called bar and foobar, and then as the last parameter we have this thing called …rest. As you can tell, …rest is the rest parameter. The rest parameter is declared by three ellipses or dots (…) and then followed by the parameter’s name. In this case I’ve named it rest, but you could name whatever you like. For example:

What does this look like for the person who’s calling the function? Let’s take a look:

As you can see, when we call this function we pass in the two defined parameters, and then comes a big long list of parameters that we didn’t define; this is how the rest parameter works, the user can put in as many parameters as they like. It’s important to note, that the user can also pass in parameters of any type, so you’ll have to do some checking if you want the parameters to be of a certain type.

Now we’ll get onto how you can actually access these parameters passed in. When the function actually starts executing it’s statements, the rest parameter has been converted into an array. So we can access the parameters like this:

As you can see, we can perform various array methods on it, access the length property, and access the elements in the array. We could also do a for each or for loop on the array, and so on. But what if we need to pass these parameters on to another function, expecting a rest parameter (not an array) itself? That’s what we’ll discuss next.

Function.apply()

When you define a function, you are creating a Function object. The object itself has a number of handy methods. One of those methods we are going to talk about today, and that it the apply() method.

The apply method allows you to call a function, but pass in the parameters needed as an array. Let’s write some setup code:

Now what we need to do is when someone calls foo, we want to do some processing on the bar string as seen in foo(), and then pass on the processed string and all the parameters the …otherParams rest parameter to bar() and return whatever bar() returns. How do we that when, inside the actual function, otherParams is an array (meaning we can’t just go

). This is where apply() comes in:

So what we’re doing that’s different is, creating an array called applyParams; this is the array of parameters to pass to apply(). Then we are adding the processed string (bar2) to the front of the applyParams array. Finally, we are calling the apply method of the bar object (which is a Function), passing in this (this object) and the applyParams array and returning the returned value. The apply method will use the array as the list of parameters for the function and everything will work smoothly. But why do need to pass in the “this” reference? The first parameter of apply, (so far as I understand it) is what object to point to wherever “this” is referred to in the function. Therefore, be careful with that one and take into account where the function is located.

Anyway, that wraps up this post, hope you learnt a thing or two about functions. I could say more, but I’ll leave it at that. Please feel free to post your thoughts below.

TweenLite (and the Greensock Tweening Platform) is simple, powerful, fast and reliable. Greensock has many awesome classes, generously available for free, all of which are (so far as I understand) maintained by one person. You can get them at http://www.greensock.com/

I’ll just go through a few features with you now. First of all the TweenLite object has two main methods, to() and from(). With these you can change and object’s properties, from their current value to a new value at a certain rate. from() works similarly; it sets the properties of an object to what you specify, and then moves those properties back to what they were. So you can tween object’s in both directions.

Let’s experiment with to():

The first parameter is the object you want to perform a tween on. The second is the amount of time you want the tween to take. And the third is an object literal of properties you want to change. In this case these properties will be moved to the values specified. TweenLite can modify any numerical property of an object, making some really powerful stuff possible.

Next I’ll talk about a few of the special properties, they are: onStart, onComplete, ease, and delay. Here’s a definition of them:

• onStart – A function that should be called when the tween begins (when its currentTime is at 0 and changes to some other value which can happen more than once if the tween is restarted multiple times).
• onComplete – A function that should be called when the tween has finished
• ease – Use any standard easing equation to control the rate of change. For example, Elastic.easeOut. The Default is Quad.easeOut.
• delay – Amount of delay in seconds (or frames for frames-based tweens) before the tween should begin.

Let’s try and use the ease property first:

Note the extra import, we must import the easing classes to be used with the tween. You can use all the standard easing equations, and a few extras to my knowledge.

Now for the rest of those properties:

So this tween will trigger startFunction() when it starts, completeFunction() when it ends, and will wait 3 seconds before starting.

That’s just the tip of the iceberg, but the engine has great documentation, so go to http://www.greensock.com/ and check it out. The purpose of this post was not to rewrite the documentation, but to get your feet wet and show you a better way to tweening.

First go and download the class from here: http://www.nova-fusion.com/cms/FileFolder/AMFPHPConnection.zip

This zip file contains the minimized class in it’s package folders: com/novafusion/net/AMFPHPConnection.as. It also contains readable version of the class, which has documentation, comments and more whitespace; it is: AMFPHPConnectionReadable.as. If you actually want to use this class instead, rename it to AMFPHPConnection.as and place it in the proper package folders. The zip file also contains package details similar to what I’m talking about now, and instructions similar to what I’m going to be talking about below. Now let’s get onto how to use it.

Setup

To get started, import the class:

Next create a new instance, you can call the variable name whatever you like but I’ll go with connection:

When you create a new instance, you are expected to pass in one parameter, the path to your AMFPHP gateway.php file. When you create the instance the class will automatically set up a connection and a responder for your function calls. If you would like to change the gateway location at any point do this:

This will set the gateway location in the class and reconnect to that server. Access the path to the current gateway this way:

Quick Service Referencing

Quick service referencing helps a lot in speeding things up and reducing the amount of code you have to right. If you have a service you use a lot in your code, the connection class can store it for you and cut down how much you have to type to reference it. Examples of referencing strings are:

You can basically store any string in them, and reference it quickly when calling a service. You could use each of these reference strings in calls like this:

You use your references with a dollar sign and then it’s number (which is assigned to it in the order you add them to the class). As you can see this will greatly reduce what you have to write in your code.

You can add service references in two ways. The first is to add them in when constructing the class:

The second way is to add them in with a method provided:

You can add as many as you like at one time, and use the method as many times as you like. You can also remove service references like this:

It’s not recommended that you remove service references, as it might generate confusion as to the order in which to reference them afterwards (just more for you to keep track of).

Calling Services

To call a service, use this method and pass in your service and parameters (not the responder! That’s taken care of for you):

The function is called talk because of confliction with the NetConnection object’s call method. However you can still use that method, like this:

You can pass in the responder either as null (the object’s responder object will be used instead, which is what you want), use connection.responder (replace connection with your instance name), or pass in your own custom responder (note that result and fault listeners won’t work).

You can use quick service referencing in your calls like this:

Just use strings in the style shown in the quick service referencing section and all will be well.

Result and Fault Listeners/Handlers

We need to see up some listener/handler functions to respond to results and faults from AMFPHP:

Notice that instead of receiving objects they actually receive plain event objects; that’s because they’re triggered by custom event listeners. You access the last result object with connection.result (replace connection with your instance name) and the last fault with connection.fault (replace connection with your instance name). Now how do we add the listeners for these functions? Here’s how:

Just pass in the result function and the fault function and they’ll be triggered for their respective events. Now you don’t have to set either one, if you want to set the fault handler but leave the result handler as it is just leave the onResult function as null. Now be careful about these handlers, when you set them like this they become the default handlers for all calls. One way to get around this is to remove the listeners in the on result or on fault functions, using this:

You could do that, but there’s a better way to do it. Set the third parameter of setListeners() to true; this will make these listeners only last for one call, and on the next result or fault they will be removed. Here’s how:

You could also add listeners the harder way like this:

And of course to remove them you just use them same code, just change the function to removeEventListener().

Conclusion

Hope that helps! Here’s a sample application to give you some perspective on how this class lessens your code when using AMFPHP:

It is very simple to pad your number to whatever length of characters you would like.

Save this class to a folder relative to your flash document /com/frigidfish/utils/PadZero.as

Here is an example usage:

I use this little converter all the time with customized timers and counters.

If you would like a simple example of a timer, you could do something like this:

You could make custom digits with your own artwork to spice up your timer.

I’ve been working with a great as3 debugging tool called “De MonsterDebugger”. Strange name but great tool. Check it out here: http://www.demonsterdebugger.com/

Basically you just download the debugger and import the class:

then as the first line in your constructor function:

Now you just open the air application that came with the download and it will track everything that happens in your class in the interface. You can run functions from it as well. It rocks!

Anyway, my point being that as I was running it on some of my programs I noticed a significant amount of memory leakage on some of the classes. Here are a few tips to help flash along with garbage collecting your old used up objects.

One thing I like to do is to create a destroy() function at the end of my classfiles. The job of this function is to reset all variables possible in the script. I’ll explain more in a moment.

The ‘delete’ keyword:

This is a somewhat misunderstood keyword because it only works on dynamically created variables. let me explain. take the following code for example:

So I have discovered that the only way to be sure that your variables will be garbage collected and the memory will be released is to make the variables in your classes dynamic by using arrays or objects to store them.

You could do this like so:

The destroy function iterates through all objects inside of the cat object and removes them from the display list.
Next, it deletes the property itself freeing it up for garbage collection.

Keep in mind that the Cat class should also have a destroy function that cleans itself out as well!
So the function would be modified to look like this:

You can use the De MonsterDebugger to magically watch your memory performance increase dramatically by using this technique. Hope it helps!

By the way, for anyone that has read my Game Grid article, these games all use the concept, so you can see it in action.

Enjoy!

The first line is the location of the package. Generally developers will save their classes under a hierarchy that is their website name backwards.. in my case, my game projects are under my business name frigidfish.com so all of my classes are stored under com.frigidfish.

To clarify, lets start by opening flash and selecting File|New, Flash File (Actionscript 3) and click OK. Save the new file to your hard drive somewhere in a folder called “Monkey”.

Now, navigate to the Monkey folder and create a subfolder called “com”. Navigate to the com folder and create another subfolder called “frigidfish”.

Go back to Flash and click File|New. Select “Actionscript File” and choose OK.
You will get a blank page that you can enter code into. Paste the code from above into the blank page and save it in the newly created Monkey/com/frigidfish as Monkey.as

Now go back to the flash file we created first and open the “actions” panel by hitting the F9 key on a PC and on a mac I’m not sure, just click Window|Actions.

In the Actions panel you can start typing in code. The first thing you’ll want to do is import the class that we saved so that you can use it. Enter the following line:

Now that the class is available, we can create a new variable instance of it. You can think of a class file as a ‘prototype’. In this case it is a prototype of a Monkey… The cool thing about a class file is that you can make as many instances of it as you’d like.

Ok, so now enter the following line:

This line creates an instance of Monkey called silly. The Monkey class does not accept any arguments so we just leave the () empty. All classes have what is called a ‘constructor’ function. This is a public function that bears the same name as the class. Anything you put in the constructor function will be executed immediately when the class is instantiated. If the constructor does nothing, it is perfectly legal to leave it out of the class completely, but it is considered bad practice to do so.

In our case, the Monkey class constructor only has one line of code which just traces ‘New Monkey Instance Created’.

Go ahead and test the movie.

If you look in the output panel you will see that not much happens except that you receive the message about the new instance being created. Go ahead and close the test window.

add this line of code next:

If you test the movie now, you will see that in addition to the new instance message, a new line appears that says ‘false’. The default jumping state of the monkey is false.

go ahead and add the next couple of lines:

If you test the movie now, you should see the following:

New Monkey Instance Created
false
Monkey is jumping around!
true

Let’s go through this.

First we created a new instance of Monkey called silly.
Next we asked flash to display the jumping state of silly, which returned false.
Next we set silly’s jumping property to true, and he started jumping.
Last we ask flash to display the current jumping state of silly, which returned true.

So you should be able to see how to get started using classes with Actionscript 3. I also used a couple of getter and setter functions in the class. I will write an tutorial on this but for now a brief overview:

In Actionscript, you can set or get properties using functions. To the person setting the property, they are none the wiser that they are actually using a function.

In our example we simply set the monkey jumping with the statement:

silly.jumping = true;

in your class, if you create a function using the ‘set’ keyword, the function name will be treated as if it were a property. Likewise, the ‘get’ keyword can be used if a developer would like to retrieve the current value or state of a classes ‘property’.

It is important to note that the value passed to the setter function must be of the same data type that is returned from the getter function. Anyhow, I am getting off track but it’s all good information.

Below I have attached a link to the files associated with this tutorial.

Hope you find it useful!

monkey

One good thing about the Sprite class is that it already extends the EventDispatcher class, so if you are working from your document class, or your class extends Sprite/Movieclip, you can use this anywhere in your class:

Let’s say for example you have the following class:

Now create an instance from your timeline:

next:

Ok, so this really doesn’t do anything useful, but you can see how you could use this idea to broadcast events from your objects. This is by no means comprehensive, but I have noticed that this simple concept has eluded a lot of people. Later I will write a more robust tutorial showing how to extend the EventDispatcher class and do some cool stuff.

Here is the class, and then an explanation:

Example usage:

Ok, so this is a very simple class that can be built upon to do a lot of things. For example you could add a dynamic text field to your display object, and use the iterator in grid.as to add numbers to each cell.

You could use this as a starting point for a match type game or an array of other puzzle ideas. The point of this is just to help you understand how the grid is generated.

Let’s quickly go through the grid class:

The first thing we do is create 4 variables (lines 8-11).

rows and cols are passed to the constructor along with the class/display object that you want to instantiate and a spacer number. Note that in this class it is assumed that whatever you pass it as your display class must be displayable.

For this example, I just made a quick movieclip and called it Token, and selected ‘export for actionscript’ in it’s properties.

Next is the constructor. As I said before, this requires 4 parameters:

your library item or class to display, rows (how many rows do you want) cols (how many columns do you want), space in pixels between display objects

the populateCells function does the meat of the work.

we create an iterator and start it at 0.
next we loop through each column.
for each column we add all of the rows:
1. create a new instance of the supplied display object and add it to the cell array
2. set the y position of the display object to it’s height x the number of the current row, + spacer
3. set the x position of the display object to it’s width x the number of the current column + spacer
4. Since this class extends Sprite, it is instantiated as a Sprite so we call just add the cell to it using the addChild() method
5. add 1 to the iterator and continue the loop.

notice that a key to making the spacer work properly is multiplying it by the row or the column. If you were to just ‘add’ spacer without multiplying by the row/col you would not achieve the desired result.

Next we execute the plotCells method. This creates an extra way to find the cell that you want. It sets up a 2 dimensional array and adds the cells to it so that you can access them by plotting coordinates.

first it creates an iterator and sets it to 0.
next we look through the length of the cols variable
now we create a new array and assign it to the plot array at the current column
for each number in cols, we iterate through all rows.
finally we assign each cell from our cell array to the proper plot coordinates.
add 1 to the iterator and process the next column.

So basically:
plot[0][0] = cell[0]
plot[0][1] = cell[1]
plot[0][1] = cell[2]
…
…
and so on. if you made a 5×5 grid, column 2, row 0 would be:
plot[2][0] = cell[10]

well, that’s it!
Hope you find this useful.

usage:

This will certainly work to load an as2 swf into your as3 project,
but keep in mind that you will not be able to access methods and properties of your as2 swf.
I will be updating this class or adding another to make this possible. In the meantime,
Grant Skinner has created this to make the job a snap!