Flash Version of Ultima IV: Quest of the Avatar

This guide explains how to set up a Flash and Flex development environment with Eclipse, FDT, Flash Builder and a couple of other editors that you want for ActionScript coding and Flash development with style! This guide is based on Windows because that’s what I’m using but I’m sure you Mac and Linux guys can figure out the parts that differ on your OS! Let’s get started …

• Java Runtime – In case you don’t have it installed yet. Choose either the Standard Java Runtime from Sun or  – my recommendation – the JRockit Runtime from Oracle. The latter is a highly optimized version of the Java Runtime. It’s free but you have to register an account at Oracle to download it.
• Eclipse Platform Runtime Binary – We want the bare bones version without all the additional junk. We’re going to add the stuff we need later. Don’t worry! It’ll be a smooth ride if you follow this guide.
• Powerflasher FDT – The best tool for ActionScript coding … with a price tag! But you don’t want to skimp on professional tools for professional work, do you?! We’re going to install this from within Eclipse later!
• Flash Builder PlugIn – I’d list this as optional since the only advantage of it over FDT is currently it’s visual editor. You don’t want to code ActionScript in this once you’ve used FDT, believe me!
• Other Eclipse PlugIns: HTML-, JavaScript-, XML-, CSS- Editors, Apache Ant (via JDT). These are all tools we need every now and then. Gratifyingly, the Eclipse project provides excellent versions of all these.
• Even more Eclipse PlugIns: Subclipse and Mylyn. Both optional! Subclipse for accessing SVN repositories and Mylyn as a great coding task tool. Both get installed later via Eclipse.

Other Tools you might need/want:

• Flex SDK – FDT ships with it’s own Flex SDK but they are usually a step behind the latest version so I prefer to use SDKs that stand on their own regardless of what FDT ships. Be sure to pick the ‘Adobe Flex SDK’, not the ‘Open Source Flex SDK’ since that one is missing a few things. Also you might want to have several different SDKs installed like for example Flex 3.x and Flex 4 which you can target individually from FDT. If you want to use Ant build files later to build your projects it’s a good idea to place the SDKs in a clean and easy folder hierarchy, e.g. let’s say I have Flex SDK 3.5 and 4.0 on my system then I would put them under C:\Users\username\Applications\FlexSDK\3.5.0 and C:\Users\username\Applications\FlexSDK\4.0.0. I remember having trouble with spaces in path names when I experimented with Alchemy hence I decided to not put the SDKs into a subfolder in ‘Program Files’.
• Flash Player Runtimes – Debug versions, release versions, browser plugins and whatnot. I typically disregard all the versions that come with any Flex SDK or Flash IDE and copy the newest version into a folder that always stays the same (for example C:/Program Files/Adobe/Flash Player/Debug/FlashPlayer.exe and C:/Program Files (x86)/Adobe/Flash Player/Release/FlashPlayer.exe) because it can get messy if you have X different SDK versions plus the Flash IDE, plus Flash Builder etc. installed that all come with their own runtimes.
• Adobe AIR – because Flash development would be only half the fun without it!
• Adobe Flash – The ol’ Flash IDE. If you code with this you will become impotent but it’s still great for putting visual assets together and use these as SWC’s with FDT.
• Alcon – My own little debugging and logging tool. There’s a good choice of similar loggers out there but Alcon still serves me well. Suit yourself.

1. Java Runtime
   This should be straightforward! Choose the one you prefer from the links above and install. If you go for the JRockit one, you might want to set an environment variable (under Windows) named JAVA_HOME that points to your JRockit runtime path. For example I have my JRockit installed in C:\Program Files (x86)\Java\jrrt, (under Windows 7) open the Start menu, from there navigate to Control Panel/System and Security/System, click the Advanced system settings link on the left of the window, in the System Properties dialog click the Environment Variables button, then click the New… button under System variables and enter JAVA_HOME as the Variable name and C:\Program Files (x86)\Java\jrrt\jre (in my example) as the Variable value. You might have to reboot or at least relogin for this setting to take effect.
