Customer Reviews

Game Coding Complete

5 star:		(10)
4 star:		(4)
3 star:		(2)
2 star:		(2)
1 star:		(1)

 

 

The first thing I'll say about the book is that it is extremely genuine, everything from the stories to the source code has seen action in the computer game industry, on games that really shipped. Since this was the main motivation for writing the dang thing, I hope everyone enjoys what they read, and perhaps learns something at the same time.

Chapter 1, Game Programming is Wacky starts the book off really well, distinguishing game programming from any other kind of programming. The rest of Part I is a gentle introduction into the high level decisions a programmer has to make before they write their first line of code.

Part II is my favorite part of the book because no other game programming book I've ever read, and I've read a few, exposes important topics like multiprocessing, resource caching, or why the stock ANSI random number generator isn't your best choice.

Part III continues this trend, digging into architectural topics such as 3D worlds and logistical topics like debugging games. Most game programming books show you how to write code, this is the first one (that I know of) that shows programmers how to fix it when it is broken. The section on special considerations for Windows games is especially useful for any Windows programmer who writes games or real time simulations.

Part IV takes a break from programming and discusses some production topics like scheduling and testing. Programmers who know this stuff will always finish their work on time and enjoy their weekends away from the keyboard.

Enough niceties - here's some harsh commentary from the author about the author.

First and foremost, the source code in the book is completely broken and disorganized. If someone spent the hours of typing necessary to write each line of code into a single compiling project they'd be rewarded with hundreds of compiler and linker errors.

Thank heavens for the web site, and the ability to download code that actually works.

Next, there are some serious omissions in this book.

Game audio is an important subject, and tends to be ignored until the last minute in most games. There should be a chapter that discusses DirectSound, Miles Audio, and how to synchronize sounds and animations. Character speech would be a good topic to add as well. The fact that the debugging chapter makes such a big deal of audio bugs makes this missing chapter even more apparent.

Game physics and collision is also totally missing, except for a brief mention of Havok in the 3D engines chapter. Physics and collision are critical to every game project, even something as simple as breakout. The author should be drawn and quartered for this omission.

Finally, there's absolutely no mention of networking and multiplayer game technolgy. The fact that the author has worked on some of the most famous (or notorious) multiplayer and massively multiplayer games makes this omission even more bizarre. Any book from Mr.Mike should have addressed playing games over the internet.

Enough complaints - here are some excuses:

First, the book was supposed to be no more than 550 pages. You'll notice that the book weighs in at more than 580. What you don't know is how many chapters were cut completely, or cut for length. The user interface chapter could have been twice as long, continuing the discussion with implementing various kinds of controls for games. There were plans for a physics chapter, and a networking chapter - they were cut because the book was running long and the deadline was nigh.

My only solace is that some game programming books are 800+ pages long, and say a lot less than you could have found in the DirectX help. If this book does well, I promise to include more info on audio, collision, physics, and networking in the next revision.

All said, I'm very happy with this book - even some of my beta readers told me they learned things when they read the first drafts. If you learn something too, then I can feel satisfied.

One last comment - the cover rocks. Thanks, Paul!

