Ok... Today I read one of the most sucky articles on game tools ever. Of course it was made by a game industry veteran and published over at gamasutra. I won't link it since it was the suck! The example the author used even involved void pointers being cast to correct internal data structures... omg and these people call themselves professionals!

There are essentially three important things in game tool development:

Integrated Editor

For efficient real time editing the editor must be integrated into your game. This way you can easily switch to an editor when you spot something that is off. You also only have one code base to maintain and it will be true wysiwyg. Another advantage is that the game and editor loads and use the same data files and formats, this also means that if your game changes your compiler will help you since the code will not compile.

The other two points actually are just help to realize this requirement.

Model - View - Controller

The basic architecture of any game should be based on the model view controller patterns. This pattern will help you separate your actual game (rules, ai, whatnot) from your graphics rendering. There are some various flavors and implementation details that is much up to your own taste in things. I use an "it's free to read but writes are formalized via an interface" approach. This basically means that the views use a const reference to the model and get to read public data directly.

Basically your editor is a specialized view for, you guessed it, editing some aspect of your game.

The Model - View - Controller pattern is explained in various books and of course online.

IMGUI

Immediate mode GUI or IMGUI is simply the best way to realize a gui in a real time application. There are excellent imgui articles out there so I will not go into details. Basically imgui is the opposite to a big, bloated, object oriented gui framework where everything inherits from a "window" class.

And yes, you can do drag 'n drop, windows, sliders and all that gui fanciness with imgui.

A good starting point for imgui knowledge

Thats it! If you stick to these points your game editors will be next best thing to sliced bread, and you can focus on making your game!

I have spent the last few weeks using and learning test driven development.

Test driven development means you write a test for your code before you write the actual code. At first it seems like you do more work, but you really gain time from it.

• You spend more time thinking on how a function/class should work before you write it. If you write the test first and the function prototypes (empty functions) so the test fails, you know when you are done (because the test succeeds)
• You can run the tests directly after compiling the code when you make some changes, this gives you confidence that your code works!
• When you find bugs you first try to reproduce them inside the test, and then you correct them inside the code -> Less chance you will run into that bug ever again.
• When you are forced to write tests your code will be easier to test automatically since you write the code for testing.
• It is fun to fulfill tests, it feels good!
• Less manual testing, many manual testcases can be automated, i have rewritten some of my user interface code so it can be automatically tested.
• You get example code for how to use the class

Summer is ending, and to start things off here comes the third best practice of software engieering, as always with a game development point of view. I will try to get the rest of the article out there at a somewhat higher pace now I hope

Manage Requirements

Many projects fail simply because the system solves the wrong problem, when the software is finally delivered it fails to provide any benefit to the customer. Requirements need to be collected, analyzed, documented, tracked and organized. This is a fundament of any organization wishing to deliver on time and within budget. Good requirements should be a major driving force behind the project. Requirements need to be handled with care and respect. Failing to do this means almost certain project failure, even if all other practices are observed and practiced.

In game development the requirements come from the game designer, traditionally described in a big bible called the "game design document". This is the same as the "grocery lists" of old time software development and will almost certainly not produce a fun game. The "fun-ness" of a game is something that is very hard to nail down completely on a piece of paper, you simply need a working game to be able to evaluate, iterate and refine the requirements.

Ok... I have finaly got around to posting the second part of the Software Engineering Best Practices in Game Development. This part focuses on maybe the most important part of modern sofware development; developing iteratively.

Browsing through our respository I found an unpublished article that I and Johno wrote a while back. We never got around to publishing which is a pity since we worked quite a bit on it. So to cut things short, I'll publish it part by part in my blog.

This is the first introductory part, so look out for the others coming soon. Feel free to comment.

Software Engineering Best Practices in Game Development

Introduction

This article describes and elaborates five best practices of software engineering in the context of game development. These practices are; iterative development, manage requirements, manage change, verify quality and visual modeling. We urge game developers to realize that many of the software problems commonly encountered in game development have already been encountered and solved in traditional software development organizations. The article is intended as an inspirational starting point for applying best practices in your own projects.

Best Practices of Software Engineering

Software development is plagued with many serious problems. Complexity is increasing, time to market is decreasing and quality requirements are skyrocketing. This puts great strains on the software developing organization and the people therein. It is no longer possible to work harder; we must work smarter. Best practices of software engineering are commonly observed, commercially proven approaches to successful software development. Developers that wish to compete on the bleeding edge of software technology should adapt these practices to the specifics of their own organization.

Game Development

The most complex part of any computer game is the software behind it. The software needs to incorporate game play mechanics, artificial intelligence algorithms, network protocols, real-time physics simulations, decompression and playback of music, filtering and mixing of sounds, 3d visualization and more. In addition to all of this, multiple platforms must often be supported. The software must also be packaged with huge amounts of data in the form of textures, models, animations, sounds, scripts etc. to create something fun and entertaining, an elusive mix of technology and art.

Considering all of this, it is not surprising that many games are released with poor quality, often requiring fixes in the form of software and / or content patches from day one. All of these complexities cause games to exceed their budgets and miss time to market by not days, but months and years. As a result, many game developers are fighting a losing battle to survive. We maintain that a large number of these problems are the very same problems “traditional” software developers have faced and conquered by implementing best practices in their organizations.

About the authors

Tobias Olsson is a lecturer at the University of Kalmar, where he teaches courses in software engineering, real-time graphics, real-time physics and game development projects. He also runs his own company, Spell Of Play Studios, focusing on computer games and development processes.

Johannes Norneby is a is a programmer at MindArk PE AB in Gothenburg, developers of Entropia Universe a MMORPG. Johannes has also held tech director positions at DICE and Massive Entertainment.

References

Alan MacCormack "Product-Development Practices That Work: How Internet Companies Build Software", MIT Sloan Management Review, Winter 2001, Volume 42, Number 2

Extreme Programming: A gentle introduction. www.extremeprogramming.org

Manifesto for Agile Software Development, www.agilemanifesto.org

Martin Fowler, www.martinfowler.com

Yoopeedoo, www.yoopeedoo.org

UML Resource Page, www.uml.org

Continued in: Iterative Development