2. Eclipse
   Download the Eclipse Platform Runtime Binary (currently v3.5.2, ~47MB) and unpack it. Copy the Eclipse folder to where you like, typically something like  C:\Program Files\Eclipse but I prefer to have my installation under C:\Users\username\Applications\Eclipse. The reason for this is that under Windows with UAC turned on Eclipse will create an additional folder in your user location where it stores all your installed PlugIns so you end up with two locations in that things get installed. This led to discrepancies more than once for me before due to ambiguous PlugIn installs. Very, very annoying so eventually I decided to keep it simple and have it in a non-UAC protected location.  The C:\Users\username\Applications folder is my place for all applications that have trouble with UAC.
   Either way, you have your Eclipse where you want it, next step is to edit the eclipse.ini. Your default eclipse.ini will look similar to this:

   -startup
   plugins/org.eclipse.equinox.launcher_1.0.200.v20090520.jar
   --launcher.library
   plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.0.200.v20090519
   -showsplash
   org.eclipse.platform
   --launcher.XXMaxPermSize
   256m
   -vmargs
   -Xms40m
   -Xmx256m

   And this is how it ‘should’ look after you edit it:

   -vm "C:\Program Files (x86)\Java\jrrt\jre\bin\javaw.exe"
   -startup
   plugins/org.eclipse.equinox.launcher_1.0.200.v20090520.jar
   --launcher.library
   plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.0.200.v20090519
   -showsplash
   org.eclipse.platform
   --launcher.XXMaxPermSize
   256m
   -vmargs
   -XX:MaxGCPauseMillis=10
   -XX:MaxPermSize=128m
   -XX:PermSize=64m
   -XX:+UseParallelGC
   -Xms128m
   -Xmx1024m

   If you don’t use JRockit you can skip the first line, if you do use JRockit you need to adapt the first line to point to your JRockit jawaw.exe!
   The -XX:MaxGCPauseMillis=10, -XX:MaxPermSize=128m, -XX:PermSize=64m and -XX:+UseParallelGC lines are not mandatory but they improve performance (or so I’ve heard!). Just be sure to set Xms and Xmx high enough, to at least 128 and 512, but better 1024 (Eclipse and FDT need LOADS of RAM!).
   Next fire up Eclipse and choose your Workspace location. Eclipse will present itself with its nice and warm intro screen …
   

3. JDT & Ant
   Click through to the Workbench (the arrow on the right) and from the menu choose Help/Install New Software… then in the Install window  where it says “Work with:” choose the Galileo update site (Galileo – http://download.eclipse.org/releases/galileo) and in the tree list that shows up, unfold the Programming Languages branch and check Eclipse Java Development Tools. Then click the Next button and follow the install procedure. Restart Eclipse when it asks you to do so after the installation.
   
4. HTML-, JavaScript-, XML- and CSS- Editors
   This is the exact same procedure as in step 3 with the difference that you unfold the Web, XML, and Java EE Development category and check the Eclipse Web Developer Tools, Eclipse XML Editors and Tools and the JavaScript Developer Tools.
   
5. Subclipse
   Next things next! For Subclipse we need to add the update URL to Eclipse. Open The Eclipse Install window again, click the Add… button and enter Subclipse 1.6 as the name and http://subclipse.tigris.org/update_1.6.x as the location (or you might wanna check the official Subclipse site for any newer update URLs) …
   … Hit OK and choose the required Subclipse components from the tree list. You need at least the parts that are marked as required but I also pick Integration for Mylyn, the SVNKit Library, SVNKit Client Adapter and the JNA Library. Can’t hurt to have them on board! After that click Next ansd from there on the procedure is very much the same as before with step 3 and 4.
   
6. Mylyn
   We can install Mylyn and all its dependencies again from the Galileo update site just as above under step 3 and 4. You’ll find Mylyn in the Collaboration category. I’ll go for Mylyn Task List, Mylyn Task-Focused Interface, Mylyn WikiText and Mylyn Bridge: Eclipse IDE. There are some other bridges for other Languages if you want them but since FDT has no support for Mylyn yet there’s nothing for ActionScript. However we can still put Mylyn to good use for our ActionScript programming, we just don’t get the same task-focused integration as with Java or C++.
   
7. FDT
   Time to install the FDT trial! We need to enter the update site just as with Subclipse in step 5. For the update site enter FDT as name and http://fdt.powerflasher.com/update/ as the location (or check the Powerflasher website in case the URL changed). Pick the FDT version(s) that you want to install from the tree list, hit Next and go drink a coffee! Installing FDT will take a couple of minutes. Don’t forget to restart Eclipse after install!
   
8. Flash Builder PlugIn
   At last we install Flash Builder! This step is wholly optional! If you don’t have any use for Flash Builder’s visual editor I actually recommend to skip this step and instead enjoy a more lightweight Eclipse without Flash Builder.
   Head over to Adobe and download the Flash Builder PlugIn trial version (at the time of this writing it’s the Flash Builder 4 beta 2 which can be found at the Adobe Labs). You might be required to register at Adobe to download the trial.
   Next quit your Eclipse and start the downloaded Flash Builder installer. Go through the installation steps and when it asks for the Eclipse install choose Plug into another copy of Eclipse and enter the path to your freshly prepared Eclipse location …
   … continue the installation, then go drink another coffee, installing Flash Builder takes long!
9. Bonus Step
   Download this slick Splash screen and replace the unlucky default Eclipse Splash screen with it by copying it to your Eclipse/plugins/org.eclipse.platform_x.x.xxx… folder.
   

And that’s all for now! With this setup you have your one-stop-shop for Flash and Flex development at your fingertips! In the next part I will try to guide through some configuring of Eclipse, in particular on how to use FDT and Flash Builder on the same project.

However the demo already shows some of the special features of the tile engine. It’s a blitted multi-layer engine which supports animated tiles (but it doesn’t use MovieClips or Sprites for this but animated Bitmap tiles). The demo shows two layers, one as a backdrop and the other with the maze on it. Additionally layers can use layer effects like the second layer here uses a drop shadow filter which is also defined in the tilemap file.

The engine tries to be resource friendly. If there is nothing to update it will not waste render cycles. E.g. if you move to any area without animated tiles on the screen the engine will shortly after start to consume less CPU.

(Please open the article to see the Flash content.)

Quite a list of features is still planned to be implemented, for example map-wrapping (to create endless maps), auto-scrolling and support for hexagonal as well as isometric tiles has already been started before but these implementations are going to be completely overhauled.

If you’re interested in having a look at the engine’s tileset and tilemap data files, they can be found here.

]]> http://blog.hexagonstar.com/lab-hexagon-tile-engine/feed/ 2 http://blog.hexagonstar.com/flash-for-big-games/ http://blog.hexagonstar.com/flash-for-big-games/#comments Wed, 26 Aug 2009 07:18:23 +0000 sascha http://blog.hexagonstar.com/?p=970 Even though I love ActionScript more than my daily meal I’ve recently started to think about if the Flash Platform is actually the right stuff for developing big games. Most Flash game developers write small-scale games for the web which is totally fine and I too like to write a small coffee-break game sometimes but often I’m craving for more! My dream has since long been to design and develop a large-scale role-playing game and I’m usually overflowing from new ideas coming to my mind every day that it’s almost hard to track all of them.

