Archive for the ‘Flash’ Category

Particle Playground

I finally released my finished particle simulation extension for flash7+. You can purchase it from flashden here for a mere 10 bones.

No Comments


Featured item on flashden (with thoughts on wallop)

A simple little extension I created for flashden is currently a featured item. This site rocks. It allows me to package up little utilities i created for other jobs and sell them for a few bucks without the hassle of setting up my own on-line store.

This got me thinking about microsofts new myspace competitor wallop. A few people have pointed out that you can make quick cash from creating little widgets for the site. But i wonder if this is really such a great idea. The fact that you need to invest the development time for such items, coupled with the rather large API you need to learn in order to implement widgets for the site, seems to suggest that you need to ship a lot of units before you see any return on the time you’ve invested. And i’m not event sure how many people are actually using wallop.
Compare this to flashden where all i have to do is package things i’ve already developed, and i think it’s easy to see that there’s better ways to spend your time.

2 Comments


Actionscript: The rules #2 – Observer pattern for all events

All classes that generate events should do so via the observer pattern.

This one might prove a little more contravertial than the last, but i’m going to stick my neck out and say that all classes should use the observer pattern for events, rather than myEvent=function() callbacks, or object listeners.

For those who don’t want to read up about the observer pattern check out the EventDispatcher class which is basically an implementation of this. or better still grant skinners GDispatcher which has a few extra tricks up its sleeve. The first benefit of this method is that you can have multiple objects listening to the same event. This is all covered in the chapter on the observer pattern in Colin Moocks Essential ActionScript 2. If you want to start using these classes i suggest you read the tutorials on EventDispatcher and Delegate over at actionscript.org.

I also tend to use Dynamic flash’s Delegate class rather than macromedias own for scoping the listener object, as this also has a few added extras, such as passing the delegate itself to a listening function, as well as the event object, which makes removal of anonymous delegates an easy task.

This may sound like overkill for a lot of simple class structures, and you will have to remember to remove your event listeners, but it does mean consistency. If you’re using EventDispatcher in one class, and myEvent=function() style callbacks in another, then it’s easier to make mistakes. And harder to pick up code that you havent looked at in a while, because you have to figure out which method you used.

When using EventDispatcher it’s always useful to include static constant variable strings (try saying that 10 times quickly) for all the events a class will dispatch. This not only lets you keep track of which events a class broadcasts easily, but also provides compile time checking to make sure you are subscribing to events that actually exist. For example:

import com.gskinner.event.GDispatcher
class com.lookmum.Broadcaster{
public static var MYEVENT:String = 'myEvent'
public var addEventListener:Function
public var removeEventListener:Function
public var dispatchEvent:Function
public function Broadcaster(){
GDispatcher.initialize(this)
}
public function myFunction(){
this.dispatchEvent({type:MYEVENT,target:this})
}
}

and…

import com.lookmum.Broadcaster
import com.dynamicflash.utils.Delegate
class com.lookmum.Observer{
private var broadcaster:Broadcaster
public function Observer(){
this.broadcaster = new Broadcaster
this.broadcaster.addEventListener(Broadcaster.MYEVENT, Delegate.create(this, this.eventHandler))
}
public function myFunction(){
this.broadcaster.myFunction()
}
private function eventHandler(){
trace('event handled')
}
}

Two added benefits are that this makes it easy to document events because you can attach javadoc comments to the string constants and they stand out from other class members so events are easy to find rather than function callbacks which apart from their names look just like empty functions.

This is all very similar to the way events are used in AS3 and so if you can get used to using this methodology now, then the transition should be that much easier. In fact another useful methodology that AS3 uses is the use of a proper Event class, as the event object rather than using a standard object, which makes it easier to keep track of what properties your event object will hold.

1 Comment


Actionscript: The rules #1 – Refactor over reuse

