http://www.youtube.com/watch?v=tgwi0lWgX8w

The demo was coded by the guys who maintain Alternative3D, one of the the few software-rendered 3D engines for Flash that are better suited for 3D game development. The engine has recently been made free of charge for commercial development. The makers only require a back link to their product website in your game now.

I find Alternativa3D quite attractive, in particular after seeing videos and screenshots of War.ru, an online multiplayer Role-playing game that reminds me of RPGs classics like Wizardry, just with better graphics. Unfortunately the whole game is in Russian only for now and so far I haven’t been able to log in, the load procedure is very slow and always gets stuck at some point for me.

Still the game looks very promising with some nice looking 3D environments. The actors (NPC’s and creatures) seem to be inanimate billboard sprites though so they only look impressive on a static screenshot but imagine what would be possible with the newly achieved 3D power! I’m looking forward to create vast 3D environments with autonomous actor AIs a’la Oblivion or Fallout 3! The only bottleneck will – yet again – be the content creation.

Either way, many classes have been updated and improved (and many still need too *ugh*) and what is particularly worth mentioning are the file IO classes which provide a unified way to work with different file formats. Basically the way how files work in hexagonlib is that you can create file objects of any specific file type (like text, binary, image, XML, etc.), give them a path to a physical file and then add them to a loader (BulkLoader, FileLoader, ZipLoader) which then loads the data of the physical files into the file objects.

While you can use the BulkLoader class to load a collection of arbitrary files in one go with all sorts of comfort (priorities, weighted loading, load retries, multi-connections etc.) the newest addition to the library is the ZipLoader class which can be used in AIR development to access a standard zip file using Random Access. What does that mean? It means that you can create a zip file (a very large one if you want), pack all your resource files that can be loaded by your application and then open it with your app and ‘load’ (= extract) files from it without ever needing to load the whole zip file completely into memory. This makes accessing a large zip file very efficient because only the chunk of the requested, zipped file is loaded.

This is especially interesting for us game developers who desire to use large, nicely packed resource files like they are utilized in a similar fashion in most current day commercial games. For a while I was promoting to add such functionality to AIR over at Adobe Labs but that was before I knew that this can actually be done in AIR since 1.0 thanks to the FileStream class and the position property of it (alas, the property is not available in the URLStream class so random access is not possible on web-based Flash). The ZipLoader uses asynchronous loading to open a zip file as well as ‘loading’ files from it because I don’t like the idea of having the application at the mercy of the file system which would be the case with synchronous access (and which is used in way too many examples on the web).

You can download the hexagonlib distribution over at Google Code, which includes the SWCs and documentation and of course the source code is available for access via SVN. I’m updating the library on a irregular basis. There are already some Wiki pages too with code examples showing how to use the BulkLoader and ZipLoader here but I will hopefully get to write some more in-depth tutorials soon.

hexagonlib at Google Code
File API Wiki
Documentaion

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/rpg-design-character-development-example/ http://blog.hexagonstar.com/rpg-design-character-development-example/#comments Thu, 19 Nov 2009 13:36:43 +0000 sascha http://blog.hexagonstar.com/?p=1067 Welcome back to the RPG Design series where I try to talk a bit about the work and progress on my game project, the development of the darkish, space -themed computer role-playing game Stellar Conspiracy: Entanglements Of The Marenis Sector (working title).

In the last part I’ve introduced the character design template I’m using and mentioned to post a character example next time which I’m doing hereby while introducing you to Eliza Retinienne, a Gessjanian security systems expert from the planet Shielle, a small world bordering on the fringe of the Suulun Sector which in turn stretches over a large area of the southern galaxy.

Eliza is one of the key characters in the game’s story and one of the characters whom the player is supposed to encounter and who eventually joins the player’s party. She is also supposed to receive her own side-quest in which the player can engage to help her out of the threatening situation she is currently in.