Ideally, I would like to give this book a better rating because it is written by a professional. So many of the currently available books on game programming are written by high-school kids who have goofed with the DirectX samples and think they can write a game. Their "hey, dude!" language gets really annoying (yeah, I'm talking to you LaMothe) and the sheer ignorance of their programming style usually makes their books useless.

Unfortunately Mr. McShaffry fell into the same pitfall most other "here's THE right way to write code" authors fall into: he just has too many opinions and not enough facts. He touches on a lot of subjects which are programming religions, and there is no objective right or wrong for much of what he discusses. I feel some of the problem lies in the fact that McShaffry has worked on two types of games: the Ultima series and a playing card game. If you work on one codebase for years, you're going to think your solutions are perfect. As a person who has worked on numerous different types of games and engines I can tell you that there is no magic solution for writing the perfect engine. The engine is always very heavily tailored to the game desired. This is why you hear about the Quake engine, or some other third-party technology, being licensed and then gutted with major portions rewritten. So most of McShaffry's game-specific ideas need to be taken with a grain of salt. An example: smart pointers sure are safe, but if you're working on the PS2 you probably can't spare the memory or execution time for all that tracking.

I also disagree with his opening statements about variable and function naming. This is a constant headache for development teams, particularly game dev teams whose programmers are mostly self-taught. But just saying "Hungarian is useless!" is ridiculous. Sure Visual Studio tells you the type of variable, but this works maybe half the time (it is incredibly easy to confuse Microsoft's Intellitype), and not everyone uses VS. If a person is more comfortable in Emacs, should they be forced to change editors just to get context information on a variable? Is one to three letters of information in front of a variable name really that hard to type?

Those are just a couple of examples for the sake of brevity. My main objection about this book is that I don't feel I learned anything by reading it. I just read Mr. McShaffry's opinions about a few things, some of which had merit, but most of which weren't supported by any factual or reasonable data. They are just opinions. I did agree with his statement that all objects should have a stream-constructor defined; having tried to graft in "save anywhere" to two engines I can attest to the usefulness of this type of planning ahead. But other than that the book is mostly useless to me.

People new to the industry or curious about it might find it exciting to read tales from the trenches. And if you're a pro, I would expect your enthusiasm for the book to be directly relative to how closely your opinions match Mr. McShaffry's. But frankly I wouldn't recommend most of his ideas over anyone else's. Maybe it's the title that grates on me - perhaps a better title would have been "Game Coding: One Man's Opinion"

Quite frankly, this book kept me going in game programming when I was about to give up in frustration.

I've bought many game programming books over the years, and two authors stand out... Mike McShaffry and Andre LaMothe. This book is incredibly valuable as a reference and as a guide. Quite honestly, I wonder who paid the guy who wrote the "Spotlight Review" to dis it so badly, or who he paid to get his opinion in the spotlight.

But here's a test you can take for yourself... go to http://www.mcshaffry.com/GameCode and see how Mike McShaffry is *still* helping folks who've read his book, (or anyone who post on the site for that matter). He's still giving *free* advice on his book's forum, when most other authors won't even respond to an email.

In response to those who objected to the author's "coding opinions":
Yes, the guy has an opinon - he's entitled to. What do you expect from a book? "well, this is probably wrong, and I don't really know what I'm talking about, but the publisher paid me a lot of money so I have to say something." Give me a freaking break! OF COURSE the book is full of opinions - that's what books are!

Just one caveat - it doesn't teach you C++. It assumes some experience, meaning you can take the coding advice and apply it to suit your own style. It does assume a basic level of professional ability in other words.

I say Incomplete because there is still a lot that could have been covered in a book called Game Coding Complete. At the same time I would not have picked it up off of the shelf if it didn't have such a catchy title, and learn as much about Game Coding as I did reading this book. Even though I think the title is incomplete, I still learned a great deal and I frequently reread chapters to catch things I missed the first time round.

IMHO this book is geared toward those who want to make a professional career in making games, but have no idea how, while at the same time teaching concrete principles of game programming to those like me who are currently hobby coders. Many times had I tried and failed to start developing a game, but I am now building my game intelligently and efficiently, knowing exactly what I need to do to get things done. I have to say it is all because of this book.
This is also one of the few books that has managed to grip my attention for as long as it did because of the clever way that Mike writes. His writing style is such that it is easy to read because of its almost informal nature. The text thankfully lacks rigid structure, and welcomed breaks in the lessons of "how and why" are made up of "I remember the day" stories that are both amusing and filled with helpful hints on what NOT to do OR how the approached a problem and fixed it :) (Which is the point BTW)
The code in the book is sparse, and it initially bugged me, but I came to realize that it really is not about giving the reader chunks of code. This is not a step by step guide on how to make a game, but a collection of ideas on how to cleverly write and manage your game. Mike frequently comments on the potential problems one might have compiling his code, and he rightfully tells the reader to fix it as an exercise. After all that is the kind of industry Game Development is if I am not mistaken: Fixing broken code and solving problems???

Anyways, this book is not for know it alls already in the industry. This is a book for people like me who are passionate about games but don't have a clue on where and how to start. To me working in the industry is an impossible endeavor, but this book is not only filled with concepts on game programming, but it is filled with motivational stories and tips on how to GET IN. This is a booster in the right direction, and to actually get the opinions of someone already in the business, and not just straight HOW TO LOAD A BITMAP crap, (which is also in the book I might add...) has left me pleasantly surprised and content. If McShaffry wrote another book, hopefully something that covers topics he didn't cover in the original, I would be all over it like a Fat Kid on a Smarty.

I highly recommend it!!

Ce livre peut servir à tous ceux qui veulent programmer directement (en C++) avec les API de rendu 3D, mais s'occupe plus ou moins exclusivement du développement sur DirectX, avec Visual Studio.

C'est tout de même un livre de programmation avant tout, et il explique les concepts de structure et d'optimisation à un très haut niveau.

The author tries to hard to cover the basics of making games. It sort of reminds me a class study guide, i.e., everything lumped together in a highly condensed manner.

This book purports to be for the programmer who wants to write a game. But actually the author sells himself short! The principles that he describes here as best practices for developing games, can be applied far more broadly. To any program that has a GUI for real time human interaction.

For example, he tells how automated build scripts are vital and how milestone builds and multiple projects are useful. But all this of course applies equally well to any code project with several programmers involved. The chapters on debugging/testing are also quite general in scope, and useful in explaining that this is a discipline, in and of itself.

The book specialises to code examples in C++ for the various Microsoft OSs. In no small part because most desktops are running these operating systems, and if you are in a commercial effort, you go where most of your customers are. The choice of C++ is good and realistic. For games with a quick response time, compiled code is usually faster than interpreted. But then why not C, you might ask? Because C is procedural and scales badly when the source code gets over 100 000 lines. C++ is a much better choice.

The coverage of 3D graphics is only the bare minimum, as the author points out. For any application using 3D, you need at least another book, dedicated purely to the algorithms in that field, to be used in tandem with this book.

The title of this book suggests two things to me. The first is that it provides a complete guide to game coding. The second is that it fills the same role for game programming that the book Code Complete fills for programming in general, i.e. a journeyman's book that fills in the gaps left in introductory texts and broadens your knowledge to prepare you to move on to more advanced topics. Unfortunately by trying to do the former (which I don't think is possible in a single book), it falls a bit short on the latter, resulting in a (very) good book rather than the great book it could have been given the author's impressive background.

