Starting with the same two files as we have used previously, in the following example you can see a document root that listens for a Signal and invokes a method of our BasicObject. This time the Signal will be carrying data that we can work with:

package  
{
	import flash.display.Sprite;
 
	/**
	 * This is the second of three Signals tutorials.
	 * In this example we will be looking at the basic usage
	 * of a Signal, how it's dispatched and how we work with
	 * the Signal when it's been received by the Listener.
	 * 
	 * @author Anton Mills
	 * @version 05/09/2010
	 */
	public class Main extends Sprite 
	{
		// an object
		private var basicObject:BasicObject;
 
 
		/**
		 * constructor
		 */
		public function Main()
		{
			// create a BasicObject
			basicObject = new BasicObject();
 
			// add a listener that will fire repeadly
			basicObject.basicSignal.add(basicSignalListener);
 
			// test the dispatch functionality
			basicObject.basicAction();
			basicObject.basicAction();
			basicObject.basicAction();
			basicObject.basicAction();
		}
 
 
		/**
		 * a listener for the BasicObjects basicSignal
		 * Signal events
		 */
		private function basicSignalListener(_message:String, _count:uint, _basicObject:BasicObject):void 
		{
			trace(_message, _count, _basicObject);
		}
 
 
 
	}
}

So this isn’t a whole lot different to what we had before, the most notable difference is the basicSignalListener now has three parameters a String _message, an unsigned integer called _count and lastly a reference to a BasicObject instance called _basicObject. All we simply do is trace out the three parameters. There’s a few small changes to our BasicObject class here:

package  
{
	import org.osflash.signals.Signal;
 
	/**
	 * This BasicObject is just that, it's here to 
	 * simply dispatch a few Signals that we'll listen
	 * for in Main. It's also worth noting that 
	 * BasicObject doesn't need to extend EventDispatcher,
	 * your objects can remain as light as possible.
	 * 
	 * @author Anton Mills
	 * @version 05/09/2010
	 */
	public class BasicObject 
	{
		// keep the signal public so you attach listeners to it externally
		public var basicSignal:Signal;
 
		// some local variables
		private var message:String;
		private var dispatchCount:uint;
 
 
		/**
		 * constructor
		 */
		public function BasicObject()
		{
			// set up the variables
			message = "We have Signal";
			dispatchCount = 0;
 
			// set up the signals
			basicSignal = new Signal(String, uint);
		}
 
 
		/**
		 * Think of this as a method that performs
		 * some sort of functionality. Once the 
		 * functionality is complete we will dispatch
		 * our Signal.
		 */
		public function basicAction():void 
		{
			dispatchCount++;
 
			// then dispatch
			basicSignal.dispatch(message, dispatchCount);
		}
	}
}

You’ll notice theres a few changes to this class, we’ve added two properties, a String called message and an unsigned integer called dispatchCount. They’re instantiated in the constructor and this time you’ll notice when we instantiate the Signal in the constructor we define the data that the Signal will carry. In this case we’ve told it the first parameter will be a String and the second parameter in an unsigned integer, adding data types to the Signal that don’t match what is expected will throw errors making it easy to locate problems.

Finally the basicAction method has been changed slightly, now each time it is invoked it increments dispatchCount and dspatches the Signal with the local properties message, dispatchCount and a reference to itself using ‘this’ to be traced out by our Listener.

Hopefully you can see at this stage just how quick and simple Signals are but also how beneficial they are in wiring your application together. Moving forward you’ll probably want to begin looking at DeluxeSignals as they allow a little more flexibility when registering Listeners as you can work with priorities using: addWithPriority(listener:Function, priority:int = 0). Next up I’ll probably be looking at how we use Signals with native events, such as MouseEvent.CLICK to make a usable application (albeit simple of course!).

anton.

For those who havent come across Signals yet, it’s a set of messaging tools created by robertpenner for wiring your application together, drastically cutting the amount of custom Events and the inherent boilerplate code. It’s one of those things I’ve heard about but never really looked in to it so it was good to finally have play around with it and after just 10 minutes of using it you know it’s instantly going to be really beneficial to your Flash projects, Peter said it’s the best thing since sliced bread…. you know what, he’s bloody right!