I could go on and make this project an oldschool-style game with 2D graphics like some other indie devs are doing but I feel that going 3D would be the best bet to convey atmosphere and tactical gameplay at the same time (you could use switchable first-person and third-person views). This makes me think if ActionScript is actually sufficient for this but the experience of some of my recent coding tests with Away3D which already start to bog down the CPU with a few hundred polygons on the screen tend to say “no!” to my ambitious plans.

Since this is a desktop game my platform choice is AIR which offers more freedom that the Web Player but there are still many let-downs that make you grind your teeth …

Hardware 3D

Without a doubt the biggest problem is the lack of hardware-accelerated 3D rendering. With the current software-rendering engines you could make simple 3D games where you try to always keep down poly-count to an absolute minimum. Basically your game will then look like anno 2000, if not worse. I remember most games of the late nineties to early two-thousands as having these “wood  puppet”-appearing character models, both in terms of look and animation. I must admit that some games achieved quite good quality for the technology they were running on, for example Metal Gear Solid on the first-gen Playstation. Would that be possible in Flash? Probably yes, with a lot of trickery but who wants to make games that look that outdated? As I mentioned in another post, I’d be better off with well designed 2D instead.

Not sure what Adobe is doing regarding 3D but sure is if if they are sleeping on this, the competition will not sleep and we might see developers wander over to Silverlight or Unity3D.

Full-screen Resolutions

There are several other painfully missing features in Adobe AIR which I hope Adobe will care about. One such feature would be the option to change the screen resolution! As it is currently if you switch your game to full screen it will run at the same resolution in that the player runs the OS in. Screens have become larger and with that screen resolutions have too. If you now switch your Papervision game – which was running fine in a 640 x 480 window – to fullscreen in 1920 x 1200 you can watch how your game is being degraded into a slideshow! Fullscreen games would profit a lot from being able to change screen resolutions.

The fullscreen mode brings me to another bugger: The Escape key! Adobe has the opinion that the Escape key must not be remapped and that it should solely be used to close a full screen mode. I guess they did this for security reasons so that an ill-intended coder cannot hijack your screen. However I disagree with this rationale! Such a coder could use C, Java or Python or any other universal programming platform for that matter in a much more suitable way. Some security restrictions go too far and the Escape key is one of them. It’s more of a blocker than a help!

