Log in

No account? Create an account
07 June 2007 @ 12:00 am
Technology and game design  
Code Base

Being a game played in third-person, Lobot would be able to utilise the core gaming engine of previous AIE projects such as Aporkalypse or Snak Vac. The main game loop, environment framework, player functionality and input system would likely need only minor adjustments.

Frame Rate

The design of the game means that the frame rate should be able to be kept consistently high.

The game is set inside a building, so visual distances will be limited, which keeps the LOD requirements to a minimum. The number of enemies onscreen at any given time is also very low, with it being rare for more than a couple to appear at once.

The game is single-player, so networking isn't an issue. The majority of the processing required for each frame will be graphics, physics, and AI.


Some simple animations will be done procedurally – for example, objects falling under gravity, particle effects like explosions and smoke, etc.  

The physics engine will also need to deal with collision detection and resolution.


The environment itself would have to be replaced entirely, as the setting is completely different from both of the previous years' games. Because the game is set inside a building, the assets required will generally be smaller-scale than those required for a large, outdoor space, although they will probably need to be more detailed. Fortunately, because the setting is a factory, a lot of assets will be able to be cloned or simply re-skinned – repetition and re-use of mechanical parts and units is expected.

Lobot, Belfry and the other robots will need to be completely new models.

Combat and AI

The combat mini-game would have to be coded from scratch. Code would need to be written to generate random configurations for each board with varying levels of difficulty, which may become quite complex. This is especially the case because the opposing player, ie, the robot Lobot is trying to deactivate, will be actively working against the player as they play. AI for other robots will also need to be written.

The most complicated AI required will be for Belfry. While it's fairly simple to have Belfry follow Lobot's explicit commands, Belfry will also need to take the initiative and act independently in certain scenes/locations, without causing himself potential danger, or the player undue annoyance. The steering required for Belfry to follow Lobot around will also be more complicated than general 'wandering', due to the hazardous environment and potential to get 'jammed'.


The camera setup from the previous games could probably be re-used, but the code will need to be expanded if it doesn't already include player control.


Because Lobot has a fairly linear sequence of goals, rather than being a free-for-all like Snak Vak or Aporkalypse, saving will be important. Players can customise and guide Lobot's development by choosing upgrades and collecting items, so it will be very important for Lobot's state to be persistent, which means frequent saving. It is also important for the environment's state to be saved, so that doors that have been unlocked stay unlocked, etc.

Saving will use a combination of two methods: save points, to write information to permanent memory; and checkpoint saves, which are stored in temporary memory. If the game is ended prematurely by Belfry's death, the game state will revert to what it was at the last checkpoint. If the game crashes, the game can be reloaded from the last save point. Checkpoint saves will be automatic, while hard drive saves will be at the player's discretion (but will be encouraged).

Save files will probably be written in a custom format developed for this particular game.

Breakdown of Tasks

The work will be broken into five main groups: code, graphics, level design, story and sound, with the first three groups being the largest. The code, graphics and level design teams will be further split into design and implementation groups. Initially, more people will be involved in design; as time goes on, most people will switch to implementation. A team leader will be chosen for each of the main teams. This is important to ensure consistency in code design, art style, etc. throughout the game.

The code team will be responsible for:

Code design
Extracting usable code from previous projects
Implementing new sections of code
Assembling the sections of code
Testing, bugfixing, and more testing

The graphics team will be responsible for:

Creating concept art
Creating assets
Extracting and modifying assets from previous games

The level design team will be responsible for:

Designing the environment
Designing level puzzles

The story team will be responsible for:

Developing the plot
Direction of any animated scenes

The sound team will be responsible for:

Recording or collecting sound effects
Recording any spoken dialogue

As evidenced above, all team members will be involved in testing and bugfinding the game, once it is in a playable state.