Over the next few post’s I’m going to put together a few examples of how you can use signals, this first post will show basic Signal usage and interaction with payloads.

So first up your going to want to grab the latest version of AS3 Signals from their git repository. It’s swc format so make sure you setup the linkages in your IDE of choice.

Once that’s done your ready to roll, starting with it’s most basic usage the following shows a document root that instantiates a basic object, attaches a listener to the object Signal and invokes a method on the basic Object.

package  
{
	import flash.display.Sprite;
 
	/**
	 * This is the first of three Signals tutorials.
	 * In this example we will be looking at the basic usage
	 * of a Signal, how it's dispatched and how we work with
	 * the Signal when it's been received by the Listener.
	 * 
	 * @author Anton Mills
	 * @version 05/09/2010
	 */
	public class Main extends Sprite 
	{
		// an object
		private var basicObject:BasicObject;
 
 
		/**
		 * constructor
		 */
		public function Main()
		{
			// create a BasicObject and add the listener
			basicObject = new BasicObject();
			basicObject.basicSignal.add(basicSignalListener);
 
			// test the dispatch functionality
			basicObject.basicAction();
		}
 
 
		/**
		 * a listener for the BasicObjects basicSignal
		 * Signal events
		 */
		private function basicSignalListener():void 
		{
			trace("Main* basicSignal received");
		}
	}
}

What’s important to note at this point is that we attach the listener to the public Signal of the object, we do not (in this case atleast as you’ll see in later examples we can) attach the listener to the BasicObject itself.

It’s also worth looking at the event handler itself, you’ll notice I haven’t added an event type, as this Signal is not returning anything we can leave this empty but in the next example you’ll see how easy it is to return data payloads with the Signal and that the data is strongly typed, making debugging a whole lot easier!

So the BasicObject’s class currently looks something like this:

package  
{
	import org.osflash.signals.Signal;
 
	/**
	 * This BasicObject is just that, it's here to 
	 * simply dispatch a few Signals that we'll listen
	 * for in Main. It's also worth noting that 
	 * BasicObject doesn't need to extend EventDispatcher,
	 * your objects can remain as light as possible.
	 * 
	 * @author Anton Mills
	 * @version 05/09/2010
	 */
	public class BasicObject 
	{
		// keep the signal public so you attach listeners to it externally
		public var basicSignal:Signal;
 
 
		/**
		 * constructor
		 */
		public function BasicObject()
		{
			// set up the signals
			basicSignal = new Signal();
		}
 
 
		/**
		 * Think of this as a method that performs
		 * some sort of functionality. Once the 
		 * functionality is complete we will dispatch
		 * our Signal.
		 */
		public function basicAction():void 
		{
			// perform some pseudo task...
			for (var i:int = 0; i < 100; i++)
			{
				// nothing doing
			}
 
			// then dispatch
			basicSignal.dispatch();
		}
	}
}

With a few small changes to our document root class we can demonstrate how easy it is to add or remove Listeners to the Signal. We also have a fantastic removeAll() function to remove all Listeners:

package  
{
	import flash.display.Sprite;
 
	/**
	 * This is the first of three Signals tutorials.
	 * In this example we will be looking at the basic usage
	 * of a Signal, how it's dispatched and how we work with
	 * the Signal when it's been received by the Listener.
	 * 
	 * @author Anton Mills
	 * @version 05/09/2010
	 */
	public class Main extends Sprite 
	{
		// an object
		private var basicObject:BasicObject;
 
 
		/**
		 * constructor
		 */
		public function Main()
		{
			// create a BasicObject
			basicObject = new BasicObject();
 
			// add a listener that will fire repeadly
			basicObject.basicSignal.add(basicSignalListener);
 
			// add a listener that will only ever fire once
			basicObject.basicSignal.addOnce(basicSignalListenerOnce);
 
			// test the dispatch functionality
			basicObject.basicAction();
                        basicObject.basicAction();
                        basicObject.basicAction();
 
			// remove a listener
			basicObject.basicSignal.remove(basicSignalListener);
 
			// remove all listeners
			basicObject.basicSignal.removeAll();
		}
 
 
		/**
		 * a listener for the BasicObjects basicSignal
		 * Signal event that will only be fired once
		 */
		private function basicSignalListenerOnce():void 
		{
			trace("Main* basicSignal received, firing once");
		}
 
 
		/**
		 * a listener for the BasicObjects basicSignal
		 * Signal events
		 */
		private function basicSignalListener():void 
		{
			trace("Main* basicSignal received");
		}
 
 
 
	}
}