Resource Files

Most modern commercial games use what is called Resource Files; large compressed archive files which contain all of the game’s media and data files. These files are often in the hundreds of megabytes up to several gigabytes. While I doubt that I will make a game anytime soon that has an assets library of several gigabytes I can imagine that my current project could go easily up into several hundred megabytes of assets.
The commercial developers use resource file formats to organize their asset files into nicely compact files. These resource files house many advantages over just simply having your naked files on the harddisk. Among the advantages are compactness, protection, easy file distribution and better structural organization.

With ActionScript you could load compressed Zip files that store all your games’ assets but there’s a tiny but important catch to this: Most of those commercial games which are written in C++ and which utilize the file system have the ability to access any of the packed files quickly and right at their position in the resource archive without the need to load the whole resource archive into memory first. In fact you wouldn’t want to load a 4Gb file into memory completely but how about a 200Mb file? While that’s possible it’s not a best-practice.

ActionScript currently provides the URLStream class that can be used to stream a file in but it still does so only in a linear way. You could start loading your Zip file, check which assets from it is available, abort loading and use the asset but this is sub-optimal! Imagine your file is somewhere at the end of the Zip file you’d still have to load the whole Zip file first. ActionScript (or in particular AIR) would go nicely with a URLStream class, or even a completely new API that could make optimal use of a Resource File format which houses compressed media and data files. Maybe Adobe could even introduce a specific new file format for this purpose. That would be ultimately nice!

I have no idea where Adobe stands with the future plans for Flash and whether some or all of the above mentioned points are resolved at some time or if they are never resolved in which case I’d get the impression that the Flash platform is a sinking ship for me – which I do not hope for!

Currently we as Flash game developers (I hate that name!) are standing at the fence which borders on that green and juicy meadow of professional game development and we can only hope that things improve in our favor so we too can graze on that green grass where the big cows are reveling.

I’ve been designing on a rather ambitious Role-Playing game project since a while now (in fact quite a long while but I’m not in hurry to finish it anytime soon) and while I’m in the process of working out the story, technical details like the combat mechanics, skill system etc. and creating interesting characters I still haven’t made a decision on the type of graphical projection for the game so far. I’ve been thinking about five kinds of projection from the most basic one (2D orthographic) up to full dynamic 3D which would be quite an effort. As my development platform of choice happens to be Flash, the resources in terms of 3D are limited.

So with that in mind I thought it would be good opportunity to introduce some of the most-used projections in computer and video role-playing games to get to know them a little better. This is by no means a complete list of all sorts of projection used in games but I believe these the ones most commonly used for role-playing games.

Orthographic Projection (Top-down View)

Orthographic is pretty much a collective term for all projections that lack perspective (i.e. all 3 axes have the same length) but I’d like to use it here to describe the typical top-down view – often called birds-eye view – used in RPGs.

Hard Nova uses a very simple (but nevertheless charming) top-down view for it's interiors.

The top-down view can either be completely flat which is obviously the most easy way to draw graphics or it can give the impression of depth by using an oblique style. Many of the older J-RPGs like Zelda and Final Fantasy are using this method. You see buildings, characters and other objects that point into one direction (usually to the top of the screen) to give the illusion of depth. Often this style is used in a very simple form so that characters are not being able to ‘step behind a wall’, i.e. the collision detection that checks where the characters are allowed to walk adheres directly to the graphic tiles used in the game. Some other games of this style might involve some trickery to offset the line used for collision detection so that characters can walk behind walls and are half-covered by them to add some more dynamic.

Jagged Alliance: Deadly Games is a good example of an oblique top-down view.

The advantages of this projection are clear: it’s the easiest to draw and the easiest to implement. Also the nature of this style makes it easy to use for RPGs that use a character party which needs to be guided around the screen. Selecting party members and using them tactically (positioning, line-of-sight, etc.) is more easily done here.

The disadvantages are that this projection is the most simple looking and most overused one (but then again these are not necessarily disadvantages)  and in particular that this projection type can ruin potential immersive atmosphere, i.e. unless you’re using some sort of Fog-of-War the player can see what lies around the next corner. Even if you don’t draw any opponents until they are in the line-of-sight of the player in my opinion this doesn’t convey the same level of immersion as 3D or Flip3D (see below) projection would.

Isometric Projection (Tiled)