First, the bad.

It seems that the author never really decided what his audience is. Parts of the book (e.g. the introduction to 3D graphics) are written for total beginners, while others (such as the overview of game engines - all of which cost tens or hundreds of thousands of dollars to license) are really only relevant to experienced professionals. The author/publisher really should have picked an audience and stuck with it.

Some readers will be annoyed by how platform-specific this book is, which really isn't apparent from the cover copy or even the other reviews. All of the code samples use DirectX, and there is a lot of space dedicated to Windows-specific information. Granted, Windows and DirectX are by far the most popular choices for PC-based game development, so this won't be an issue for most readers.

And now for the good.

The best parts of this book were those covering topics that typically get overlooked in other game programming books, namely things like pointers and memory management, scripting, creating automated build enviroments and code/resource management, debugging, and notably the entire section on production, scheduling and testing. Although some of these topics are covered in other books that are not specific to game development, putting them in a single volume and exposing game developers to them early on is a Good Thing.

Although the sample code was fairly sparse, what he did provide was extremely useful, in particular the resource file implementation, random number generator, and scene graph.

Finally, props to the author for maintaining a website and actively supporting this book. As an author myself, I know how much work is involved in doing so, and I recognize that it reflects the author's desire to really help people and not just sell books.

In conclusion, my overall impression of this book was very positive. It's marred by a few shortcomings, but overall, I think that most new game programmers will benefit from it.

I just wanted to weigh in with my thoughts on this book. I really enjoyed it, no I loved it.

