Slashdot Mirror

zalas writes "Stanford's computer graphics class holds a video game writing competition each year at the end of the term, and this year's results are finally online. You can download all the finalist entries from the website. The winning entries featured very original game concepts, such as sending a spiked soccer ball through wormhole planets or infesting a growing maze of cheese with mold. Judges at the competition included representatives from Electronic Arts, Microsoft and the creator of Pong, Allan Alcorn. Ironically enough, the winners of the wacky category who received a voucher for an XBOX360 wrote a game that only worked on OSX laptops with the drop-protection motion sensors."

roadies writes "One-upping the AM3/Nintendo official GBA flash player (as previously discussed), Portagame reports that the 3rd party imported GBA Movie Player has released its second version. In a slimmer profile casing, it still plays movies and music from CF cards. (Not pre-recorded tv shows like the AM3 player either, you record and save your own content.) The best feature of the firmware update: An included NES emulater. You can download your favorite NES games to a CF card and emulate them through the player. Only catch is there is a 192K per game limit. May not be enough for the biggest NES game, but still enough for the true NES classics."

Thanks to an anonymous reader for communicating that the Famicompo Nintendo NES music competition is underway. The entry period lasts until the 15th June, and recommended composition tools include the Nerdtracker II 'tracker' for DOS, or even the text-based MCK system. This is pretty arcane but interesting stuff - to check out some more recent NES music (in .NSF format), try The Sounds Of 2A03 page and a player like Festalon.

Thanks to an anonymous reader for communicating that the Famicompo Nintendo NES music competition is underway. The entry period lasts until the 15th June, and recommended composition tools include the Nerdtracker II 'tracker' for DOS, or even the text-based MCK system. This is pretty arcane but interesting stuff - to check out some more recent NES music (in .NSF format), try The Sounds Of 2A03 page and a player like Festalon.

Richard Jones writes: "In my opinion, the most difficult aspect of writing a good 3D game is coding complex physics. If you can take away all the flashy graphics, texture maps, light and shadows from a game, and it's still at least 75% as playable and addictive, then you have an excellent game. But too many programmers seem to be ready to concentrate on the graphics, neglecting the underlying physics which make the game playable. If you compare, say, Re-volt with its fabulously detailed models of remote-controlled cars, and Carmageddon which on the N64 at least has sucky physics, well I know which one I'm still playing." He's contributed his review (below) of a book intended to help game programmers make games that aren't sucky. Physics For Game Developers author David M. Bourg pages 326 publisher O'Reilly rating 8 reviewer Richard Jones ISBN 0-596-00006-5 summary A good introduction to the difficult subject of writing 3D games and simulations with accurate physics, let down by a few minor snags.

Programmers who want to get serious about game physics will love David M. Bourg's Physics for Game Developers. As I've said, the subject is inherently very difficult, and the book assumes that you are already familiar with vector and matrix arithmetic up to college level, integration and differentiation, and at least you hazily recall your mechanics/physics lessons from school. You also won't be afraid to wade through Bourg's carefully documented derivations of formulae for various physical effects, and his well-commented source code.

The book starts off by recapping the basic concepts of mass, centre of gravity, moment of inertia and inertia tensors. Bourg assumes that you have a working grasp of these subjects, and I admit that I had to go back to some of my A-level mechanics text books. He then goes straight into kinematics, where he uses standard (but forgotten!) integration techniques to calculate velocities from accelerations and positions from velocities. His examples are excellent, although a few exercises wouldn't have gone amiss. The chapter on forces covers a great many different types of forces such as springs and buoyancy, but curiously omits the important subject of contact forces (the normal force that a table, for instance, exerts on your computer monitor to stop it falling through the floor). In fact contact forces don't appear until much later in the book. Particles, rigid bodies and impulses (forces from collisions) are introduced in chapters 4 and 5.

At this point I have to say I was a little bit confused. What did this have to do with game programming? Everyone knows that games spend most of their time running round a single big "main loop," working out the forces on each object, looking for collisions and working out which keys the user is pressing. It doesn't seem imaginable that a game programmer could completely solve all the equations of motion by pure integration at the beginning of the game, and then just run the positions of the players through the graphics engine like a movie!

I already knew a little about this from what I'd found from the web, but what most games actually do is calculate all the forces on all the objects (players, scenery, etc.) in the game, and then integrate them at each step. Some of these forces will be generated by human players pressing keys on the keyboard or wiggling the joystick, and that's how the objects end up moving. Pure integration isn't usually possible, so the physics engine performs numerical integration - a kind of fast approximation to the pure "closed form" solution. Numerical integration is itself a tricky subject, but it's the meat-and-veg of good game programming. Surprisingly, numerical integration and a realistic main loop doesn't appear until chapter 11 (172 pages into the book). I skipped straight to this section, and I suggest you do so too...

The chapter on numerical integration is excellent and contains the first realistic gaming (or at least simulation) code. Many games I've examined use simple numerical integration, like this:

// At each step ... A = acceleration, dt = time step
Vx += Ax * dt;
Vy += Ay * dt;
Sx += Vx * dt;
Sy += Vy * dt;

Unfortunately this method (Euler's method) is very inaccurate and unstable: if you tried to simulate planets orbiting around a sun using this method, they'd soon fly off into outer space unrealistically. Bourg gives an excellent introduction to better methods such as the "improved Euler" method and the popular Runge-Kutta method, and he covers them in a context which will make it clear how to use these methods in your own programs.

The book reaches a crescendo with three fully developed simulations: two hovercraft which you can drive around and jolt into each other like bumper cars -- they spin around realistically; a flight simulator; and a 3D car which can be crashed into blocks that bounce around. Again the source code is meticulously commented and generally well written. My only two reservations about the code are: It would be nice if Bourg had chosen to use OpenGL instead of Direct3D so that those of us without regular access to Windows could actually compile and run the examples. The book would make an ideal companion to the OpenGL Red Book. And coming firmly from the Windows camp, Bourg's examples are full of all the horrors of Win32 APIs and Hungarian Notation. But maybe that's just my personal preference :-)

So in summary: The Bad Points:

• Measurement systems: Bourg moves uneasily between the English/US system and the European SI units. So we get examples which combine ft/s, meters, slugs and kilograms, uneasily converting between the two. He should have chosen one system and stuck with it.
• A common complaint about computer books: I've just spent 25 quid on a book which will sit open on my desk for months. Is it too much to ask that it be ring bound?
• Some subjects are not explained in enough depth. Particularly: moments, contact forces, impulse methods. Bourg should probably have written a chapter or three on collision detection.
• The chapters are presented in a very strange order. Move chapters 6-10 until later, or introduce numerical integration earlier.
• A few of the illustrations are inaccurate.

and The Good Points:

• Considerably better than the usual round of maths/physics text books which make up this field. In fact, this is really one of only about 2 or 3 significant books in this area which are pitched for game developers as opposed to mathematicians, and it's certainly the best.
• The areas which are covered are done well, in significant depth, with a good bibliography where you can find out more.
• The commentary on the difficult equations is good, and Bourg resists the temptation to derive many of the formulae he presents, instead referring interested readers to other references.
• Code is well documented and explained.

And now I suppose I have no excuse not to resurrect XRacer :-)

You can purchase Physics for Game Developers at Fatbrain