Isometric view and (although not technically isometric) it’s cousins trimetric and dimetric are projections that were (and still are) used in a long list of games, mostly strategy-, management- and of course role-playing games. Highly regarded by many as the finest-ever invented graphics style, isometric projection has the advantage over basic top-down view that is adds more depth and at the same time often more dynamic and clarity to the layout of the play field.

Fallout 2 - one of the better known tile-based isometric RPGs.

I must admit not many RPG titles that are using a tile-based isometric projection are coming to my mind but some good examples from this domain are Fallout 1 & 2 which use trimetric projection (all three angles are different) and the Indie RPG  series Avernum.

Advantages of the tiled isometric projection include the easiness of implementation and a big favor for tactical gameplay. It’s easy to see tactical elements in relation to each other and so it comes to no surprise that many strategy games used this style.

The disadvantage I see with isometric graphics is the same as with top-down view projection, the lack of immersive atmosphere (see above) and that isometric graphics (tiles, sprites) are more difficult to design (but assets rendered with a 3D package can help a lot here).

Isometric Projection (Full Backgrounds)

The big contender among isometric engines that used pre-rendered backgrounds instead of tiled graphics was without a doubt the Infinity Engine and with it such classics like Baldur’s Gate, Icewind Dale and Planescape: Torment.

Baldur's Gate II: Excellent use of pre-rendered backgrounds and light-effects all around!

Instead of using tiles, larger backgrounds were modeled, textured and pre-rendered with a 3D graphics application and then used … well, as sort-of large-scale tiles in the game. This technique allowed for a lot more visual detail and variation. Environments that were difficult to draw with a tile-based approach such as for instance a deep, rocky abyss or other intricate landscape were made possible much easier with fully rendered backgrounds. Also many other items like furniture and interior walls could suddenly have a lot more detail. Another advantage that the Infinity Engine introduced was the use of dynamic lighting and acceleration of visual effects by use of DirectX. Full-screen rain or snowstorm? No problem here!

Collision detection and path-finding was solved by using a special bitmap for every background that defined the walk-able areas using different colors.

The big advantage for this technique is of course the gain in graphical detail and that it eliminates some of the problems of a tile-based engine, namely intricacies when dealing with dynamic lighting, path-finding etc.

The disadvantage here is the extra-work of complexity required to implement such a full background rendering engine, the additional task to design pre-rendered background graphics using  3D modeling and that such an engine requires more system resources than a tile-based engine, RAM and CPU-wise.

Flip3D

Now what in the hell is Flip3D? You might hear this term for the first time ever here but Flip3D is what I like to call (for the lack of a better word) the projection style used by many games from the Golden Age of RPGs era that use pseudo 3D images which are drawn with perspective in mind and if you turn in-game to the left or right the whole view is flipped turned by 90° hence the name, uhh, Flip3D (if you know the technically correct term for this type of graphics display technique I’d like to learn it but until then let’s just call it Flip3D).

Countless RPGs utilized this projection, most notably titles like Dungeon Master, Eye of the Beholder, the Ishar series, the Might and Magic series and – although not really a RPG – one of my all-time favorites, Hired Guns. All these games used pre-rendered graphic parts like floors, walls and ceilings that are composed together on the screen to create a room or corridor or even an outside environment.

Wizardry 7: VGA never looked better (and RPGs never were harder).

The advantage is that these graphic parts could be re-used, making it easier to quickly build whole maps. The disadvantage to this was often that in many of the games the maps looked monotonous. In my opinion Hired Guns nailed this problem quite well which is one of the reasons that made it stand out from the others for me.  The maps looked detailed and very different from level to level, in the background they’ve used a gradient to represent the dawn on the firmament and there was usually a dark backdrop used for a horizon to give the impression of mountains, landscape or buildings in the far distance. It’s exactly these details that are one of the features that filled the game with atmosphere. What could be there in the far distance? The distance that you were never able to reach because it was not a part of the map but, alas, only a backdrop.

The lack of clear detail opens a lot of freedom to the player’s own imagination and this is one of the points why I highly regard some older games that use simplified graphics where modern games with tons of detailed real-time 3D choke the last bit of imagination from the players mind (not that I’m saying that this is necessarily bad but for me it is gaming on a different mental level).

Ahh Hired Guns! Flip3D at it's finest!

And with that we have the main advantage of this projection type … used with well-drawn graphics it can add a nice deal of ‘hidden’ atmosphere to the game because you never really see what lies (or lurks) in the distance.

