This is an ambitious and expensive book. In my opinion it isn't really worth the cost. I have two major criticisms: first, there is no CD with code samples, and no color plates for showing off graphics. Second, it is *very* poorly edited, and the code formatting is so bad as to be almost unreadable.
For example, on page 576 on reducing texture memory requirements the author talks about how using RGB4 is generally okay if you don't have fine color gradients. This is correct. He then refers to an unnamed figure (which we find on the next page) but swaps the left and right side (presumably) defeating his point. He then later refers to the figure, by number, but with completely incorrect content. The actual picture referred to was apparently removed, and the wrong one got its number. This is not an isolated incident. Page 329 has a nasty (yet typical for integer divides) off-by-one error.
Further, I find he often uses pseudo-code where you would want details, and real code where you would want pseudo-code. And the coding style used is also poor, especially when one thinks it is meant to be an example to new programmers. Often #define's are written exactly like normal variables and are used when enums would be much better, upper case and lower case are regularly switched when referring to the same variable, long, unreadable, all lowercase variable names are used, constants are not brought out of loops, braces are not matched up, erratic use of whitespace, etc.
I also found discussion often sadly lacking. The book is admittedly already large, but much could be cut out that isn't interesting or germane (e.g. pages of badly formatted code, or mixing force-feedback effects for DirectX which belongs in a DirectX book). For example, in discussing A* searching no mention is made of using pessimistic heuristics, which in practice can dramatically improve performance. In a very brief section of Design Patterns, no discussion is made about why the author thinks its better to subclass strategies rather than use function pointers.
Some statements are just wrong: "As anyone familiar with algorithm theory knows, sorting a list of N numbers needs at most N log N comparisons, and no algorithm can perform better than that (in a worst case scenario)." Well, in fact, if you can meet certain criteria, you *can* sort in O(N) time (even in the worst case), and many "standard" algorithms require N*N comparisons in the worst case.
There are some good points. The history of games was quite interesting, as was the review of tiling, sprite, and palette techniques. And, if you're a complete beginner to programming, there's a fair bit of useful information, and I'd give the book 3 stars instead of two. Even experienced game programmers will probably learn something, or at least be pushed in that direction. The explanation of BSPs was quite good, for example.
All in all, disappointing. For reference, I've programmed the PlayStation (one) for Electronic Arts, and more recently done gaming stuff for mobile phones, and have a background and interest in gaming, 3D graphics, and AI.