Customer Reviews

Beginning Game Programming (Premier Press Game Development)

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

 

 

Most of the reviews on this book are from the first and second editions which are from different writer and/or different language C. This review is of the Third Edition by Jonathan S. Harbour, for C++.

The book is really good, it starts into the basics of windows programming but only goes far enough so you know how to get a program running to start making directx games, which is good cause that stuff is confusing and not much fun. But the rest of the book is a blast to read and the information is priceless. As you go through the book you start building a library of your own for directx that you can use in all your projects and games even after the book is read, which gives it lasting value. The writing style is excellent and interesting, the example code just works everytime if you type it in correctly. Overall this book is perfect for me and perfect for anyone who understands C++ and wants to make games with directx.

10/10

[N.B.: This is a review of the first edition, not the second.]

Jonathan Harbour, Beginning Game Programming (Thompson, 2005)

Beginning Game Programming has been kind of the holy grail of programming books for me for years. I can't even remember how it got such stature in my head, but over the last year or two it became one of the books at the very top of my wish list. When I found a copy for sale (relatively) cheap earlier this year, then, I jumped on it. Unfortunately, I had hyped it up so much in my head some disappointment was likely inevitable, but I tried to keep as even-keeled as possible when thinking about what to put in this review. After all, it's not a bad book, I've just read a number of intro-to-game-programming books that are better in at least one sense (comprehensiveness, readability, number/length/quality of code samples, or what have you).