Lately i’ve been trying to formalise a lot of the processes i use for coding actionscript so I started to write them down. I then was going to post them to my blog, however this quickly grew into a very large post, so i’ve decided to break them up into a series. Also this should make discussion of each of these points easier, and allow me to add more as i think of them (also it means i shouldnt be stuck for content for a while ;) ).

This isn’t a definitive list of best practices, and i’m sure people will disagree with me on some of the points but i think it helps to write this stuff down and discuss it. And with the introduction over it’s time to dive into the first rule.

“When creating classes don’t create them to be reused. Reusability should come from refactoring old classes”

This is an important but tricky skill to master, the ability to go back to some code you’ve already written and rework it. It can be a major headache the first time you want to reuse something, but if you can generalise a little more the code you’re useing every time you look at it, eventually you’ll end up with a solid code base. This goes hand in hand with not writing for reusability as raised by qlod, but rather letting reusablility come out of refactoring by itself.

Heres a simple example. Lets say we write a class for a specific task:

class myClass{
private var a:Number = 1
public function doSomethingWithNumbers():String{
//multiply by 2
a*=2.toString()
//then return the new value
return a
}
}

Later we want another class that does something similar. We could subclass our original like so:

class mySubClass extends myClass{
public function doSomethingWithNumbers():String{
//multiply by 2
a*=2
//then add 1
a+=1
//then return the new value
return a.toString()
}
}

However another approach is to move the common functionality to a super class, then have both classes extend this. First We create the super class:

class mySuperClass{
private var a:Number = 1
public function doSomethingWithNumbers():String{
return doSomethingSpecificWithNumbers().toString()
}
public function doSomethingSpecificWithNumbers():Number{
return a
}
}

Then we create our two sub classes:

class myFirstSubClass{
public function doSomethingSpecificWithNumbers():Number{
//multiply by 2
a*=2
//then return the new value
return a
}
}

And:

class mySecondSubClass{
public function doSomethingSpecificWithNumbers():Number{
//multiply by 2
a*=2
//then add 1
a+=1
//then return the new value
return a
}
}

So we now have two sub classes that do exactly what we wanted, and we also have a more generalised superclass, that should we want to create a third class in the future, is easy to extend for whatever we need it for.

I realise this may be an overly simplified example, but hopefully you’ll see the benefits of what i’m getting at here. Most importantly we’ve acheived reuse without having to waste time guessing what functionality we will need in the future while writing the first class. This means we’ve avoided writing any code that we don’t actually use, and anything that helps us to do less work can only be a good thing right?

2 Comments


Extending Actionscript implicit getter & setters.

Here’s something i only just noticed. If you overwrite either a getter or setter in a subclass of a class with both, but don’t provide a hook for the other one, then the property will become either read or write only. For example:

MyClass{
var _i:Number
public function get i ():Number{
return _i
}
public function set i(num:Number):Void{
this._i=num
}
}

Will produce the following expected behaviour:

var myClass = new MyClass()
myClass.i=10
trace(myClass.i) //traces 10

In the subclass we overwrite the setter with some new behaviour:

mySubClass extends MyClass{
public function set i(num:Number):Void{
this._i=num*2
}
}

Will produce the following not so expected behaviour:

var myClass = new MySubClass()
myClass.i=10
trace(myClass.i) //traces undefined

Which means the property i has become write only. To keep the property read and write you need to copy the getter into the sub class:

mySubClass extends MyClass{
public function get i ():Number{
return _i
}
public function set i(num:Number):Void{
this._i=num*2
}
}

And you then get the following:

var myClass = new MyClass()
myClass.i=10
trace(myClass.i) //traces 20

I know it makes a kind of sense, but it does mean you have to be careful you’re not changing the signature of your subclasses, as they dont behave exactly as you might expect.

3 Comments


Certified flash certification certificate

It’s been a while coming but i finally got my certification pack today. I suppose it took a while to get all the certificates reprinted after the Macromedia/Adobe merger. It is very shiny though so i’ll let them off.

