Dovyski

One of the most common tasks in game development is the assets loading process. You have two options: 1) ship your game as a single 45Mb SWF file filled with sweet and compressed-to-the-bones images/sounds or 2) load all those assets separately and on demand.

Sometimes the first option is your best shot, but for casual online games the second one is more suitable. Multiple loadings in AS3 can be a pain, because there are several file types to load (wave, JPG, mp3, GIF, swf, etc) and there is no single way to load them all.

So far my best approach to solve this problem is called BulkLoader, a library for managing multiple loadings with AS3. It is licensed under the MIT License and has amazing features:

• Connection pooling.
• Unified interface for different loading types.
• Unified progress notification.
• Events for individual items and as groups.
• Priority
• Stop and resuming individually as well as in bulk.
• Cache management.
• Statistics about loading (latency, speed, average speed).
• Various kinds on progress indication: ratio (items loaded / items to load), bytes , and weighted percentage.
• Configurable number of retries.
• Configurable logging.
• Various assest types (XML, NetStreams, Swfs, Images, Sound, Text Files)

Design goals:

• Minimal imports.
• Few method to learn.
• Consistent interface, regardless of content type.

BulkLoader gracefully handles progress notification in these use cases:

• Few connections to open: bytes total can be used instantly.
• Many connections opened: progress by ratio
• Many connections opened for data of widely varying sizes: progress by weight.

One of the things I like the most is that this project was created by a Brazilian fellow named Arthur Debert . Thanks for this great tool!

Create and develop a game is hard task, but optimize one is even harder. You can ruin a perfect game design and a beautiful artset by filling the source code with useless and/or unnecessary stuff. In order to keep things in control a performance monitor comes in handy.

Mrdoob stats provides a simple info box that will help you monitor your code performance. It can tell you the following:

• FPS Frames per second, how many frames were rendered in 1 second. The higher the number, the better.
• MS Milliseconds needed to render a frame. The lower number, the better.
• MEM Memory your code is using, if it increases per frame is VERY wrong.
• MAX Maximum memory the application reached.

It is another great tool to know what is happing under the hood.

After Happy Farm and FarmVille attracted millions of user there is a lot of talking about isometric games. I've played several games featuring an isometric view then I've spent some thoughts around the idea of creating my own isometric game (or one for my company, developed during my inexistent free time).

Looking for isometric game engines, I found three great projects: FFilmation, As3isolib and OpenSpace.

FFilmation (MIT License):

• Have a programming interface as small and easy as possible, no matter how complex the internal code is;
• Rendering performance is a major concern when designing all the algorythms;
• Graphic designers are able to work on the application’s ( game or not ) environments without any programming skills, visually, and with almost immediate previews of what they are doing.

As3isolib (MIT License):

• Simple scene creation;
• 3 primitive types;
• Base class for displaying user-created conten;
• Plenty of styling option on vector based primitive;
• Integrates well with a variety of tween engine;
• Improved 3D isometric positional sortin;
• Scene & view renderer classes geared towards performance optimizatio;
• Performance caching of static and animated sprite asset.

OpenSpace (commercial, part of the SmartFoxServer platform for multiplayer games):

• Engine and framework for rapid development of multi-user virtual worlds and MMO communities;
• Customizable tiles' aspect ratio;
• Tiles Elevation
• 2D objects in a 2.5D world
• Backgrounds and foregrounds
• Scrolling
• Advanced pathfinding
• Powerful avatar management
• Advanced map interaction system
• Exhaustive documentation
• Complete Map Editor

If you were planning to develop an isometric game, you just found your first step.

When I play a game, I like to see all those flying particles popping up on the screen. Casual games make heavy use of this resource, sometimes more than what is considered healthy.

A particle system adds dynamism to the game and makes it feel alive. Where is the fun of blowing up an enemy base and see just a few flames as a reward? Players want to see lots of things flying around and sparkles shinning towards the camera. Flash gamers are no exception. In order to add particles to your game, you can use two free particle systems (both use MIT license): Flint and Stardust.

Flint is an open-source project to create a versatile particle system in Actionscript 3. The aim is to create a system that handles the common functionality for all particle systems, has methods for common particle behaviour, and lets developers extend it easily with their own custom behaviours without needing to touch the core code.

Stardust was inspired by Flint, but it has its own set features:

The first time I saw a really convincing physics engine working on a PC game was during a Half Life 2 session. All that Havok physics created an unique game experience. Luckily the use of physics inside games has grown and now we have a wide range of tool to use, even in Flash games.

QuickBox2D is one of them. It is a mini-library created to work with Box2DFlashAS3, which is an AS3 port of the famous Box2D C++ physics engine. The main purpose of this library is to significantly simplify instantiation of rigid bodies and provide a simple way to bind them with custom graphics.

You can start with QuickBox2D by reading this great kick off tutorial. It explains the engine itself and demonstrate how to use some of it's features.

I see lots of open source projetcs using Worpress as a blog platform, phpBB as a forum solution and Mediawiki as a wiki. I like them all, but maintaining them separately with no integrations is a pain. It's great when you register to a website and you can use the same fresh new account to comment on the blog, reply to a forum thread and/or contribute to a wiki page.