The main disadvantage of this projection from my point of view is that it’s not much in favor for tactical gameplay as long as you want to involve your party into the action. Games with Flip3D projection are necessarily first-person so you don’t see your own character and your other party members are either behind or sideways of you or standing in front, covering a big part of the view field. Guiding and commanding all your party members can become quite a chore here.

3D Projection

3D projection is the current state-of-the-art in computer game graphics and will probably not be replaced so soon (until somebody invents some sort of 4D virtual reality device). This projection allows the highest degree of freedom meaning that any object can be viewed from any angle, at any distance and with arbitrary FOV.

SWKotoR 2: Can we haz it in Flash please?

There is virtually no quality loss when zooming in and you can re-use 3D objects for all kinds of displays, for example you could have your once-designed character 3D objects walk around in the game world and at the same time use them on a special inventory window where you drag and drop equipment onto the same used 3D object of their bodies. This allows for ‘create-once, use everywhere’ unlike with 2D assets where you often have to create variations of the same object for use in different views.

You could also use 3D with a fixed camera to simulate a certain type of 2D view and the advantage of 3D objects would still be obvious.

The disadvantage of choosing this projection is that the creation of assets, i.e. 3D models of characters, items and environments is a lot more involved as with 2D graphics. Unless you are some sort of super-developer-designer-machine with 300 years of time up your sleeve you probably need a small team of professional 3D designers who can do this work for you. Ok, I’d say nobody died of trying but recent 3D game graphics have become so professional that it’s not an easy feat to try catching up with it. And who wants to design a game with 3D graphics that look like anno 1996? I’d probably be better off with nice-looking 2D graphics instead!

Then, as you want to create a large world for a RPG you’d have to design many interior/exterior maps that are used for the game world. If you use 3D I doubt you want to design this all manually. What you need is a map editor to create the environments more comfortably and re-use assets quickly etc. Writing such a map editor is already a whole job unto itself and takes a lot of time.

Wizardry 8: Simple 3D graphics & first-person view

Another complication with 3D graphics is the platform used for the game. I use Flash (or AIR) with use of ActionScript. While I’m convinced that ActionScript can handle all the other projection types, with 3D we’re hitting the limits very quickly. PaperVision 3D, Away3D and the Alternativa Platform all have been used sucessfully for game development already but I have yet to see a good example of an extensive RPG made with one of these and the fact that a few thousand triangles bring the framerate to a screeching halt doesn’t help the case.

Still, any of these 3D engines could be utilized in Flash for a simpler form of 3D graphics style, for example the use of mainly simple primitives with a good job in texture detail work and a combination of 2D sprites. I’m definitely looking further into this possibility.

Conclusion

I’m still in the dark about which projection style I’ll eventually use. I might be creating a first prototype with a very simple and flat top-down view (a la Ultima) to test other components of the game and then later change to something  more advanced.

Any of the introduced techniques have their charming sides, for example (as you might have had no troubles noticing) I’m very fond of Hired Guns and it’s dark and futuristic pseudo 3D view. Then again an isometric view could be more suitable for tactical gameplay (which, as I’m planing the game should have quite a few of).

Realtime 3D would be the ultimate thing but I dislike the idea of creating super-simplified 3D objects and Flash currently lacks the rendering power to use higher-end 3D graphics. I might as well be watching if the Flash platform improves in this area and then see what can be done in terms of 3D later.

Was it that? I’m sure I forgot a ton of facts and details here but I would be very interested in what others have to say about this topic or what view styles you’re about to use and why etc.

Further Reading: Significant Bits – A layman’s guide to projection in videogames

