.NET Game Programming with DirectX 9.0

Written in easy-to-understand language, this book is a must-read if you'd like to create out-of-the-ordinary, yet simple games. Authors Lobao and Hatton demonstrate the ease of producing multimedia games with Managed DirectX 9.0 and programming the games with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio.

The authors emphasize simplicity, but still explore important concepts of Managed DirectX 9.0, such as Direct3D, DirectSound, DirectMusic (using the COM interface), DirectInput (including force-feedback joysticks), DirectShow, and DirectPlay. Additional chapters discuss game programming technologies: Speech API for generating character voices, GDI+ for simple games, and multithreading. A bonus chapter even shows you how to port a simple game to a Pocket PC.

The book includes two chapters' worth of sample games. The first presents a game with simple features; the second extends that game and presents additional concepts. A library of game programming helper classes is also created, step by step, in both chapters.

User review
-5 Stars!
I would Actually give this a -5 if there were an option for this. Obviously no proofreading was done, the layout is horrible, and the author jumps into programming without much explanation of what he is doing.
The examples don't work.

User review
One good chapter, lots of bad code.
Alexandre Santos Lobao and Ellen Hatton, .NET Game Programming with DirectX 9.0 (Apress, 2003)

The best thing about this book is the theory; Lobao and Hatton lay out the basics of working with DirectX, etc., in simple, easy-to-understand language for those of us whose programming experience is limited to, say, database access, and have never had a use for graphics.

The code, on the other hand, is deeply flawed, not to mention not all here (the authors refer us repeatedly to the book's CD, which is all right-- unless you're borrowing yours from the library and the CD is smashed into seven or eight pieces). I've tried copying some of it straight from the book into VB.NET, with, shall we say, questionable success. I've been able to debug a good deal of it myself because I do code for a living, but I can't imagine a beginner, who's never coded anything before, doing anything but being thoroughly puzzled by the errors.

The rating is given mostly for Chapter 3, which is valuable. ***

User review
You can do much better
There is no reason to buy this book. There are much better books for managed DirectX and game programming. As a programmer, I was embarrassed by the poor coding in this book. Trying to learn from this book is pretty hopeless.

User review
Reconsider buying this
This book teaches some useful concepts and techniques when it comes to game programming. It is getting me started on Direct3D okay, which is why I bought the book. There are some serious problems, however.

The book (thank god) comes with a CD with working source code. This code will often not agree with the book. The book contains syntax errors. The author forgets to inform you of many variables and functions that need to be defined. He flips back and forth between VB6-style and VB.Net program flow mechanisms and commands, using Err.Raise, On Error Goto, MsgBox, and FunctionName = ReturnValue in one function, then Structured exception handling, MessageBox.Show, and Return ReturnValue in the next function. In the function I am looking at right now, a for/next loop is needed, but the for and next lines are simply omitted from the source in the book! The code doesn't appear even make sense until you open the source from the CD to see what is missing. He uses incorrect DirectX function, class and enumeration names (on the page open in front of me, he declares a texture object as a `Direct3DTexture8` rather than the correct `Texture`,,. I am beginning to wonder if all this code is not ported from VB6 and DirectX 8).

I copied one of the games (River Pla.Net) to my hard drive, and compiled and played it. It (intentially) runs at about 6 FPS, with the entire playing field scrolling one row of tiles per frame. It works, but it looks,,. bad. In five minutes I looked around, modified 15 lines of code, tops, and I had the game running with smooth scrolling and waaaay smoother controls. Why would the author not take the extra five minutes to make his game look 100% better?

I have to admit, though, that I am now capable of creating a Direct3D, tile-based game, which was my goal, which is why I would give the book 3 stars rather than one. A less experienced programmer, however, might not be able to fix the errors found in the code in the book. If you find any other book that suits your needs, I recommend swaying away from this one.

User review
At least I like the title of the book ,,.
I was lucky enough NOT to buy this book. I sat down in Barnes & Noble this weekend and read the first 60 pages and skimmed briefly through the rest. I would hate to try and recommend this book to anyone. A beginner may learn a few things, but it's riddled with errors and some terrible programming techniques, that I would hate to see a beginner pick those techniques up as `the way to do it.`

I think authors should take more care in the editing procedure. Even a casual re-reading by the author would have, I should think, exposed many problems, which could have been fixed before going to press.

A couple errors:

- Saying you'll take errors if you try and use a certain technique with indexed pixel formats, like JPEG. Excuse me? JPEG is not, never has been, and never will be an indexed pixel format image. Sorry!

- Saying `In .NET all the arrays must be defined without boundaries, which are later assigned in the code.
So we must always use Redim before assigning values to an array.` What?! Are you nuts??

The biggest chuckle I got was when, in the first chapter, he is careful to code his own `Rectangle` storage so that he can save an addition (+) operation. But, if you look at the code for drawing the blocks, he is as inefficient as you can get: creating and destroying entire device contexts for EACH BLOCK. Yeah, for each (X,Y) block, he calls `ArrGameField(X, Y).Show(WinHandle)`, which in turn does `Graphics.FromHwnd(WinHandle)`. Crazy!!