certificate

On a related note, one thing i forgot to mention in my previous post on the certification was that during the exam, a lot of questions were about code and techniques that beginners to flash would use. This makes a lot of sense, because as an experienced developer you’re supposed to be able to look at code from anybody and figure out whats going on. Not just completely datatyped, and neatly packaged stuff.

Keep that in mind if your coming up to the exam to not only revise the more advanced areas of the program, but also try to remember the techniques you used when you first started with flash.

No Comments


Flash 8 example for Flashamp 3

I recently produced a little flash 8 example for marmalade media, to show off some of the features of the latest release of flashamp. You can view it here, under “FlashAmp examples with Flash source code”

I’ll be releasing the source code via the examples pages in the not too distant future, but for now just enjoy the show.

flashamp example

5 Comments


Flash decimal to fraction utility class

I recently had to do some work where i had to return a fraction from a decimal number. I did some hunting around on the net and found some great information at layer51 and ericlin. From the info i got there i made a utility class that handles decimal to fraction conversion. You can download the source here, or just copy and paste from below.

The documentation is in the code comments, but if there’s demand for it, i’ll create a bit of html documentation. The class itself is pretty straightforward, so hopefully you should see how to use it. Any useful additions to this class would be appreciated.

Enjoy!

/**
* Utility class for getting fractions from decimals as an array of values or a string
*
* @author Phil Douglas
* @version 1.0
*
* website : http://www.lookmumimontheinternet.com
* email : phil@lookmumimontheinternet.com
*
* based on information from:
*
* http://proto.layer51.com/d.aspx?f=289
* http://ericlin2.tripod.com/mis/ration.html
*
*/
class com.lookmum.util.Fraction
{
// class variable, limits the amount of iterations in finding the fraction to prevent infinite loops
public static var iterationLimit : Number = 10000
private static var it : Number = 0
// class variable, the accuracy to which to find the fraction (used for infinately recurring decimals e.g. 1/3)
public static var accuracy : Number = 0.00001
private function Fraction ()
{
//class is static utility class so no need to instantiate
}
private static function resetIt () : Void
{
it = 0
}
private static function addIt () : Boolean
{
it ++
if (it == iterationLimit)
{
trace ('error : too many iterations')
return true
}
}
/**
* Static class method, returns a fraction from a decimal as a string
*
* @usage com.lookmum.util.Fraction.getFractionString(0.5) // returns "1/2"
* com.lookmum.util.Fraction.getFractionString(1.5) // returns "1 1/2"
* com.lookmum.util.Fraction.getFractionString(1) // returns "1"
* @param num the decimal to find the corresponding fraction for
*
* @return a string of the fraction
*
*/
public static function getFractionString (num : Number) : String
{
var fracString : String
var fracArray : Array = getFraction (num)
switch (fracArray.length)
{
case 1 :
fracString = num.toString ()
break
case 2 :
fracString = fracArray [0].toString () + '/' + fracArray [1].toString ()
break
case 3 :
fracString = fracArray [0].toString () + ' ' + fracArray [1].toString () + '/' + fracArray [2].toString ()
break
}
return fracString
}
/**
* Static class method, returns a fraction from a decimal as an array
*
* @usage com.lookmum.util.Fraction.getFraction(0.5) // returns [1,2]
* com.lookmum.util.Fraction.getFraction(1.5) // returns [1,1,2]
* com.lookmum.util.Fraction.getFraction(1) // returns [1]
*
* @param num the decimal to find the corresponding fraction for
*
* @return an array of the fraction of length 1-3
*
*/
public static function getFraction (num : Number) : Array
{
var fracArray : Array = new Array ()
var hasWhole : Boolean = false
if (num >= 1)
{
hasWhole = true
fracArray.push (Math.floor (num))
}
if (num - Math.floor (num) == 0)
{
return fracArray
}
if (hasWhole)
{
num = num - Math.floor (num)
}
var a : Number = num - int (num);
var p : Number = 0;
var q : Number = a;
resetIt ()
while (Math.abs (q - Math.round (q)) > accuracy)
{
addIt ()
p ++;
q = p / a;
}
fracArray.push (Math.round (q * num))
fracArray.push (Math.round (q))
return fracArray
}
}