One of the oddities of the book, and one which a number of novices will likely appreciate, is that the book focuses on C, rather than one of the more popular languages featured in books of this sort (C++, C#, or VB). For someone experienced in one of the other languages, that can be either a blessing or a curse, so take it into consideration. Aside from that, however, the main thing to note here is that the book dives right into game programming in C and DirectX (which version will depend on which version of the book you're reading; my copy is first edition, not second, and so the book's examples use an older version of DirectX than currently advertised). Code examples and discussions on the theory of game design start right up in the first chapter. Once again, this is something that some readers will find a strong point, while it will be a drawback to others. There's something to be said for some overview and nuts-and-bolts stuff (at least one of the book's reviewers complains about the lack of instructions for installing the software that comes with the book, for example), but if you kick things off from page one, you have room to cover more material in the same number of pages than you otherwise would. Can't call that a bad thing under any circumstances.

The book is also very small for this type of thing, only 337 pages, which limits the amount of space there is to cover material. Once again, something that could be seen by different readers as a good (not as imposing as doorstop-sized tomes) or a bad (not room to go into anything in depth) thing.

So, basically, it's up to you and what you're looking for in an intro-to-game-programming book. This could be it. It might not be. Check it out before shelling out the dough. ***

I liked this book. Don't be fooled by the author when he says in the beginning that "This is a book all about game programming". It seems like its goal is to do everything with DirectX but make games. You spend the first 9 chapters making neat little programs to demonstrate basic Windows code and the various components of DirectX. However, the games come eventually; you make a sort of Pong clone in chapter 10, and a 3D version of Breakout to finnish the book. You also walk away with a fully functional game "framework" you can apply to your projects for a while to come. BE WARNED: the compiler included with this book is Dev-C++, an environment I have found very difficult to use with DirectX. Your better off using MSVC (the compiler that is actually covered in the book). To sum up: I gained a knowledge of how to make games with C and DirectX from this book, so I'm satisfied. Definitely valuable, worthwhile, and a great place to start for the novice game programmer.

I had high hopes for this book. I really did. Unfortunately, it's just not very good. There were a number of mistakes and sections left over from the previous editions that were apparently forgotten about when the book was updated. A lot of the code won't even compile as written (missing dependencies, etc.), and looking for help on the author's website (as the book itself suggests) is quite frankly impossible--it's been abandoned. More on that later.

Twice as much information could have been covered in the same number of pages if less space had been wasted on useless proof-of-[an obsolete]-concept examples; I realize this is a beginner's book, but I'm definitely a beginner (I'm only about a month into learning programming) and even I found them painfully redundant. Even once you get past all that, the most advanced code in the book is still based on DirectX9, which was already outdated at the time of the book's writing.

Back to the site: nothing is accessible without an account on their forum, which requires manual approval by an admin--who, two weeks later, I still haven't heard back from. A quick perusal of the one accessible board (which contains nothing of use--that's all stored on the boards for the individual books, which, again, require an account to view) shows that the author himself has essentially stated that he doesn't want to deal with it anymore.

I hate to say it, but between the corny clip-art, outdated examples, and the author's self-praising writing style, I feel like I was tricked into buying a joke product. If there's a definitive guide to beginning game programming out there, this isn't it. You'll do better looking at free online tutorials.

I'm taking the rare step of submitting a review of a book when I've only read the first three chapters. I think I have a fair point to make.

This is supposed to be a book for people who are confident in C/C++ but who have no Win32 or DirectX experience. Fair enough. But to be frank it's written in a very confusing style, full of sloppy carelessness and ambiguous sentences which will leave you scratching your head.

For instance, in describing the HINSTANCE parameter to WinMain on page 32, Harbour says:

"The hInstance parameter tells the program which instance is trying to run. For the first instance, you will want to initialize the program (covered later). But if the program is run multiple times in Windows, the general practice is to just kill the new instance (also covered later)."

I have no doubt that this sounds logical and makes sense to someone who is already well versed in how Windows programming works. But to the Windows beginner this just doesn't really make sense. Why would you want to "kill the new instance"? Fair enough, it says "also covered later" but this is the kind of idea that's going to confuse the beginner and interrupt the flow of learning. Why not just leave it all until later Jonathan, instead of confusing the reader with something that is just not going to make sense at this time?

At times Harbour says the most bizarre things which make you wonder if you really want to learn the subject from him or not, for instance:

"In my opinion....a game shouldn't run in a window, it should *always* (without exception) run fullscreen. Do you want players focusing on your game or on instant messages and e-mail?"

So, the guy has some pretty fixed ideas about what a game should and shouldn't be from the start. What exactly is wrong with a game that runs in a window? There are many small games that work well in small windows which serve as a welcome little break from whatever the user is doing on the desktop. What does Harbour have against such games? There is no reason at all why a game should have to take up the full screen. Sure, he's just expressing an opinion here, but it just seems like a pretty strange opinion to express so adamantly in a book the purpose of which is supposed to introduce the reader to the tools with which to express his or her own personal game ideas.

Sometimes the layout of the book is sloppy as if no proof reading went on. For instance, Harbour lists the parameters in GetMessage(). In the final list item which explains wMsgFilterMin and wMsgFilterMax, he adds "The GetMessage call is the most crucial line of code in the entire Windows program!" This sentence belongs after the list, not part of a list item. I know this sounds trivial but it's a lack of attention to detail like this that is liable to make a reader weary about the level of accuracy and proof reading that has gone into a text.

Another gripe comes in the review questions at the end of the 2nd chapter. Question 2 is "What does the hDC variable represent?" I hate to break it to you Jonathan but the hDC variable has not been mentioned in the book yet.

Mistakes like this are inexcusable in a programming text and to be honest I'm sick and tired of spending money on programming books which are full of such sloppy errors even into their second editions. Seriously, how hard is it to have someone (even the author) proof read a book thoroughly from start to finish before releasing it?

One of the reasons I bought this book was I thought that in addition to introducing me to DirectX it would help me become familiar with the basics of the Win32 API like WinMain(), seeing as how most tutorials online do a terrible job of explaining things. Alas, this is no different. For instance, his terrible explanation of the hInstance parameter of his "InitInstance" function on page 45:

"...is passed by WinMain with the program instance that it receives from Windows. InitInstance will check this with the global instance to see if the new instance needs to be killed (the usual procedure in Windows). When this happens, the main instance of the program is set as the foreground window. To the user, it will seem as if running the program again just brought the original instance forward."

If Harbour thinks this is an acceptable explanation to lay upon a beginner Windows programming then what can I say? I'm not stupid, am quite proficient in C and C++ and have no trouble with some pretty advanced concepts. But I know little about Windows programming. And explanations like this are just far too vague and confusing. Where in his "InitInstance" function does he "check this with the global instance"? The code for the function suggests no such action. What is the "global instance" and how does it differ from the hInstance passed to InitInstance? He doesn't say. He doesn't even hint. It's as if he doesn't really care if the reader understands or not.

His subsequent explanation of the "nCmdShow" parameter is just as vague ("common values for this parameter include....")

One of the hardest things about getting to grips with the Win32 API is absorbing and taking in all the various names. To this end, it helps to hint at *why* something like nCmdShow is named as it is. Just a single sentence would suffice! Is that so hard?

And more: he goes on to explain that the functions "ShowWindow()" and "UpdateWindow()" are used to display the newly created window. But after making the technically inaccurate statement that hWnd is "passed to these functions by the CreateWindow function" (it's not - CreateWindow *returns* the hWnd value and the programmer passes it to those functions), Harbour goes onto tell us that UpdateWindow() tells the new window to draw itself, without even mentioning ShowWindow()! Was this book written hastily in an afternoon and published the next day?

Pushing forward, it seems that the book's sloppy and inadequate explanations continue in virtually every section. Next, Harbour goes on to explain his "MyRegisterClass" function which is declared as "ATOM MyRegisterClass(HINSTANCE, LPTSTR)." Thinking that one of the first things he would surely do would be to inform the reader what the type "ATOM" is, I scanned ahead...and ahead....and to my surprise, there is NO mention of ATOM.

Then, he tells us that MyRegisterClass defines a new variable of type "WNDCLASS." Fine. Let's look at the code....oh look, it's actually defined as type WNDCLASSEX. Does Harbour think to explain the difference? No. Does he even care if this causes confusion to the reader? Apparently not.

Some programming authors have a knack of predicting exactly which questions the reader will ask and answering them just as they thought of them. Judging by this book, Jonathon Harbour is not one of them. This is without a shadow of a doubt one of the worst programming books I have read. I note with interest that the "most helpful favorable review" for this book is written by....the author himself, who awards himself a modest five stars. Hilarious.

If you are like me - knowledgable about C++ - you will appreciate this book if you are trying to get started with Windows DirectX programming. I have read a lot of introductory gaming books and I can honestly say that Harbour gives the beginning chapters the attention they desperately need. I have read too many gaming books that go over WinMain and WinProc so fast you have no idea what they actually do. True - they really don't play that big of a role in the full span of game development. Here is the thing, though, if you are typing things like "HINSTANCE" and "LPTSTR" and don't know what they mean, it is likely you are just memorizing everything you see in the book; what good is that? As a programmer, you need to know what is going on so that random letters suddenly make sense and you know what is going on. Never program blindly - it is the first step to failure! Harbour explains everything in concise, well-rounded chapters that make coding even easy for beginner programmers. I have another book called Beginning DirectX 9, and the author starts out by giving over a page worth of code with hardly sufficient explainations. Harbour's book is not like that! He is very ambitious and will direct a reader to actually learn something - not everything - but anything a serious programmer needs to pick up another books that will be more challenging. His only fault may be that he repeats himself too much, but it never takes away from the quality and it really stresses the important things. If you are sick of programming books that just aren't working out for you, this is your last caveat. Enjoy learning something for a change. :- )

Besides the few mistakes that make it difficult to compile code etc. the book is very good for beginners. It starts with the basics of windows programming framework then adds DirectX, onto 2d graphics then finishes with 3d. Each chapter has questions to test your knowledge and it CLEARLY states the answers are in the Appendix which ISN'T included. I have contacted them and they just state, "nope no appendix sorry". So if you are unsure of an answer your never going to know the answer. It also has a program he uses called meshview which doesn't come with ALL SDK's (maybe I have a newer one that has it removed). So the whole section on optimizing mesh's is worthless to me (I have searched for it on the SDK ON THE BOOK's CD!! and online to no avail) Things like that throughout the book make it just a so so book to me. Anyhow don't expect a complete 100% thorough book.

This book is a very quick and dirty intro to DirectX 9.0b programming (it's very odd that directx is not in the title; perhaps the publisher felt it was redundant with their other begnning directx books). The book seems like it was written in a weekend using a dictation machine, but I forgive it this sin because it's very quick to read. Think of it as an example game source with heavy comments.

Note: you'll need to be familiar enough with pointers to understand the peculiar way the DirectX API immitates class objects in C (without using C++ features); I wish the author commented on this and why a class-based interface isn't offerend in the first place; I'm guessing it's so they don't have to write the API twice to support both C and C++. Nor does he address the more general question of 'are classes really so bad for performance?'.

In sum, my only real complaint with the book is its cost: for $30 bucks it should be more complete.

BTW, what's with the repeatedly redundant parts where he goes through setting up the visual studio project? He should have saved that hand-holding for the actually difficult concepts.

This book has exellent information, but the author spends little time emphasizing the basics. I am about halfway through the book and i have just stopped reading it becuase it is so confusing. I am very experienced in php, and know basic C and C++, and was surprized i found it so difficult to understand. If you can catch on quick enough though then im sure the information given is great, i expecially loved the first few chapers before the code, where he explained about api's and how directx works...

I've started reading multiple C++ game programming books and found that the Author clearly spells out what is needed, how to complete tasks, and most of all bug free code. It's very rare to find a book that will compile on the first go, and on VS 2010. The book takes you through the basics of getting started, then begins to teach you how to create a game. Starting out you'll begin to understand Windows Messages and what you can do with them for your game.

After you get past that you'll be moving along and starting to use Direct3D, while it's not DX11 it is however DX9. The author does an excellent job explaining why he is going to be using DX9. After you get the basics of DX down you'll then move along to Graphical uses, input from keyboard, mouse, and controllers! I really loved using the Xbox 360 controller and seeing how I could manipulate the input for my game.

Next up you'll venture on to using Animated Sprites for your game, this is something that is hard to understand, yet the author has done an excellent job with very detailed instructions and uses. Then you'll be moving along to Transforming Sprites, I had a ton of fun using the code from the book to manipulate my game sprites.

Detecting Collisions was very fun and I learned how players can walk on terrain, and it opens up so many other things such as shooting and hitting the target, even with melee weapons! Not to mention shortly after you'll be learning how to add audio to your game, and then some basic 3D rendering and you'll be provided with some model files courtesy of the compainion cd, or the authors website has the book source code.

Finally you'll be putting everything you've learned from chapter 1 and forward into making your first game, it's a really sweet game where you can shoot down approaching ships in a space environment, not to mention the author challenges you to add things to the game, and I really appreciated that. A lot of times books just end and you never get any more use out of them, that's not the case for this book and it certainly will remain in my library for years to come.

*** Side Note ***
The author really does an excellent job with keeping in touch with his customer base, and I've gotten help with issues outside of the books scope, and had my questions answered in a very timely manner. So if you want an excellent beginners book, an author that is there for you, and a great community on facebook or the forums: [...] buy the book and head on over to join us.