[ad#ad_content]ActionScript developers are a poor bunch! Internet Applications have become more and more complex and require you to plan your architecture carefully. In fact you need to be not only a programmer but also a full-fledged OOP architect if you want to achieve complex applications or otherwise two weeks later when the client asks for changes you will be in code chaos hell. On the other side the customer can’t care less and asks you to finish their product within two weeks just like it was in the old days of  Flash 5 where you could churn out some wonders quickly (but dirty under the hood) because, hey, does the client care how well your code is organized? The hell he cares! I feel kind of like: first we all yelled for better code management, now that we have it people start to complain that it’s too OOP.

Being a game developer who has a few more ambitious projects on the shelf I’m all for OOP and coding-best-practices. The artsy-fartsy Flash Designer hype from yesteryear had it’s show but now please move along, it’s time to advance!  Personally ActionScript was what has taught me OOP practices and I would be nowhere today if it wasn’t for ActionScript. Sure, I could have probably learned it from C++ or Java too but ActionScript’s prevalent support and documentation made it a lot easier.

I’m all for strict typing and seeing some people wishing back dynamic typed features makes my stomach turn over. Instead I’d rather like to see more data structures that allow strong typing just like the recently introduced Vector does. Really, there’s no way that 10 horses can pull me back to dynamic typed programming! Sometimes I find AS3 code examples on the web which are all untyped and dynamic, obviously by some coder who completely neglected strong typing because he either didn’t fully understood it or was too lazy. This is what Nicolas Canasse got right when he stated that ActionScript lacks expressiveness. It leads to people falling back to dynamic typing if they see that all this extra stuff required for the correct approach. I use FDT which has an excellent template system so I don’t really care if there’s a tad more code to write to achieve good code. In fact OOP stipulates more code. At first I worried too but I’ve learned to live with that.

I think Adobe should loosen the grip of ECMA 4 on ActionScript which it already has broken anyway by not being fully compatible to it anymore. haXe is doing many things right where Adobe fails with ActionScript, advanced OOP features like Generics, typed Arrays with auto-casting, in-lining, Enums etc. To stay up to competition ActionScript needs these and then some. Others have already listed their feature hopes which I reflect but here are they once more:

• Method Overloading (because writing Open-Source frameworks and libraries often is a travesty without this).
• Generics
• Threading (Oh yes!)
• Multi-CPU-Support
• Private Constructors (bring them back!)
• True Abstract classes/methods
• Enums (has been a long time wish. Don’t know what the problem is!)
• Hardware rendering (PV3D etc. are great and all but whats the point if you hit the wall with under 1000 triangles?!)
• Compiler performance (Seriously MXMLC needs to hide in the corner if the haXe compiler shows up!)
• And last but not least I’d like to see a lot more love for the AIR runtime like better OS-integration (changing screen resolution for example) and better performance and resource management (the way how AIR wastes up RAM is not from this planet!)

${property} = new ${cursor};
addChild(${property});

It’s very simple but effective. Usage: Let’s for example name this template “newDisplayObject” and after invoking it with CTRL+SPACE you start typing the name of the display object property that you defined as a class property before which then should be auto-completed, then you hit TAB and then CTRL+SPACE to quick-insert the type after the ‘new’ operator (FDT is finding the correct type for you) and Voila, you’re finished, no need to add that extra ‘addChild’ manually.

After a lot of research it turns out that there seems to be no way in an AIR app to use the GPU mode that is otherwise supported by Flash embedded in HTML via wmodes parameter. In fact the docs state it’s not even supported by AIR …

… Flash Player 10 introduces two window modes, direct and GPU compositing, which you can enable through the publish settings in the Flash authoring tool. These modes are not supported in AIR …

While this is a definitive must for a hopefully soon appearing update there’s another issue with fullscreen modes … AIR doesn’t really feature any decent solution for fullscreen! You can have your app to be either in fullscreen OR in windowed mode but trying to be able to switch between both looks very ugly because the system chrome isn’t being disabled automatically when switching to fullscreen which results in that the window size will simply get maximized. So creating applications where you could let the user switch between fullscreen and windowed mode seems to be impossible at the moment with AIR 1.5.

I can understand that the Flash player on the web needs it’s security restrictions in this regard but AIR should definitely not be touched by this! I hope Adobe will improve this for a future update, AIR is a great platform for (complex) game development but these two issues are serious limitations to that!

So today I finally figured out how to install the plug-ins that I really need and nothing else (well … almost nothing else). The following guide describes how you can set up your own custom Eclipse tailored for Flash/Flex development which features FDT plus Subclipse, a HTML, CSS, JavaScript and XML Editor and then some. The CSS Editor becomes especially useful for Flex Stylesheets.

1. First I recommend to wipe your standard Sun Java runtime and install JRockit instead. JRockit is a highly optimized Java runtime from Oracle which is free and can be downloaded here. I recommend getting the ‘Real-Time’ version (you have to register at their site to be able to download but I’d say it’s worth it).
   You might also want to add a system variable under Windows named JAVA_HOME that points to the JRockit runtime path if you want the Flex SDK compiler to make use of JRockit.
2. Go to eclipse.org and download the “Eclipse IDE for Java Developers” (~85MB). Currently the latest version of Eclipse Ganymede is v3.4.2. The reason I choose the Java Dev distribution is because it is not as loaded as the Classic version or some other versions (we don’t need Plug-In development do we?!) but it contains some niceties which can be very useful for us, notably Mylyn, a decent XML editor and a cool Snippets plug-in which can be useful even though we already get the Templates feature with FDT.
   Note for Vista users: If you’re under Windows Vista and use UAC like me, I recommend not to put the Eclipse folder into your Program Files. If you do this Eclipse will split up your installation and put all your additional plug-ins into a sub folder in your user folder. And so far I’ve always ran into troubles with this when updating Plug-ins at a later time. Instead I’ve created a folder named ‘Applications’ in my user folder into which I install all applications that have trouble with Vista’s UAC, and so Eclipse is placed there as well (e.g. C:UsersusernameApplicationsEclipse).
3. Next edit your eclipse.ini to something like the following:

   -vm "C:Program Files (x86)/Java/jrrt/jre/bin/javaw.exe"
   -showsplash
   -framework
   pluginsorg.eclipse.osgi_3.4.3.R34x_v20081215-1030.jar
   -vmargs
   -Xms768M
   -Xmx768M
   -XX:PermSize=256M
   -XX:MaxPermSize=512M
   -XX:+UseParallelGC

   … of course you need to correct the path to the JRockit runtime and you might need to change Xms/Xmx as your system fits, however a minimum of 512MB is recommended for use with FDT. (While you’re at it, you might wanna replace the splash.bmp file in Eclipse/plugins/ org.eclipse.platform_x.x.xxx.vxxxxxxxxxxxx which this one).

4. Install Subclipse by adding the Subclipse update URL from the Subclipse website to your Eclipse Help/Software Updates dialog. I recommend the 1.4.x release as in the 1.6.x release SVNKit seems not to be supported at the time of this writing. Be sure to install …
   • Subclipse
   • Client Adapter
   • Native Library Adapter
   • JNA Library
   • SVNKit Client Adapter
   • SVNKit Library

   … and – if you want – Subclipse Integration for Mylyn and Subversion Revision Graph. Restart Eclipse after install.

5. Next up is Aptana, or at least the parts that we want from it. By default Aptana comes with a freight full of web dev stuff that we as Flash deveopers probably wont ever need. However I find it useful to have a decent HTML, CSS and Javascript editor at hand.
   Grab the Aptana update URL from their site (probably http://update.aptana.com/update/studio/3.4 ) and proceed the same way as with Subclipse. Aptana will first install a bootstrap installer after which Eclipse is restarted and then starts with the real installation. At that point you are able to choose which components of Aptana you want to install. I choose the following …
   • Aptana Editor Infrastructure
   • HTML Editor
   • CSS Editor
   • Javascript Editor

   Let it download and install those parts. After install and Eclipse restart for some strange reason Aptana will continue to nag us with the install dialog to install other parts of the Aptana package (probably the Aptana Web Development Tools). But we don’t want all that baggage, right?! To get rid of the install nag, press cancel, quit Eclipse and then do the following …

   • navigate to Eclipse/features and delete or move the
     com.aptana.ide.feature.eclipseXX. aptana.bootstrap _X.X.X.XXXXX-XXXXXXXX folder.
   • navigate to Eclipse/plugins and delete or move the files:
     com.aptana.ide.eclipseXX.aptana.bootstrap_X.X.X.XXXXX.jar
     com.aptana.ide.server.portal_X.X.X.XXXXXX.jar
     org.mortbay.jetty_X.X.XX.vXXXXXXXXXXXX.jar

   Removing the first three parts kills the install nag. The last file is not really necessary to delete but doing so prevents a feature of Aptana that establishes a HTML preview server even though we only want to build Flash projects.

6. At last we install our main tool, FDT. Get the update URL from the FDT website, add it to your Eclipse Software Updates dialog as usual and proceed to install. I choose the latest beta which is at http://fdt.powerflasher.com/update_beta/. Installing FDT might take a while as the package is quite large, including a shipped version of the Flex SDK.
7. Finished! Enjoy your light-weight (in Eclipse terms) setup and start coding your soul out! I hope this guide was useful for anyone to get their Eclipse install right! However I’m by no means an Eclipse expert so if you got any hints or improvement notes to make the install even better let us know!

Besides that Alcon is now code-signed there is exactly one new feature in v3.1 which I called Key Tracer. You can toggle Key Tracing Mode from the Log menu. If you enable it you are able to press any keys and their key code (and if available character code) will be listed in Alcon’s output window which is a useful feature if you want to know the codes for some specific keys quickly.

More features where planned (and already started) like a Search function, Log Level Filtering and even a Calculator but these haven’t made it finished yet into v3 so most of them will come with version 4, which is – yet again – a complete re-write (I do loathe my source code that is over one year old ).

The newest version can as always be found here.