To summarise up to this point, we simply add a Signal for the event we want to dispatch, add listeners to the Signal object (in our case basicView.basicSignal) externally which catch the dispatched Signal. There's no constants for Event names, there's no imports, just listen and dispatch. Great stuff!

In the next post I'm going to be building on this example with transmitting data payloads with Signals.

anton.

It’s a pure Objective-C iOS game framework. It’s built upon OpenGL for it’s rendering and OpenAL for the sound processing so it’s very fast rendering and has very rich multimedia support. The aspect that attracted me was it has been styled on ActionScript 3! I’ve been using it over the last two weeks and well…. I’m sold!

I’ve never cared much for Cocos2D. I’m not denying it’s a great framework and it’s proven itself with hundreds of games. Out of the box Cocos2D iPhone even packs many more features such as physics support with Box2D and Chipmunk, a Tile Engine and even a Particle Designer, there’s a whole lot of work gone in to Cocos2D. For me using Cocos2D always felt awkward, I didn’t like the naming conventions used, things didn’t always seem logical, it’s hard to put my finger on it but I never enjoyed using it and I ended up not diving headlong in to iPhone game development. Then I stumbled (not literaly…) upon Sparrow framework and while being a little reluctant at first I began building some simple tests for game mechanics and I love it! The syntax is what I expect, it reminds me of Flash / ActionScript 3. For example take a look at this example of an image:

// init of Class
-(id)init
{
     if (self = [super init])
     {
          // add a Background image to the splash scree
          SPImage *bg = [SPImage imageWithContentsOfFile:@"Splash.png"];
          [self.stage addChild:bg];
     }
}

Or how about this tweening example:

- (void)performTween
{
     // animates the playButton's alpha over 1.5 seconds
     SPTween *playTween = [SPTween tweenWithTarget:playButton time:1.5f transition:SP_TRANSITION_EASE_IN];
     playTween.delay = 2.5f;
     [playTween animateProperty:@"alpha" targetValue:1.0f];
     [self.stage.juggler addObject:playTween];
}

Heck Sparrow even has it’s own EnterFrame to save you the hassle of setting up a CADisplayLink or NSTimers for your game loops:

- (void)someMethod
{
     // add the EnterFrame event
     [self addEventListener:@selector(onEnterFrame:) atObject:self forType:SP_EVENT_TYPE_ENTER_FRAME];
}
 
- (void)onEnterFrame:(SPEnterFrameEvent *)event
{
     // Do something every frame
     NSLog(@"Hello Sparrow!");
}

Sparrow does need some core features though, animated SPImage using Atlas Sprites would be good, I’m using my own concoction at the moment, it aint pretty! some on screen FPS etc but nothing major. In short, it’s a great framework, very young and streamlined (which is a GOOD thing!) and you should definitely give it a shot for your next project, if you love ActionScript it’s a fair bet you’ll take to Sparrow!

anton.

The voting is going to be very tough with some fantastic entries such as the Perrier Experience and the Bacardi Talk To The Hand campaigns, viral campaigns such as the hilarious Old Spice adverts and the UK’s best agencies going head to head. The awards are split in to 16 distinct categories:

…phew!