Note that this sheet is basically just here to give an example of how the character design template can be used to shape out a character so I suggest not to look too critically into the details. Things can (and will) still change and also the sheet is not filled out completely, for one reason because some details are irrelevant for this character and for another that I haven’t found any other suitable details for her yet. Either way I hope this gives a good example of how to utilize the template!

Full Name	Eliza Cathrine Retinienne
Nickname or short name	Eliza, sometimes called Cathy
Image
Character Type	Co-Protagonist
Gender	Female
Species	Gessjanian
Class	Security Systems Expert
Age	30
Summary	Eliza used to be a forefront engineer who worked for Seciate Armaments on a highly confidential Security Systems project. Later during the project she came to disagreements with Seciate about the target clients for the system she worked on. She left Seciate in a dispute, not accepting the bribe she has been offered to stay quiet. She had enough presence of mind to suspect that she would soon become the subject of an assassination attempt, in order to prevent her knowledge being of use to anyone else. Seciate however underestimated her smartness and she narrowly escaped while killing the assassin (rather unintentionally though). Since then she is on the run from SECIATE.
Biography

And back to the game design topic! The part I love most about game design is that you can create worlds full of life, intricacy, intrigue and interesting characters, experimenting with scenarios and situations (that would otherwise probably have negative  repercussions in RL™).

As a programmer you’d ever only write your code and if you are happy with it that’s fine but we one-man-game-developer types are more like Jack of all trades who want to create complete worlds … and stories. And then tell those stories by means of the game. And maybe throw a bit (or a large chunk) of dynamics in there again … as programmers.

One extremely satisfying aspect of game design (for games where narrative is important) is the development of characters that should act throughout the game. Creating characters is just as much fun as the other bases! If you do it right and create deep and sympathetic characters people will love them.

And even villains can be sympathetic. In fact they should be! Who likes an antagonist that is completely unsympathetic? Nobody, right? But why should you even like a villain, after all he’s the guy who needs to be defeated? The answer to this is that the guy who is the villain is so only in the context of our story. Maybe he’s not so bad after all in a different context. Or in short: Antagonists also have a life, feelings … but guess what? Now I totally digress! I actually wanted to show you my new and all fresh character template that I came up with to shape out characters for my game.

[ad#gog_arcanum_box]The template I’m introducing here is based on a template that is used by the two authors of  The Ultimate Guide to Video Game Writing and Design, a book I’ve recently purchased which I think is just slightly overrated on Amazon but still definitely worth it’s money. The two authors have the character building template fully laid out in their book for the purpose of their example but I’ve made modifications to it so that it suits the holy needs of my RPG design.

This character building template is quite extensive and there might be a few items that you want to throw out for your design or you’d want to add other questions appropriately. Also, as stated in the book by the authors, when designing a new character with this it’s not required to go through this in a linear way. Skip sections and fill them in later … like a puzzle. Likewise it’s not always necessary to fill out all the boxes. Some minor characters don’t need that level of detail.

It’s also worth to note that most of what you fill into this template is for your eyes (or for your teams eyes) only. So write away care-freely!  Only some of this information makes it into the game anyway however the whole additional info helps to give the character the amount of depth that is needed to make him/her an exceptionally outstanding character.

The template consists of several tables with rows of questions on the left column and the answers or details to fill in on the right side (in which for the purpose of explanation I’ve entered a description of the kind of text that goes in).

So without much further ado here’s my character building template used to help creating the story for my totally epic role-playing game (which *cough* should be in the shelves somewhere within the next millennium!). In the next post I will show an example of how the template is used with one of my (player party) co-protagonist characters … hopefully without revealing too much information about the game’s story.

Of course feel free to use it, change it, adapt it or come up with your own template! I’d love to hear about them! And always keep in mind: We’re not digging ditches or performing brain surgery here, we’re making games. Lighten up, for chrissakes. (That was an actual quote from the above mentioned book).

-

Appearance Information

-

Behavioral Information

-

Professional Information

-

Location Information

-

Background Information

-

Story-related Information

-

Dialog-related Information

-

Additional Information

-

Extra Information

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.