Labs Jaap Kooiker AKA Flashcoders - Flash, Flex, AIR, IPhone

Today I decided to do a few funky particle experiments. This is what I came up with. The’re relatively simple to make, but the result is fantastic. Click on the images to see the real deal. Maybe next week I create some kind of an interface to change the properties at realtime…Lookin’ forward to that already….

This is one of the many products I’ve been working on in my spare -> spare -> spare time. It’s done totally free because it’s a local drumband wich can’t afford my hourly rate at the time (oh yeah, and my mother and sister are members of the band :) ).
Anyway this site is in Dutch and has no translation at the time. But the main idea will get clear when you see it.

Because this is a site with no hard deadline or cost target, I could spend my time learning new stuff and try something (almost) new (for me).
I have used 3d max to make a 3D environment and render the whole. Oh my god…I didn’t remember it was so complicated after the last - and only - time I used it four years ago.
Oh well… after a decade (it seemed like it) of tutorials and reading I started to make some 3D models and maps. The basic idea was to create some kind of an old hangar in wich the band does it’s practicing. I do realize I’m no expert (and maybe never will be) but I think the end result is pretty good.
After creating the hangar and stuff inside I went and created some camera’s and started to aminate the cam trough the hangar. This resulted in a flying cam from a fixed spot to the top of a specific bin and open the contents.
Making the camera go back after clicking home gives it some extra interactive feeling. One thing I intend to improve is when a bin is clicked and a book is showing, it needs to use all the screen width. This way (in case of large enough resolution) scrolling is not needed.

The final contents are not set yet… Let me know what you think of this beta release…

Edit:
Final Version : http://totallosameland.nl

Jaap Kooiker

A couple of days ago I struggled with (at the time) seemed a strange problem.

I had a main application which on it’s part loaded new applications (sub swf’s). Both (the main and the sub) swf’s where on my local machine at the time of development and both swf’s used (besides many other classes) the same (from the same package) static class with static functions. Let’s say the Class had a counter which whenever called, a function called countUp() traced the current count, like so:

public static function countUp():Void{
trace(”current count: “+Sample.countUp++);
}

For now everything worked fine. So at the end of the day I uploaded all the swf’s to a test server. The next morning I started with a glimps at the victory I achieved the day before. I did this by compiling the main application and discovered it wasn’t working anymore. The output for an instance would be this:


(output : current count: 1)
(output : current count: 2)
(output : current count: 3)
(output : current count: 4)

and when the external loaded swf called the static method


(output : current count: 1)
(output : current count: 2)
(output : current count: 3)

Somehow the two swf’s used a different static class??? At that time I had a big questionmark above my head and got up to get some coffee first.

While drinking my coffee I re-tested the whole on the test server and it worked fine…what the… After some struggeling I remembered that the XML for the main application had Urls to the sub swf’s. Of course these sub swf’s where comming from the server. Maybe that is the problem? I discussed this with a colleague of mine and we concluded flash does this (as in the sample above) for security reasons (of course). This way it is not possible for another external swf to manipulate the classes from another server. It’s all seems so logical now…

So from an interaction design point of view:

If there only was a Sercurity Warning in the flash output panel….

Jaap Kooiker

As I mentioned earlier I use a MVC framework which we created at my work. Now for AS3 we wanted to revise this MVC framework and review the whole, although it is already pretty good. The discussion about queuing commands raised. Here are some reasons why I think queuing commands is a good practice. Now there are some things you have to consider when using queued commands, like for instance build a (failure-) timeout when executing a command. Otherwise your next command may never be executed.

• You always know which result belongs to which command dispatched, because you can only execute one command at the time;
• Browsers have connection limits which opposes a problem when you dispatch multiple commands at the same time;
• You can use singletons instead of instances as commands, which makes is easier to create and manage EventListeners. It’s more likely you don’t build up countless EventListeners for each command (because it’s a singleton);
• Starting up an application can be better directed. If you know you have to execute, for example, 20 commands you only have to know if the last command’s result (or fault) event is dispatched. Now you can continue your startup of the application

So these are some main reasons why I think you should use this construction.

Jaap Kooiker

The last couple of years my work with flash is more or less occupied by programming actionscript. I’ve learned to do everything with actionscript, from working on and with the Custom MVC framework we have at TFE, to tweening, using the drawing API and so on. Today a colleague of mine reminded me of the power (and flaws) of old school timeline tweening and masking. Since I totally shut my mind of this “old school” stuff I needed some convincing, so I tried it out.

Turns out very nice results can be achieved in a simple way.
Since I build more like applications, I always had much respect for the websites with trees or flowers growing from scratch. Now I have made a simple but (as I might say) nice example of what can be done with simple timeline tweening and masking.

Check it out : Old school tweening and let me know what you think of it.

So there you have it… when used right, timeline tweening can also be cool.

Jaap Kooiker