I have an addiction that involves buying every darn programming book released on Amazon. Many (most?) of those books sit on my over-stuffed shelf barely dog eared. I tend to browse the books I own or just mark useful chapters.

Not so with this book! I read it cover to cover. I loved the real world advice, the conversational style, the war stories and the pragmatic advice on non coding aspects of game development like estimates, scheduling, QA etc...

I got the same feeling of enlightenment when reading this one that I did a all those years ago when I read the classic book "Code Complete".

Great job Mike. I hope it is selling well so we can hear from you again especially on topics like AI and Sound.

As someone who just has about 3 years of programming experience and is finishing up high school this year, I found this book to very helpful. I got Tricks of the Win Game Programming Gurus one year for Christmas, and although the later chapters such as AI, multithreading, and physics modelling were pretty good primers, all the DirectX material were essentially rehashes of the SDK docs. Just about every other game programming book that focused on DirectX had the same kind of characteristic...most of the DX material could just as easily be found in the SDK docs. But when I came across Game Coding Complete, I saw it had a lot of good, practical information; I couldn't put it down.

I really liked the 2D chapter because it provided some good pointers on surface management (such as when and when not to restore surface data), explained how alpha blending works (and provided a surface-surface copy function that utilizes alpha blending), and lays out some of the basic functionality of a sprite class. For a newcomer to game programming, I really found these practical examples very helpful in at least getting ideas churning in my head as to how I want design my game.

Chapter 7 on the whole initialization, main loop, and shutdown procedures were real insightful in my opinion. Mr. Mike begins by discussing what he thinks is a good initialization process. One of the earlier reviewers might dismiss this as just another opinion of the author, backed up by no fact, but, at least to me, the author has some pretty sound reasoning for suggesting what he suggests. An example would the case he makes for doing initializations of certain objects: instead of relying on a user calling some Init method and using the return value from it to test for success or failure, he suggests doing all initializations from within the constructor and throw an exception if an error occurs. I agree with the author that the resulting code looks cleaner and a bit more elegant than testing the return value for multiple Init method calls (of course, this is also partly a matter of personal preference, but what have you). As with many other chapters, this chapter provides some pretty useful code for you to use, such as a function that will calculate the CPU speed, another example showing how to ensure that only one instance of your game is loaded, and a fairly solid cooperative process manager.

Chapter 8, which covers resource management, was pretty informative and made a convincing argument as to why you ought to use resource files rather than relying on all your images/sounds/what have you as individual files. Even though resource packing may seem a little daunting at first for a beginning game programmer, but in the long haul it's rather rewarding to be able to store all your resources in a few packed resource files. Mr. Mike uses the iPac program as an example for a resource packer, and although it is not freely available (I'm unaware of any free resource packing tool), through images and bit of information the book provides, I've been able to create a resource packing tool that more-or-less models after iPac and that suits my needs.

There are other chapters, especially the 3D math and 3D graphics chapters, which are pretty helpful, but again, as someone with no knowledge in 3D graphics, it kind of confusing. But I attribute that to my ignorance.

This book is not without its shortcomings though. Some of the source code won't work if type straight from the book. Fortunately enough, many typos have been pointed out on the book's website, and the source code appears to be in working order. Also the GUI and user-input chapter didn't seem to have the same caliber as some of the other chapters had. The author did mention it would've been much longer, but just seems like it's lacking a bit in its current state. It's better than nothing though. Also, there isn't any mention to audio really (aside from his choice of Miles Sound System in the beginning of the book).

In all fairness to Mr. Mike though, he does state in his introduction that he has a bit of a bias to Win32 and DirectX throughout the book. As such, you can't necessarily assume that ALL the concepts are applicable to every type of game programming (PC or console). I do think he makes a valiant effort in trying to cover certain topics relevant to console development. He does a very nice job of trying to cover a lot of material in a rather short book. Coupled with the source code that is available online, I found this to be one of the best books I've read on game programming. It's chock full of very useful information, much of which can be insightful for both the beginning and the professional game programmer. Has my definite recommendation.