Johnny Chung Lee is my nerd hero!

I worry a bit this will cause the animations to look too real – while watching these videos I was wincing at each punch and I felt sorry when the storm troopers fell to their deaths.

Thanks to Jason S. for the links!

FlexBuilder may have its ups and downs but it still remains my pick for best AS3/MXML editor on the market (with TextMate not far behind). Part of the beauty of FlexBuilder is that it’s built on the Eclipse SDK, one of the most versatile and powerful IDEs available, which is not only free and open source, but boasts a wealth of third party plug-ins for every kind of (mostly Java) development. This article will take a look at some must-have plug-ins for doing Flex development as well as some tips for tricking out your development process.

As with all of our entries, your feedback, suggestions, corrections and additions are all more than welcome.

(more…)

AIR public beta is out.

and while you’re at it…

Flash Lite 3

New Flash Player

and BlazeDS, whatever that is. (Hint: despite the name, this is not Flash CS3 for Gameboy)

There are only two ways to create a weak reference in AS3. The first is with the IEventDispatcher.dispatchEvent() method which allows you to create a weak link between the dispatcher and the listener. To quote the AS3 Bible:

ActionScript 3.0 introduces the concept of weak and strong memory references. Normally, an object will be garbage collected if there are no references to the object. That is, when no objects are using a variable, it gets thrown out. Weak references allow you to reference an object but the object will still be eligible for garbage collection unless another object holds a strong reference to the object. By setting the [eventDispatch() method’s] useWeakReference flag to true, you will create a weak link between the event broadcaster and the event listener. That way, if an event listener is deleted while still listening to the event broadcaster, the weak reference will allow it to be garbage collected. This helps to prevent memory leaks.

The other way is with the objects used as keys in a Dictionary object.

ActionScript, unlike many other languages, does not have a way to explicitly remove an object from memory. Instead it waits until all references to an object are removed and then auto-deletes it. Therefore, an object will continue to stay in memory if all strong references aren’t removed.

Below is an example of how strong-references hold an object in memory. If you’d like to try this out, copy the below text into a file called StrongReferencesExample.as

[ftf]
package {
import flash.display.Sprite;

public class StrongReferencesExample extends Sprite
{
public function StrongReferencesExample()
{
// create a new object called dog. Add it to the first leash object
// and make leash2 a copy of leash 1.
var leash1:Object = new Dog();
var leash2:Object = leash1;

// tracing both leashes will show that they hold a reference to the Dog
trace(leash1); // [object Dog]
trace(leash2); // [object Dog]

// deleting the dog from the first leash will not remove it from the second leash
// even though we originally set leash2 equal to leash1
leash1 = null;
trace(leash1); // null
trace(leash2); // [object Dog]

// The object (dog) will not be free until all of the references to it (leashes) are broken.
leash2 = null;
trace(leash1); // null
trace(leash2); // null
}
}
}
// Define a simple Dog class within the same file.
class Dog {}

[/ftf]

Richard Lord over at Big Room Games has an interesting article on hacking AS3 to allow you to create weak-references to objects. The hack is pretty decent but lacks a few things I’d like to see like strong typing at compile-time or a more refined ‘memory manager’ type functionality. However, I tried implementing both of these and came up empty handed. If you can think of a way to make this strong-typed, I’ll give you a candy bar.

Using the WeakReference hack could be useful if you want to make sure that an object will not stay in memory if you forget to delete all references to it. However, keeping track of your objects and practicing good memory management is a much better solution and hacks like this one should be saved for special cases where tracking use of an object becomes difficult or impractical.

Thanks to Alex for the link!

An Introduction to Using Patterns in Web Design [37 Signals]

• firstborn. My friends relaunch their flagship site. Congratulations! It’s totally PIMP! Be sure to check out Zune Journey which they just launched as well, it’s a really, really fun site. I love seeing sites like this that are just fun, cute, happy, and aren’t heavy-handed with the marketing.
• EOS 400d site, using papervision with a photos-in-space collage to really great effect! Feels a lot like the interface in Photosynth. The hinting the camera uses to change angle toward points of interest, and smoothly traverse around objects in the foreground, make this interface really smooth and very filmic!
• Away3D normal mapping demo. This really blew me away. Normal mapping is, I feel, somewhat of a holy grail for software 3d packages like Away3D and Papervision, because it lets you display very simplified geometry, but shade it like the high-resolution original model. You can see the bust is only rendering maybe a hundred or two hundred polys, but the impression it gives is of a very nicely detailed model, because lighting calculations use normals from a prerendered normal map rather than from geometry. BRAVO!
• FOAM. My brilliant accomplice Drew Cummins’s new physics engine, which he created because there aren’t enough physics engines in Flash. Just kidding, he made it to play with maths and so we can make games with it! And so I can use the term Range-Kutta when talking about it, which I love.
• PARKLAB. This one isn’t new at all, but I just wanted to point it out. These guys are great designers and great programmers, and it could be my favorite flash experiment blog out there. I’m a fan.