It's free to join Gamasutra!|Have a question? Want to know who runs this site? Here you go.|Targeting the game development market with your product or service? Get info on advertising here.||For altering your contact information or changing email subscription preferences.
Registered members can log in here.Back to the home page.

Search articles, jobs, buyers guide, and more.

By Wayne Imlach
Gamasutra
[Author's Bio]
October 26, 2001

Introduction

What Went Wrong

What Went Right

Printer Friendly Version
 

 

Letters to the Editor:
Write a letter
View all letters


Features

Postmortem: Startopia

What Went Right

1. Design. The design of the game systems (object interactions, peep attributes, interface, level structure etc.) was done in a few months, and hardly changed at all during the development cycle. The only changes were the removal of a few game elements near the end of the project due to scheduling restrictions, which had no impact on the fundamental way the game played. This required a lot of faith from the team in the ability of the game designer to get it right the first time, as the game could not be realistically prototyped or tested for playability or balance until a vast majority of the elements had been coded and were in place. This trust in the designer's ideas and systems working as written wasn't blind. A past history of successful games did much to strengthen the belief that Startopia's design was an accurate blueprint for a fun and enjoyable game. This highlights the importance of a strong credible design blueprint at the early stage of game development.

The benefit of this was one of economy — with a stable design that changed little during the development period, very little work needed to be scrapped or rewritten due to unexpected design changes. This was one of the main reasons why such a small team could put together a large game like Startopia within a reasonable development period (the other being sheer hard work from all involved!).

2. Scripting and Tweaks. A flexible yet simple scripting language was developed to build the missions that appear in Startopia. Stored in a simple text format, it allowed quick and easy editing of each mission without the need for any special tools. Missions could be updated on the fly, and required no extra compiling or processing before they could be tested. If a specific action was required in a mission, and it couldn't be adequately described with the current script commands, it was a straightforward task for a programmer to update the scripting language with a new command and provide support for the action in the game with no disruption to existing scripts.

A flexible yet simple scripting language was developed to build the missions that appear in Startopia.

In addition, this simplicity made the game ideal for the modding community to build their own custom scenarios that could be easily slotted into the existing game, and distributed as just a set of small text files.

The same system was applied to the values that determine the balance, and in some cases, look and sound of the game. Referred to as "tweaks", as well as being adjusted from within the game, they were also stored in a text file that was loaded at the beginning of a session. Their simple text-based format meant that adjustments to game balance could be made, then saved out and distributed to game testers with a minimum of fuss. Then adjustments could be made on individual machines to see the overall effect on the game. The tweaks were also used to enable or disable a number of audio and visual settings, and proved invaluable in adjusting various parameters of 3D models, animation settings, and object behaviour without having to delve into code. Wherever possible, any values within the code that might need some adjustment or "tweaking" to get right were included in this text file.

3. Compatibility. Compatibility is incredibly important to reach the widest possible audience. It's hard enough making people want to buy your game without sneering at them because they have an obscure and/or old graphics card. Our solution was composed of three parts:

• Scalability: Make sure all game effects can be scaled down to work on even the simplest graphics card. The effect need not be quite as pretty on the lower-end cards, but it must actually exist and not look completely terrible. Alternatively, some special effects that are not vital to the game play can simply be turned off.

Each single game effect (e.g. "draw with a disease texture added on top") has multiple versions of the effect done with different methods. At the start of day, the game starts from the more fancy version, and tries to get that working on the current graphics card. If it can't, it tries the next one, which is a slightly simpler version, and will be either slower, more ugly, or both. And so on down the list. The last version in the list is the one that is guaranteed to work on every card. In this way the game automatically uses the prettiest and fastest effect that works on this card.

• Diagnostic dumps: Whenever the game is started, it dumps a whole load of diagnostics out to a text file. This includes any hardware information we could even dream was relevant — graphics card ID, capabilities, memory, driver versions, OS versions, which blends were used, which didn't work, etc. The idea was that if a user had a problem, instead of asking them questions about their system (most users do not know what is inside the box, or have faulty and incomplete knowledge), we just had to ask them to send us the file — we called it something friendly such as "your gfxcard.txt".

It could also present some of the more obvious problems. For example, all the user knows is that the game is slow and crashes a lot — an incredibly vague problem to track down. Looking at the diagnostics, if the card reports having 0MB of AGP memory, we can fairly reliably diagnose old motherboard drivers.

• Detecting cards: In theory, DirectX has a very powerful and elegant mechanism, called ValidateDevice(), to detect which of the blends and effects will work on a particular graphics card. However, this relies on the video card's driver being bug-free and well written. In practice, this is rare. So you get video cards claiming to do blend modes that either (a) the driver doesn't understand, and gives a random answer, (b) won't work on that hardware, though the driver claims it will or (c) would work on the hardware, except the driver is buggy. The only way to detect these cases is to sit a tester down and try playing the game with every video card in the building.

This is fairly easy to do, though it does take the testers time to go through all the different cards. The tricky bit is to detect what card is in the machine. You can't just ask the card for its name and look for the word "Voodoo" in it — that never works reliably. The only reliable way, is to retrieve a number identifying the card and the maker, called the DeviceID. Then we have a huge text file listing each DeviceID we know, followed by the list of fix-ups that need to be applied to get that card running correctly. The file was named CardID.tom — it is just a text file, but the bogus .tom extension stops inquisitive people fiddling with it and breaking stuff.

In some cases, we also found that although newer drivers did some effects correctly, older drivers did not (due to bugs or whatever). So as well as DeviceID, we also had subsections for a range of driver numbers. So if we had a problem with an earlier driver, but we had a later driver (e.g. version 1234) that did the effect correctly, we could say that driver versions 0 to 1233 disabled the effect, whereas drivers 1234 to infinity enabled the effect. This meant that we could do the fanciest blends on cards that we could without getting nasty bugs on systems where the drivers had not been updated for ages (in practice this is most systems!).

The system in action: OK, so we've shipped the game, and someone emails us with a problem. One example was "some of the game objects keep flashing green and black blobs". This we diagnose as an effect known as "impostors" failing — a known problem with a wide variety of cards. Because the system is designed with scalability, we can disable them if they don't work, and use an alternative method. This alternative may not be quite as pretty, and may not be quite as fast, but it is guaranteed to work on all cards. So we ask the user for the "your gfxcard.txt" file, and from that find out what card and driver version they are using. We update the CardID.tom file with the data that "impostoring" should be disabled on this card with these drivers (and usually all previous drivers as well), post the new CardID.tom file to the user, and check that it works for them. Then we post the updated CardID.tom file on our website. In this way, the very first thing we recommend to people is to download this new text file — it's like a patch, but it's only about 50k in size! And it's easy to keep it incredibly up to date, since changes to the file are only enabling/disabling stuff that testers have already checked, so it doesn't need much re-testing.

4. VAL/ARONA Characterization. When developing the advisor character (VAL) for the game, we took the unusual step of basing the character around our ideal voice actor, rather than deciding on a character type and searching for a voice to match. We listened to a series of example voice actors using a variety of accents, listening for one that we thought would match our perceived image of the game.

The casting of William Franklin as both the voice of VAL the computer advisor and Arona the trader was a great step in enhancing the humour and tone of the game. Once we had chosen him and confirmed his participation, we began writing our scripts specifically with his voice in mind (which reminded us of the archetypal condescending British butler). In some respects VAL isn't played by William Franklin — VAL is in fact based on William himself!

A distinguished and very professional actor, Will took our scripts and brought them to life in a way even we didn't expect, making VAL, and eventually Arona (with the help of some digital manipulation) seem like flesh and blood beings rather than software-run scripts.

The casting of William Franklin as both the voice of VAL the computer advisor and Arona the trader was a great step in enhancing the humour and tone of the game.

The professionalism of Will allowed us to record all the material used in the game over two day-long sessions, which were set a few weeks apart to allow us to review the scripts and add or update them as required. Where the script seemed a bit vague or perhaps contained grammatical errors, Will would record alternatives for us to use, often producing a better flowing sentence or paragraph structure than the original material. He could also read the scripts cold yet produce a perfect recording on the first take, which is one of the main reasons we managed to record so much material in a relatively short period of time. This kept costs down, which was a bonus considering the premium you pay for quality voice actors (a premium definitely worth paying I may add!).

5. The Team. Probably one of the most important aspects of the game development, and the one most often overlooked by publishers and public, was the commitment and stability of the Startopia development team. While the team began with only four members, and finally grew to 15 full time staff, it never lost any of it's number due to the usual industry pressures. This resulted in a strong bonding and level of understanding among the team of how each member worked and thought, allowing a high degree of informal decision making and sharing of tasks with little or no reliance on management to approve actions. Indeed, there was none of the usual slew of managers when it came to Startopia — if there was a particularly thorny executive decision to be made, then the team Lead programmer or Artist could make the call, handily also being two of the four company directors. Even the concept of a 'producer' was somewhat alien to us, the position being provided on a part-time basis by our publisher.

This was further strengthened by our relative small size and overall experience in the industry; with so few programmers and artists, communication among team members was maintained with little disruption to the schedule. People could literally turn from their desks and discuss a proposal with all the necessary people without having to leave their seats. At the worst it might require taking a few steps through a door if the art team needed to confer with programming over a subject. The experience and professionalism of the team also kept conflict to a minimum — trusting the judgement of the team member responsible for any particular section of the game, even if it might be contrary to personal feeling.

Conclusions

Overall, despite it's flaws, Startopia is probably the game that members of the team are most proud of working on. It looks great, sounds fantastic, and is eminently playable, even among the developers who worked on the game for so long. It has garnered many great reviews in the press and on the 'net, and has been nominated for a BAFTA award in the UK.

Despite this, the game has unfortunately failed to be as financial a success as we had hoped. While we understood that the muted marketing that the game received would mean a slow uptake, we had hoped that it's qualities, as a good game would help it achieve a respectable number of sales after it's release. We wont be making the same mistake next time. Our next project will not only aim to be better than Startopia, we'll also ensure that every man and his dog knows it!


Startopia

Game Data Publisher: Eidos Interactive

Number of Full-Time Developers: Core Team — 6 programmers, 4 artists, 3 testers, 1 designer, 1 musician (Support Resources — 2 programmers, 2 artists)

Number of Contractors: 1 scriptwriter, 1 voice actor

Estimated Budget: £2 million ($3million)

Length of Development: 2 years

Release Date: June 2001

Platforms: Windows 98

Development Hardware (Average): PIII 550,128mb, 20GB HD, Win 98/Win 2000/Win NT, Various 3D accelerator cards, Various sound cards

Development Software: WordPad, MS VisualC++, SourceSafe, Photoshop, Paintshop Pro, 3DS Max, paper, pencils and pens

Notable Technologies: Direct X, Bink, Peer Engine

Project Size: 335000 Lines of Code, 33000 Words of In-game Text, 125 MB of Graphics and Models, 151 MB, of Compressed Sound Effects, 48 Minutes of Game Music


______________________________________________________

[Back To] Introduction


join | contact us | advertise | write | my profile
news | features | companies | jobs | resumes | education | product guide | projects | store



Copyright © 2003 CMP Media LLC

privacy policy
| terms of service