Excluding the wiki part, there is a tool that makes it all possible. OnePress is an integrated website and forum solution. It is, simply, a WordPress theme to serve as the foundation and framework for your web site and online  community.

Some of it´s cool features:

• Seamless integration with phpBB, complete with unified login and widgets to display forum posts on site.
• Widgetized WordPress layout with drag and drop interface to quickly build site.
• Professional featured content widgets to display important posts with prominence.
• Easy to use backend enhancements for editing OnePress widget content.
• Highly optimized page rendering process for optimal performance.
• Built with WordPress 2.7 and child themes in mind.  Flexible hook system for full theme customization.

I like to write my code from scratch, but it does not  mean I want to reinvent the wheel every single day. This is one of the reasons why I like to use engines to code games.

Sometimes the project has it´s own specific features and it requires a completly customized code, but most of the time it´s all about the same things: test input, check collisions, update a bunch of elements and finally render them all. Looking for a tool to do those tasks for me, I found two free and open source game engines: PushButton and Flixel.

PushButton is a very modular game engine licensed under the MIT license. It has core functionality as resource manager, logger, debug monitoring, serialization, time management, globally named objects, etc. It also has a set of components that make the engine even better:

• Physics based on Box2D;
• Gameplay components: health, teams, state machines;
• Sprite-based and SWF-based 2D rendering;
• Tilemap system;
• Pathfinding library;
• Basic networking. Pass events to/from your servers, do XMLRPC/JSON Web API requests, etc;
• Awesome UI capabilities via Flash - localizable, stylable/themable, internationalizable.

Flixel is collection of AS3 files that helps organize, automate, and optimize Flash games. It is also licensed under the MIT license and has a great set of features:

• Really fast renderer (5000+ sprites on modern PCs);
• Tilemaps;
• Particle systems;
• Global sound system with volume hotkeys, looping, panning, etc;
• Parallax scrolling (free/multi-directional);
• Built-in 2D box-based game physics (not Box2D);
• Fast text rendering;
• Retro style zoomed rendering options (2x pixels, 3x pixels, etc);
• Works great with non-pixel art too, with support for rotation, scaling;
• Composite multiple sprites using blending modes to create sweet lighting effects;
• Does not require the Flash IDE, works best with free tools like FlashDevelop;
• Organizational classes like game states;
• Simple buttons;
• Utilities for looping music and playing sound FX;
• Simple special effects like screen flashes and fades;
• Save game data between sessions using a local shared object.

Reading about them gave me the idea of writing my own game engine someday. Maybe some raining day I give it a try

These days I was looking for intranet solutions and I luckily found Open Atrium, an intranet in a box that has group spaces to allow different teams to have their own conversations.

OpenAtrium is built on top of Drupal, has a nice design and a useful set of features:

• Blog: A classic blog for each group that has commenting, file attachments on both the post and comments, and granular notifications.
• Calendar: A calendar that lets you quickly add events, suck in iCal and other calendar feeds, and support single or multi-day events.
• Group Dashboard: Mini widgets give you a snapshot of all the activity happening across your groups.
• Documents: A simple online handbook that lets you collaborate on documents, store and compare revisions, attach files, and once you're done print out the final copy.
• Shoutbox: Kind of like a private twitter, the shoutbox lets you share short messages, links, and information with just the people in your group.
• Case Tracker: A full ticketing system that lets you assign to do's and create unlimited projects within each of your groups. The case tracker also lets you classify the to do, give it a priority, and manage its status.

For small companies, it is an efficient tool to create/maintain an intranet.

Probably I've spent several hours editing and arranging pictures to create a nice Powerpoint presentation. Even though the Microsoft product is a great tool, I do not like the final result. It seems unfashionable, too poor and/or simple.

This is one of the reasons why I like image sliders developed using Flash. I look at them and imagine how wonderful life would be if I could easily use it and some lines of text in a .txt file to create a presentation. Nice graphics, beautiful font rendering, smooth effects (including blur and glow) and maybe some physics, why not?

Trying to make my dream come true, I found two amazing image/content sliders in Flash: MegaZine 3 and CU3ER. The first one is an open source pageflip/flashbook engine, written completely in AS3.

The other one is a content slider with 3D transition effects, such as spinning.

Certainly those two projects have lots of cool features and they can perfectly fit into a wide range of uses. If I have the change to save some time for my personal projects, such as my own Flash slide presentation, I will use MegaZine 3 and CU3ER for sure.

Sometime ago I was working on a Flash game and I had to output some information to the console. That's a very easy task when you use trace() and the Flash IDE, but things get a little harder when you need to output text inside the browser.

Looking for a tool that could help me output text, I found SWFConsole.  It is a free developer tool for Flash AS3 projects that gives you output in all environments, not just the IDE. You can type commands in order  to manipulate Movieclips in the stage,  such as myMovieclip.alpha = 0.3.

SWFConsole also has a built in resource monitor that shows FPS and memory usage, pretty useful for game developers. I miss some features as listeners to handle custom commands and a method to "enable/disable" the console instead of  showing or hiding  it, but it does not make  the tool less useful.

If you are a Flash game developer, SWFConsole can make your life easier!