41 of 43 people found the following review helpful
on March 22, 2012
I have owned three versions of Game Coding Complete (2,3 and now 4) and have always been impressed by the material found in the book that is neglected in nearly every other text of its nature. While many books focus strictly on a specific topic related to game development, such as a rendering API, physics engines or AI, GCC delves into topics that are not as easily researched either in books or online.
While there are a few requisite chapters about rendering, which uses the newest version of DirectX, they are less about teaching you how to use the API and more about how to structure a renderer for a game engine. This is a topic that is all to often overlooked except in game engine books, many of which are of questionable quality. Fortunately, GCC is written in a far more structured manner and these chapters, as well as all of the others, don't feel as though the authors wrote the first solution that came into their minds and the result is a much higher quality book.
While the first few chapters are basic introductions and a bit of design theory, the heart of the book begins in chapter 5. What follows is nearly twenty chapters of topics discussed with a fair amount of detail on subjects that are often missed entirely. This part of the books begins with a lengthly discussion on how to properly start up and shut down your game or game engine. While many books choose to miss any kind of discussion on how to do this in an elegant way, GCC gives it the attention it deserves and it may just be the best chapter in the entire book. Chapters on game actors, input devices (including game pads as well as keyboards/mice) and scripting have seen extensive rewrites from the third edition in order to modernize the code. There are a couple of fine introductory chapters to cover audio, user interface and game event management before the three chapters on rendering begin. After the rendering chapters, we are treated to topics including collision and rudimentary physics, AI, networking and multithreading. While none of these can possibly be discussed to exhaustion (each are deserving of an entire book and those books can be found), they do introduce the material in a significant way that will help you as you move into more advanced topics. All game development books feel the need to wrap everything up into a little game at the end and GCC4 is no exception. The Teapot Wars game does an adequate job of employing the techniques in the previous chapter and shows you how everything comes together. While most books would end at this point, GCC continues with three excellent chapters on building a level editor, debugging/profiling and some end of development cycle issues.
While the book did not release with source code available on the author's website, I believe this was a testament to ensuring that the code base was mature enough to be released. In the couple of weeks since the book's release, the source code has become available from the books site at [...]. The code, if you have never owned a GCC book before and are jaded by the lack of good code in other development books, is of surprisingly high quality. The authors have rewritten large portions of it along that match the associated rewritten chapters for the books fourth edition. It maintains the same level of quality we have come to expect, a particularly important point since the books original author handed over several chapters of GCC4 to his co-author. While a few chapters of GCC's third edition were authored by someone other than Mike McShaffry (including one by the fourth editions co-author David Graham), McShaffry did the lions share of the work. In edition 4, Graham has done admirably well in continuing McShaffry's work and ultimately delivers the same high quality content we have come to expect from the series.
While no programming book can ever truly be complete, GCC does a remarkable job of highlighting the issues few other books dare to address. The website offers direct support from both authors who seem to respond to any questions promptly as well as community support from other GCC forum members. In GCC, you will get a book that at a minimum you will pick up a few coding and design tricks from. Many will find a great deal more that may prompt radical changes to how they design games and game engines. Overall, even the most experienced of game programmers owe it to themselves to pick up a copy of one of the better game development texts.
29 of 31 people found the following review helpful
on March 28, 2012
Being a self taught game programmer myself I have quite a tall pile of books about the subject, including the previous edition by this author. Out of all the books out there trying to teach how to write a game and a game engine right, this one I feel deliver the knowledge the best out of all I tried so far, with its predecessor being right behind it.
While other books usually fall short, focusing mostly on a single element such as the game engine or the game only, this book takes you step by step through the process of creating the game engine using practical approaches from modern (2012) game industry applications, then follows up with creating a whole simple yet fun game and finishes with an editor for the game you just built. The whole process leaves you with enough knowledge to tackle your own game development with a set of tools to start with.
The chapters are set in order to teach you how to set up each piece of the engine from starting your windows application to reading user input, managing memory, rendering graphics, playing audio and even networking. Personally I enjoyed chapter 6 a lot where the authors explain Component based Actor architecture which feels to be a very simple and instinctive way to describe your in-game entities/actors. By the end of the chapter you should know how to create easy to use XMLs for defining your game objects. (Personally I added a binary read/write conversion for those classes for performance once game editing is done)
Another chapter I enjoyed a lot was chapter 18 "An Introduction to Game AI" where Rez explains many different AI systems all which the reader can choose from to use for specific game implementations, using a lot of examples from previous games he worked on such as The Sims Medieval .
Regarding graphics, the book uses DirectX 11 which is great but it is not the book's main focus to teach you how to use DirectX. You will learn enough to start with and get visuals on the screen and even make a solid 3D game, but I would recommend taking another DirectX specific book to read after finishing this book so you can then expand the engine's capabilities by adding special effects, post processing, etc.
There is a lot more to be said for the book and all the knowledge you acquire from it, another major point would be the Lua scripting implementation in the book - allowing your game to feature scripts like professional games do.
Yet what might possibly be the highest quality for Game Coding Complete is the support and interactions with their readers over the book's forums. Rez and Mike both regularly reply to posts and answer design and code questions, really fulfilling Rez's statement of him wanting to be the resource he wish he had back when he first started.
11 of 11 people found the following review helpful
on December 15, 2012
Short story: If you want to work as a game programmer in the industry, you absolutely should understand the information in this book 100%. However, it is truly an advanced book, and if you are just getting into C++ usage, this should probably be your second or third book (at least).
Long story: There are few textbooks required by the Digipen Institute, one of the best game programming schools in the country. It emphasizes working together with your classmates to actually learn how to create games, so there is not a lot of actual book work to be done. This is one of those few books required. That alone should be enough to convince you it is worthwhile.
Let's go into a bit further though. The game industry has been alive for decades now, and that has led to standards and styles of programming that proves more effective than other methods. It is accepted that C++, and object-oriented programming in general, is the way to go. Event-driven programming is common in large titles. Resource management is a common theme in a game with gigs of data that needs to be continually streamed in. Multiple controller schemes need to be supported.
The authors of this book have worked in the industry, and this book is their offering to help teach you how modern games are made. Other books will manually load in individual resources, or will read the state of the keyboard directly in their examples. This is fine when you are first learning DirectX, for instance. But if you plan to work with a team, and you have tens of thousands of lines of code to debug, much of which you may not have actually written yourself, you need a better structure supporting your game, or it will become top-heavy and impossible to finish. This is what they are focusing on getting across.
As good as the book is, even more valuable is the sample game that has been built and evolved since the first edition of this book. Teapot Wars is freely available on Google Code, and it is a working example of everything they are trying to get across. It actually has more complex examples of the topics discussed in the book, and internally it is a basic version of a AAA title. Understand its structure and you will have a massive leg up in your quest to become a game programmer.
So this should be the book to buy right? Just understand it and you will be good to go, right?
Well.... yes and no. This book assumes several things, without really saying them outright. It assumes you have proficiency in object-oriented programming, especially in C++ programming. They assume you are comfortable with the concepts of inheritance, using abstract interface classes, overloading, encapsulation, and all those fun names you see thrown around in the Wikipedia definition of OOP. They build some fairly complex abstract factories and just throw them at you in the book. It took me months upon months of carefully reading C++ books and going through their code to finally really start to get it. I bought this book right when it came out, and I only now feel comfortable to write this review.
So this absolutely should NOT be your first book. You must study OOP and C++ first. Another book that Digipen uses, C++ for Game Programmers by Noel Llopis, may be a good start. I went through Thinking in C++ by Bruce Eckel years ago, as it is freely available online, and it's a great start too.
This book uses the DXUT framework, which has been deprecated by Microsoft and stripped from their MSDN online documentation. No big deal, it still works fine, but the main function may seem tricky to you because of it. They do not use DirectInput which is good, as Microsoft is no longer supporting it and it doesn't seem to work in 64-bit code. It assumes you understand how DirectX works when you get to the graphics chapters, so understanding the graphics pipeline is a good idea.
So you see, this is not the kind of book that says it's the only resource you need. In fact, it's probably the third or fourth resource you probably need. There's a steep learning curve, though kudos are due to the authors for being extremely available on their forum at [...] Seriously, they respond within 24 hours to any question anyone has.
However, if you understand everything in this book (a process that could easily take a year or more), you will have a clear idea of how a modern AAA game is created. It's just a framework, but you will probably be ready to start taking on major game programming projects. And that is a compliment that no other book on the market likely can boast of.
So in conclusion, I think any budding game programming will be doing themselves a HUGE advantage by making sure they understand everything this book is talking about. It is the more Complete book I have ever read on game programming, and is 100% essential to anyone taking themselves seriously. Just make sure you understanding object-oriented programming in and out before you begin, or you will be very lost very quickly.
8 of 8 people found the following review helpful
At a little over 900 pages, this book (now in its 4th edition), covers the essentials of making games for programmers. I would recommend it for any programmer. It's not for artists or designers, but it considers how artwork and graphic design has to be factored into the CPU load. While I would recommend this book as the first book to read on programming concepts for gaming, it probably should not be the very first gaming book for beginners in either programming or game development. It is very much a conceptual->operational book, but it has enough concrete examples to provide grounded understandings of the concepts.
In my option what makes this book great is how it introduces the importance of Design Patterns in game development and design. (When I mention 'design' I'm talking about code design. Graphic or artistic design will be labeled as such.) In Chapter 2, the authors, Mike McShaffry and David Graham, spell out why object oriented programming and design patterns are practical tools to use in game architecture. They do not go into the details of working with OOP and design patterns, but they provide plenty of references that do. Their examples pretty much assume that the reader is familiar with classes, interfaces, methods and properties in the context of OOP. When reading what they were saying, I felt that I wanted to grab a young programmer by his Upper Playground t-shirt and and point to Chapter 2 and proclaim--'For God's sake! Listen to these guys! You may not see it now, but when you're 52 levels into your game, you'll understand!" So, yeah, I really like their approach.
The topics in this book deal with the essential elements of what you need as a game developer throughout its 24 chapters. I found myself running into fun and useful examples. For instance they showed the assembly listing for a 6502 chip from an Atari and a finite state machine in Lua for creating a simple AI. The AI example has a simple state chart showing how both the state machine and AI works rather than one of those awful old fashioned flow charts from the 1960s. (Some books still use those blasted things--to promote sequential programming it would seem.) Throughout their book they used what I consider "module" charts effectively and clearly. I would have liked some class diagrams illustrating using a design pattern in a game, but they can be confusing unless you're familiar with the UML, especially the version used by the Gang of Four (authors of design patterns).
Throughout their book, they use little "side stories" with special identifying cartoons. Included are Best Practices (most useful), Gotcha! (what to watch out for), and Mike's and Rez's tales from the Pixel Mines (interesting and useful experiences in working on different games for different companies.) In some books such asides often range from distracting to banal, but here, they are used very effectively. This does not seem to be the kind of book that you'd read from cover-to-cover (unless you're in a North Korean prison) but instead a book to keep nearby when developing a game and to look into for guidance in dealing with a specific issue. Chapter 2 is one you'll want to read from beginning to end and Chapter 3 has great tips if you have not programmed larger projects, but otherwise, it's easy to skip around between topic on UI, sound, input devices, multi-threaded programming (Introduction to Multiprogramming), gaming across the internet, game AI and other game coding topics.
At first I was concerned about the C++ dominating the examples, but very quickly it was clear they were easily translated into my favorite programming language, and they were used to illustrate a more general idea. The book's value lies in its concepts and practices. Those concepts and practices will be around long after the hardware, programming languages and game tastes have gone the way of the dodo bird.
17 of 20 people found the following review helpful
on March 21, 2012
If you're like me, then your sitting at the keyboard wondering if this book will pan out or be like all the others that claim to deliver, but fail. I've read over the book just to absorb the content, not to put it to 100% use so keep that in mind. While reading the book I didn't feel that 'huh?' or 'what just happened?' feeling in my head that some of the other books I've purchased leave me feeling after reading a chapter. I'd list out the table of contents of the book and how it is structured, but I'd rather use my space here to say the following:
The source code was not uploaded yet, I visited the site in the book where your able to speak with the Authors via a message forum. The response time was very fast, and friendly. This is something that is hard to come by, and it's a big perk! I was able to download the code, compile it without any issues, and play the game that is designed using the very engine built in the book. The code is still being updated for bug fixing, it is very commented, and includes page numbers back to the actual book!
I've very happy with this purchase and it's one book that I can say will be used extensively, and I was very happy to discover a book that was very current and using VS 2010! Also it's worth it to note that the 3rd party applications used are already assembled and so easy to implement because the work has already been done for you, this save a ton of time getting this up and running.
So if you are like me above wondering if you should buy this book, then do as I did and buy it.
4 of 4 people found the following review helpful
Game Coding Complete is primarily for experienced developers contemplating or simply curious about the reality of a job in the game industry. While there's plenty of code, both in the text itself and available for download, most of the book is prose covering the highest levels of abstract game design, development environment and business issues, as well as the lowest software details of memory management and hardware considerations.
If you're a former C++ developer - perhaps a bit rusty after a few years' diversion into web-based scripting, Java or .NET, and you want to brush up on all that "low-level stuff" you enjoyed, the book makes for an interesting refresher boot camp.
The chapters alternate roughly between the two authors: McShaffry comes off as more of the architecture, tales-from-the-trenches, senior guy while Graham's a bit more of the geeky code head.
If you've worked in a corporate non-game development shop, it's both enlightening and (for me) a bit dispiriting to read about how similar working on a large production game can be (i.e. automated build scripts, source code control, specs, code reviews, been there, yawn...). The image of a roomful of disheveled geeks slinging code in the middle of the night powered by pizza, Chinese take-out and liters of soda lives on in geek cultural mythology, however at odds it is with today's industry reality.
I wouldn't recommend the book to beginning programmers or hobbyists looking to write relatively simple retro-style games for their own amusement. Game Coding Complete is unabashedly C++ oriented with no apologies for its inclusion of low-level memory management, smart pointers, object-oriented features, comparative strengths and weaknesses of APIs and a heavy emphasis on architecture. Not to mention more game-oriented topics such as 3D graphics and physics as applied to game software. The recommended reading includes texts that have graced cubicle shelves of most every shop I've worked in since the 80's (i.e. Meyers, Gamma, Alexandrescu)
If you're a beginning programmer, I think you'll be completely lost without both core C++ language skills and experience with Windows API programming. It's not like the old days but there are still good "prequel" texts out there, such as "Beginning Game Programming" by Michael Morrison that are C/C++ oriented and will give you experience getting your arms around entire games - which is distinctly different from the team-based development efforts described in Game Coding Complete.
Game Coding Complete is not one of those game books from the 90's we devoured that trace the creation of an entire game, detailing every line of code, chapter by chapter. This book assumes you've already been there (perhaps while holding down a corporate coding job) and have always dreamt of being part of one of those blockbuster games you've likely sunk a few hundred hours into playing - or at least getting a well-written, entertaining, at times irreverent and hard core technical view of just what goes into turning one of them out.
3 of 3 people found the following review helpful
on December 3, 2012
I cannot recommend this book highly enough. Before I found this book, I was a student of game programming who had written a small game (with levels, menus, gameplay, sound, DirectX graphics, with shaders, meshes, particle effects...the works) for his midterm project. But it was an incomprehensible mess of code and I had no idea how to code things properly with a clear division of responsibility (low coupling, high cohesion) and sanity in code. When I wanted to create a particle effect, I literally hard-coded the texture file it needed to use, the image sizes, colours etc. all based on the current context. It was absolutely dreadful and any software developer would have cried themselves to sleep that night looking at it.
I wandered aimlessly for several months, trying to figure out on my own where to go from here. I was completely gridlocked with so many questions racing in my head, I didn't know where to start. Then, suddenly, like Moses coming down from Mt. Sinai, I stumbled on this book. Ho-lee-cow was I blown away. It answered every single question I had at this time:
* How to ensure sensible communication between subsystems? (Events)
* How to create a Component-based entity system?
* How, when and where should I do logging and error handling?
* How do I read and write sensible data files (XML)?
* How to load/unload resources on the fly?
* How to handle user input so that a single input event is captured and processed by one game subsystem, and not multiple?
* How to write and manage a scene graph?
* How to write a game from the ground up to support both single and multiplayer?
* How to organize a damn Visual Studio project?!
Between all of the useful industry tips, and the reassurance that these guys have worked in the industry using these exact methods to solve the same kinds of problems I was having, I was on Cloud 9.
Since then I've taken the base engine code, tweaked it a whole heck of a lot (replaced the graphics system with Ogre, etc.), using it for my senior project, and kicking ass.
If you've written a game and were confused like me, or even just know a moderate amount of C++ and want to write games, buy this freaking book.
3 of 3 people found the following review helpful
on May 20, 2013
Just finished reading the book today, thought I'd give a review!
A bit about my self; I'm a self taught intermediate game programmer with a dozen small games in the basket. I wanted to move a step up and improve my understanding of the overall knowledge of games, game structure and every small element that goes into making a full game. To my surprise.. there's a lot more than I first thought.
It's pretty obvious that the writers have many years of experience in the games industry, that's exactly the kind of people that should write these books. This will hopefully help the new game developers not repeat the same mistakes, skip a few years and jump right in.
The book opened my eyes to so many new ideas and concepts, I now find it hard to imagine what it feels like not knowing them, as if I always knew them.
There's a fairly good amount of story telling from pixel mines with some good humor, I like that.
The chapters with heavy use of DirectX specific calls were a bit hard to understand, specially because I'm more familiar with OpenGL. But I was still able to take the ideas, and will find my ways in OpenGL.
Overall I thought the book was great, worth the time if you want to be an engine programmer or a generalist.
Thank you, Mike and David.
3 of 3 people found the following review helpful
on January 9, 2013
Originally I was not going to buy this book since I already had the previous edition but I'm glad I did! Mike McShaffry and David Graham have nailed the subject of games programming with this book. It has the perfect balance of narration and coding examples. All of the sample code is available online but I prefer to type it in since I learn better that way. I love Mike and Dave's analogies of past project experiences it helped reinforce some of the concepts. You should have some programming experience with at least one C based language before attempting to dive into this book as it discusses a lot of advanced topics such as memory management. This book has a strong bias for Microsoft compliers so if you are using something else for development such as C++ Builder I would suggest installing Visual Studio Express when working with the examples. Anyway, I highly recommend this book to anyone who wants to know more about game development.
7 of 9 people found the following review helpful
on June 19, 2012
I really enjoy reading Game Coding Complete (4th ed). It's hard to find materials that teach how to actually structure an entire game. Sure, you can learn how to display a 3D rotating cube, but you can't really find any resources to teach you how to make a powerful game architecture. This book fills that gap, but it has a few chinks:
-It is *way* too Windows-specific. Me being a primary Linux user I have to skip large sections of code because it deals with setting up a window in Windows or grabbing input in Windows. I would rather have a book with pseudo-code rather than Windows-specific listings, especially with the rise in mobile platforms. I understand that probably more than 50% of the book's readers will be on a Windows computer, but I bet a lot less than 50% of the money that goes into the game industry goes into Windows games!
-"Rez's" chapters generally don't fit in that well. Mcshaffry's chapters tend to be a lot easier to understand and follow (basically, more enjoyable), while Graham's are a lot more difficult and on the heavy complex programming side, not the heavy *game* programming side. The chapter "Coding Tidbits That Saved Me" was probably the most difficult "Rez" I've read so far. Now, when I see his name as the author of the next chapter my heart sinks a little, because a grueling section is ahead.
-The whole section on "App Delegates" didn't make any sense to me, as it's another one of those Rez chapters. I usually try to avoid 3rd party libraries as much as possible and try to home grow my own (the only library I use a lot is SFML) as much as possible, especially when it comes to things like physics and artificial intelligence as those tend to be on the enjoyable side to program. With this background it doesn't really make me gung-ho for some App Delegates library, especially because they don't seem all that necessary to me at all.
-This is a smaller thing, but some of the text is really unprofessional. Mike's reminiscences are fine, but calling the Nintendo DS a "Game Boy DS" makes me think less of the authors (like I said, a small thing, and note that I'm no DS fanboy, things like this just bug me).
Despite these chinks, there are some great perks:
-Its clear reliance on heavy scripting (as in, creating everything the game needs in parsed text files, not compiled code) makes it a lot easier to create a scripted engine beforehand. Learning clever things like calling functions via streams is quite interesting. Scripting also helps with heavy abstraction of the engine, so one doesn't have to worry about what's happening under the hood.
-The proposed Logic View Application architecture seems like a very viable and versatile architecture, including the actor component architecture, event managers, process managers, and resource caches. I wouldn't be copying and pasting any of those latter three, but I would recommend implementing versions that better suit your individual cases (none of the book's code should be copied and used for your games, mainly because you won't learn anything and your game will be Windows-only).
If you are interested in structuring your games well (and not just learning how to make a textured sphere, like most "game programming" books), and having a good time doing it, this book is definitely for you.