So get yourself over to the .net Awards 2010 website (http://www.thenetawards.com) and have a look at the fantastic entries yourself!

PS excuse my cheesy mug shot in the judges page…

.anton

Here’s a quick snap of the group!

1. Grab yourself the 3D Studio Max version of the OpenCOLLADA plugin, you can find it in their download pages. Note that it comes in 32bit and x64 flavours.

2. Once it’s downloaded, go ahead and install it the same way you would normally install software in Windows.

3. Once installed, boot up 3D Studio Max and create your 3D Model.

4. Once you have it completed, choose File > Export Selected.

5. The Export Window will appear, give it a filename and make sure to choose the new OpenCOLLADA filetype, press Save!

6. In this new Window that appears, make sure Triangulate, Copy Images and Use Relative Paths are all checked and press Export.

7. Now your file has been exported, you will have the .dae OpenCOLLADA file and an images folder, hop over to your Papervision setup, drop these in to your project structure and use the following code (assuming your using a basicView) to get your Collada 3D Model up and running.

public class Main extends MovieClip
{
	// globals
	protected var colladaModel:Collada;
	protected var basicView:BasicView;
 
	/**
	 * constructor
	 */
	public function Main()
	{
		basicView = new BasicView(550, 400, true, false, CameraType.TARGET);
		basicView.camera.y += 150;
		basicView.camera.z = 220;
		stage.addChild(basicView);
 
		initColladaModel();
	}
 
	/**
	 * method loads the truck.dae COLLADA file.
	 */
	protected function initColladaModel():void
	{
		colladaModel = new Collada("assets/truck.DAE", null, 0.01, false);
		basicView.scene.addChild(colladaModel);
	}
}

Should give you something like this:

If needed I have put together a sample project with the 3D Model, all textures and a sample Flash Papervision project (using BasicView) you can use to test everything with, it can be downloaded from here.

anton.

Some of you may already know the news but I have been a casualty of the financial crunch (boo!) and unfortunately made redundant from my post at the lovely Cube Interactive.

That’s about it for the bad news, it’s a bit of a shame but it has given my partner Jen and I a lot to think about; our future, what we want to achieve with our lives and ultimitely what is right for us. For a long time we’ve been throwing the idea of emigrating to Australia around and we’ve finally the perfect opportunity! Having attended the two day Australian Expo put on by WorkingIn in Hammersmith on the 17th and 18th July, we then purchased all of our eligibility tests and Journey To Work services to make sure it’s as smooth a transition as possible. We’ve finally had the results back and we’re totally eligible and we’re in the process of setting up the permanent residency Visa (subclass 175) which can take up to 3 years.

So while that is slowly ticking away I’m searching for a digital agency in Australia (preferably Sydney or Melbourne) that are either actively searching for a Interactive Developer (Flash/AS3/AS2, iPhone/Android) or if you think I could fit in to a team your building, definitely drop me an email at hello-at-antonmills-dot-com and we can have a chat about the possibilities as I can be onshore and working within 6-8 weeks. I can’t wait!

anton.

Quick update, I’ve just completed a new iPad development tutorial on behalf of Computer Arts Magazine!
Recently I’ve been using the fantastic Appcelerator Titanium (http://www.appcelerator.com/) to create some of my mobile applications. While Titanium isn’t really aimed at gaming per se it’s more than capable of moving objects around the screen and offering alert dialog boxes etc so I put together a small three page introduction to the tool and how to develop a simple drag and drop based game for the iPad. The beauty of Titanium is that your able to port your applications to the different platforms (Android, Desktop and Blackberry (soon!)) with a few clicks if your not using any specific platforms API so you could take this tutorial and port it to Android in a few minutes! Great Stuff.

Also I’ve just found a link to the Flickr and Flash/ActionScript 3 tutorial I did for them a few months ago here might be worth a butchers if your new to using API’s.

anton.

The particular part I like is the queueing system using TimelineLite, it’s so simple to get up and running but has a wealth of features to create incredibly complex queues of tweens (for more info check: http://blog.greensock.com/timelinelite):

1
2
3
4
5
6
7
8
9
10
11
12

// create a tween queue
private var tweenQueue:TimelineLite = new TimelineLite({onComplete:queueComplete});
private function queueComplete():void
{
     trace("queue complete");
}
 
// populate it with tweens
for(var i:int = 0; i < 10; i++)
{
    tweenQueue.append(new TweenLite(desiredMC, 1, {x:i*50, y:100}));
}

anton.