Main Site Links Resources Tutorials
News VB Gaming Code Downloads DirectX 7
Contact Webmaster VB Programming Product Reviews DirectX 8
  General Multimedia Articles DirectX 9

Infinite Game Universe: Level Design, Terrain, and Sound
Author: Guy W. Lecky-Thompson
Publisher: Charles River Media
ISBN: 1-58450-213-4
Purchasing: [Amazon.Com] - RRP US$49.95
Reviewed: 10th September 2002

Front Cover Shot:


This book follows on in the foot-steps of 'Infinite Game Universe: Mathematical Techniques' (reviewed here), and is basically a continuation of the trends set out previously. Whereas the previous book was fairly generalized in it's study of random numbers, probability etc... this book focuses a bit closer on three areas most people will be more familiar with.

An interesting was of looking at old tricks

This book is still primarily concerned with an 'infinite game universe' - the use of mathematics and algorithms to create a rich gaming world that's not necessarily constructed by the game designers before-hand.

There are several very good books on the more 'classic' forms of game programming, the Game Programming Gems series (which the author has featured in) for example. These books and tutorials focus on what everyone may consider 'normal' - sound programming for example: load a sound in memory, play the sound back to the user, maybe add some volume/panning and possibly 3D positioning. This book goes beneath this - what is the wave-form behind the sound and what can we as programmers do with it.

In some respects it's taking a bit of an 'old-skool' approach to game programming - the advent of high-level API's such as DirectX has removed some of the need to bother with the finer-points of technology and their associated algorithms/mathematics. As this book shows, in some cases it is also beneficial to remember the skills game programmers used in the past as they can still produce interesting results.

Level Design
This almost comes across as being slightly odd - the idea of the previous book (and a theme still in this book) was to create an entire, believable, world from very little data. More about creating the building-blocks for the 'level' (and let math handle the rest) rather than build it in a traditional style.

That considered, its an interesting chapter if a little old - it spends quite a bit of time with platform games as the main example. Whilst I wouldn't be able to say that this genre is 'dead' it has been a long time since a large (and well known) game has hit the shelves for any of the major game systems (GB/GBA excluded). The discussion can still be carried over to other genre's, but it's not as obvious.

The overriding feeling having read this section of the book is that it misses out on a lot of up-to-date material. If I were to take a quick poll of game developers it would be far more likely to find high usage of complex compression algorithms and various forms of tree's for data storage as well as graphical presentation.

The coverage of terrain is one of the longer parts of the book, yet it covers only a small portion of the terrain rendering field. This is to be expected; in recent years terrain generation and representation has advanced considerably - it could quite easily justify it's own book. What we get in this book is almost entirely regarding the generation of terrain.

However, in tune with the previous volume and the general idea of the series I feel it misses a couple of points - mathematics for an infinite universe and the general ideas discussed throughout this book aren't put to their full potential. Simple things such as procedural texture creation (both for land, plants and skies) and real-time terrain generation (that fits in with visibility algorithms).

Regardless of this, the content is of a high quality - the standard fault line and mid-point displacement methods are covered, as well as various methods of smoothing. It's not directly mentioned, but you can use the information found in other chapters on data representation and stored to optimize the way that terrain geometry is stored (it's often a logistical nightmare).

Of all the chapters covered so far in this review, the sound/music chapter is by far the best. This is because it has the most to say, and is the most relevant to modern hardware (as mentioned, other chapters neglect modern hardware in some respects).

The area's covered in this section vary from standard to academic level research. Sound synthesis (particularly voice replication/analysis) and 'natural language recognition' are hot-topics for academics the world-over. The author has done a great job of bringing these down to the level of mere mortals. The practical aspect (as in case-studies and usable source code) gets a little thin on the ground in some places, but that is a minor fault in an otherwise intelligent and well thought out chapter.

Data storage and resource management
The author acknowledges at the start of this section, very wisely, that 'not everyone owns the sun...'. Second to run-time performance, it is of utmost importance to game developers to ensure that the underlying resources and general logistics are kept in line. In modern games textures, sounds, music and just general data files can get very large very quickly. This chapter addresses this, and adds a new spin to the ball - the handheld and console market. It is common (now) to find a PC with 128mb system memory and a 16mb graphics card, and not too hard to find a PC with 512mb memory and 128mb graphics memory - but even the XBox (currently 'top dog' for technology) only has 64mb shared memory.

This section of the book has lots of really interesting and really useful information regarding the consoles and hand-helds available at the time of writing (it's around a year old and still accurate). This information does make for interesting reading - hardware such as a the Gameboy are perfect case studies of limited processor and memory environments.

The lessons learnt in this section won't necessarily be important to a standard PC developer used to having 128mb of RAM 'lying' around, but it could provide an interesting new approach - some of the ideas presented that are essential on hand-helds could prove useful when applied to PC's.

In Conclusion
The writing style is similar to that of the first volume - generally good. However this volume benefits from being a bit more applied, many more of the concepts and chapters presented in this book are likely to match up with situations and problems most game developers will have stumbled across at one point in their lifetime.

It would probably be best if you owned both volumes (I'm sure the publisher and author would like this), but it isn't necessary, and if I were forced to choose one - it would be this second volume.


Good Things Bad Things
Improves on the previous volume Full appreciation of this volume would require that you've read the first.
Many more separate parts to this book - its likely you'll find something to your fancy. Misses out on some really good juicy material.
Provides a different way of looking at some problems. Uses some old technologies not entirely relevant in modern games.
Reasonably good CD included.  
Excellent sound/audio section  
Brings some traditionally academic level work down to a usable level.  
Good writing style.  
Not specific to any API or operating system.  


DirectX 4 VB 2000 Jack Hoxley. All rights reserved.
Reproduction of this site and it's contents, in whole or in part, is prohibited,
except where explicitly stated otherwise.
Design by Mateo
Contact Webmaster