4 Comments


certifiedFlashDevelopers += me

It hasn’t quite sunk in totally, but this morning I took and passed the certified flash developer exam. It was quite an intense experience, but I came out of it with a spring in my step and a respectable 83%.

This has been a goal of mine for quite a while now, and it feels great to have finally accomplished this. The challenge of the certification has certainly helped me to broaden my flash skills into areas that I wouldn’t normally have dived head first into, and this in turn means I can introduce these new elements to the projects I work on.

I started to see the benefit of this exam, long before I actually took the thing. Anything that forces you to learn more about different areas of your field can only be good for your day to day work, and the sense of satisfaction is the icing on the cake.

Apologies if this is a bit of a gushing blog post, but I’m totally stoked at the moment (all be it a bit frazzled)

Anyway, lets move on to the gory details. The testing centre itself was a bizarre experience, first showing a couple of forms of ID before being led through to a room where I had to divulge myself of all my possessions, including my watch. Then on to the control room full of video monitoring equipment, with a big glass window looking through to the test rooms where I was given a short brief on procedures. Then led into the test room, and installed into my booth. I half expected to be sterilised and de-loused!

I can’t go into details about the exam itself, due to the NDA you have to agree to, but lets just say it’s definitely a tough one, like the official study guide says, “tough but fair”. It really was a collection of questions on nearly every area of flash, so you really need to know your onions to get through it.

A couple of resources to look at if you’re going to take the exam would be, firstly the official study guide. This is a great little book that I would recommend even to people who aren’t going to take the exam. It gives an overview of the whole of flash, and can really help to point out your weak spots, plus where you need to look to improve these areas. Secondly, get to know your Essential ActionScript 2.0 by Colin Mook. Better flashers than myself have pretty much covered everything about how great this book is, so let’s just say I concur. Lastly there’s a great mini preparation guide, and example exam by Tom Kitta, that helped a lot in the later stages of my training.

Next up, I’ll be continuing with my Korean language course, and hopefully learning to scuba dive in the near future. At least until they announce the Flash 8 exam! Ever feel like your head is going to explode? :P

7 Comments


My sordid Actionscript past

Over the last few days, I’ve been working on some changes to some really old projects here at Massmedia. One of which was the first thing i did when I started here, and the other is from nearly two years before that, full of all the tricks and hacks that flash required at the time. While I sat there looking through all this old code, I couldn’t help thinking what I would change if I had to redo the projects today.

The fact is that almost every Flash developer i know, or indeed most professionals in any related fields, are seldom happy with the work they did a long time ago, and it’s almost with a sense of shame that we pick through our first old projects. I suspect Colin Mook is spinning in his multiuser application grave as I navigate throught the spaghetti i used to write, while on my journey from someone who used flash purely for broadcast TV animations.

But surely this is a good thing. The day i pick up a project I did years ago and think “That’s great, I wish I knew how to do that now!” is the day I truely have to worry. Maybe it’s just me, and all of your first projects were a strictly typed synergie of design patterns and dynamically loading class libraries. I for one enjoyed reminising with a colleague about the hacks we used to use while flash was developing, and ourselves along with it.

I will always fondly remember the heady days of:

<em>if ( _root.getBytesLoaded() == _root.getBytesTotal() ){
gotoAndPlay(3)
}else{
gotoAndPlay(1)
}</em>

Oh onEnterFrame, how you spoiled all my fun :) .

Anyone else got Actionscript skeletons in thier closet they’d like to confess to?

1 Comment



  • SetPageWidth