Customer Reviews

Windows Game Programming For Dummies

5 star:		(126)
4 star:		(38)
3 star:		(17)
2 star:		(11)
1 star:		(12)

 

 

An idiot who slapped the 1 - star rating on this book is, in fact, a dummy. You CANNOT expect to write any game without having C or C++ down. Before buying this book, make sure that you are strong in using pointers and such 'advanced' things found in the C language. Some Windows programming is nice, however, Andre LaMothe is able to explain it nicely in the pages that are in the book, without going into explicit detail (which is a good and a bad thing). If you want to learn how to write games using your C language, then this book is a very good one. It explains Direct X fully, although, it doesn't go into explicit detail. On a final note, this game teaches a lot in the pages that it houses. It teaches basic Windows Programming, DirectX, as well as Physics and AI. Don't expect to get an extremely detailed tutorial on each concept taught in the book. If you need every detail found in Win32 Programming, then head off and purchase Windows 98 Programming by Schildt. If you want to learn DirectX (no D3D..) by going into explicit detail, Inside DirectX is the way to go. However, if you want a brief and somewhat detailed tutorial of both (including many, many other aspects of game programming), you'll find that this book provides you with everything you need to know. However, don't expect to write ANYTHING 3d. Right now, after reading that book, I am able to program my own Secret of Mana type game. How many people can say that after reading a 480 page book?

This book is for programmers with a fair grasp of C; you should understand macros, pre-compiler directives and a little bit of Windows programming (IMHO).

This book is NOT for people who do not have some programming knowledge (basic understanding of C is REQUIRED)

Also this book does NOT use MFC or C++ for a very good reason. MFC adds too much overhead to game programming and since MOST games using DirectX run in fullscreen mode - MFC is USELESS for DirectX programming. C++ can also add a large amount of complexity for someone trying to LEARN game programming. While I prefer C++ myself the author chose the right language to write the samples in (why worry about inheritance relationships/polymorphism/templates etc when you dont have to :).

Many 'evil' reviewers (heh how COULD you give this book a bad rating) stated that this book focuses on Windows programming too much. Believe me that is a GOOD thing. It is amazing how much code is required just to print the text "Hello, World!" in Windows. The book gives a great overview of the NECESSARY and FUNDAMENTAL workings of the Windows API. You MUST read those sections if you have never programmed in Windows. It does help.

What Andre Lamothe does with the Windows API is build a game shell that handles all the Windows implementation details (messages etc), freeing you to work on game specific details and DirectX. He explains the characteristics of fonts, bitmaps and how Windows handles output using GDI (which leads to why DirectX is faster for games...read the book you'll get it :)

Some people have given this book bad reviews because the code samples are not done in C++ or by using the VC++ 6.0 APP wizard etc. To those people I'd like to say that all the code in this book is EASILY portable to C++. That was part of the fun of this book for me: implementing his ideas into C++ (using ADTs etc, polymorphism woohoo). I challenge those reviewers to show me any SUCCESSFUL commercial game that uses DirectDraw/Direct3D and uses MFC. Can't find any? I suppose they are the same people who think the next great first-person shooter game should be written with Visual Basic...

Also using wizards to create and maintain your code is great but NOT while you are learning a language/API. Wizards and application frameworks (MFC) can hide implementation details which doesn't help you understand the code. I like to understand what I am coding before I let a tool (VC++) help me maintain my code.

When you finally reach the DirectX section you get a clear, focused discussion of the DirectX API. I have never read a book that explained DirectDraw so well. Never.

If you want more of a reference to DirectX just download the DirectX 6.1 SDK and use the documentation provided, or get Inside DirectX, by MSPress (surprisingly good book on DirectX 5)

C is NOT dead. C is a highly portable (though using DirectX negates that =P) language that has seen use in the most popular games, i.e. the Quake line of games.

To summarize,

This book WILL teach you how to use DirectDraw using C. While the book does teach you about DirectInput (great intro) and DirectSound, its main focus is on DirectDraw (how to use bitmaps to make sprites/animation, different special effects etc).

I do recommend that you at least know C before buying this book. You don't have to be an expert C programmer but at least feel comfortable with the language. Understanding how the Windows API works (namely messaging) is also recommended but NOT a requirement (Andre does a great job of helping you here). If you know C++ then you'll probably be tempted to convert his code, I know I was - but I learned a LOT about how to use DirectX from his C code.

If you want to understand DirectDraw (before going on to Direct3D (yikes)) then get this book...

This book does NOT cover advanced topics but this IS a dummies book after all...

For a good reference book, check out Inside DirectX; while not a tutorial it is a GREAT reference on some of the more advanced features of DirectX (especially DirectInput).

Based on the amazon reviews, I purchased both this book and Andre's more recent tricks of the 3d programming gurus. His newer and much more detailed book covers everything in this book in more detail.

Both books are definitely excellent tools for learning the basics of game design. Game programming can be extremely difficult due to the real-time nature of the application. Because of this, a good game programmer knows how to write efficient code.

My suggestion to ANY aspiring game programmers is to learn C or C++. C++ is MUCH more difficult to learn due to the added complexities of Object Oriented Design. Get comfortable with dealing with data structures (such as arrays, linked lists, binary trees) because many times efficient code requires efficient management of data.

Once you have a grasp of the language, then move on to Andre's gurus book. The learning curve will be fairly steep at first as you try to understand windows programming, although you really only need to know how to design a basic shell to create a window and handle messages.

Andre's DirectX explanations are usefull, but VERY outdated. DirectX 8.0 marks a vast change in many areas as it seems to be becoming more openGL-like.

I would not suggest that anyone writing a game today use the older direct draw 2D methodology. Instead, you can utilize the added functionality of direct3D and get access to the 3D accelerator and still create a top-view or side-view game that appears 2D. What this means is that you're working in a 3D space (x,y and z coordinates) but placing all of your 3D objects on the x-y or x-z or y-z plane and using the third axis to view this 2D plane.

Get a hold of the DirectX 8.0 SDK from the msn website. Go over the documentation and look at and edit their sample programs until you understand the concepts you want to learn. They provide you with predrawn 3D meshes in their 3D donuts game, which also contains all of the source code.

I'm actually writing my first game now after a long time of researching to make sure I do it right. The game is a simple asteroids like top-down game except that I'm using 3D ships, asteroids and such. I first learned how to render my 3D ship in a window, then learned how to move (translate) it and also rotate it by reading the keyboard inputs. I then figured out how to render a background behind the ship. The next step was to learn how to use directShow to play an mp3 theme when the level started. The next steps will be to learn how to play a .wav file when say thrusting or firing, and then editing the lighting effects of the models and the entire scene.

If you break the project down into small steps, as described by Andre, the task because much less daunting.

One last thing, C++ is definitely going to become a HUGE asset to engine and game programmers. It's portability and modularity makes for easy partitioning of tasks and reusability. Even John Carmack (Doom, Quake)is debating learning C++ as the games are getting extremely complicated over time and reusability could save him a great deal of recoding.

I'm not going to bother writing another review and include all the different things that are in this book. There are enough reviews about that. As the description says, he covers the Windows basics, sound, input, graphics manipulation, AI, physics, and much more.

One thing I would like to make absolutely clear. I own all of Andre's other books, and whenever I read reviews of them, they all seem to have several people saying one thing in common. Simply put, these people say "I knew NOTHING AT ALL about programming, and I read 4 pages of his book and was not able to write my own DOOM game. This book sucks!!!"

COME ON PEOPLE!!! That is like expecting your FIRST EVER driving lesson to make you an expert. Or taking ONE class on auto mechanics and expecting to be an ASE certified tech. It isn't going to happen.

Get real. He openly says you MUST have some basic knowledge of C. The book does not suck because some people refuse to learn. I own SEVERAL assembly language books, beginner to advanced. Most of the advanced makes no sense. Did I write reviews and say it sucks? No. It doesn't suck because I refuse to learn and expect everything to be given to me like some of these reviewers.

Windows Game Programming for Dummies is an excellent book for ANYBODY new to programming. Put it this way: I have NEVER, EVER written anything for Windows. I used an old Borland C++ 3.1 for Windows compiler, took Andre's first example, changed one variable, and made it work. If it hadn't been for Andre, I wouldn't have ever tried to program in Windows.

This book makes it so easy. If you have read his previous books, but gave them a bad review (for whatever reason), give this one a shot.

In closing, if you are considering making the move to Windows game programming, but haven't because of all the complexity, the answer is here. If you are one of these people who say "I couldn't ever do it, it's way too hard", I said the exact same thing before I tried once, and I did it. And I had NEVER done it before.

Nothing complex. No MFC, COM, OWL, or otherwise. Just the basics. And it works.

Just remember that you do need to have some C (NOT C++) experience. You don't have to be an expert, but 6+ months of experience would really help. This book does not teach you C, rather, it shows you how to apply what you have already learned.

First of all, before buying this book make sure you know C/C++. If you know C/C++ this book is an excellent resource for beginning DirectX programmers. The book does not cover very advanced topics but it will get you going on the right track. After reading this book you should be very familiar with DirectDraw, DirectSound, and DirectInput; these skills will allow you to make rather complex applications in a short time. If you want to learn DirectX programming, this book is a great place to start.

Andre Lamothe knows his stuff. There is no doubt about that. This book is an excellent tutor and will successfully introduce anyone with some knowledge of C-programming to the fundamentals of DirectX, excluding Direct3D. I never had any trouble digesting his examples or explanations. He is very lucid and straightforward, speaking from experience in every instance, giving the reader advice tempered with theory and practice. The book begins by shedding light over and teaching the basics of windows programming. Creating a custom window and handling events therein will never again become a problem. It then delves right into DirectDraw, covering all the basics of both pixelling and bitmapping, the use of surfaces and clippings. One is led so smoothly to creating animations that one hardly notices it, and all along one feels the excitement of thinking thoughts like, "Ah! With this I could...", inspiring one to experiment and even look into the DirectX SDK-documentation to find out more capabilities. The book continues by introducing DirectSound, DirectInput, DirectPlay, and even covers how to create installation programs for your games. All along, as one is learning, one finally ends up with a complete game engine -however basic- that almost completely encapsulates the complexities of DirectX. Finally, Lamothe offers some great theory on game-physics and artificial intelligence. Nothing is perfect, however, and unfortunately neither this book. The reader will undoubtedly have to think for hirself along the way in order to make some code workable, depending on compilator and system. One flaw that I myself never managed to solve on my system is the usage of more than 256 colors. In this case, Lamothe neither gave me workable code nor explained enough to help me make this work on my system by myself. Further, a topic which was left out that I consider important was that of tiling and creating scrollable scenarios. One is left at the end of the book with only one-screen, static levels. Nevertheless, three factors make this understandable: 1) Lamothe had a limited page-count to fit all this knowledge into, 2) It is an introduction to DirectX, and obviously cannot cover everything, and 3) To write code that is workable within every concievable system is an impossible task. To sum up, Andre Lamoth offers the reader a great book! This is not your average "for Dummies" book, and certainly it shouldn't even be called thus. It will get you well on your way to understanding the complex DirectX-API. The rest is up to you. A wonderful beginner!

Windows game programming for Dummies was the first book that I bought that taught me a little about DirectX programming. I must say, it is an excellent read and the sources and executables that the author provides are very helpful in creating a few games. To tell you the truth, this book is geared more towards beginners, like me, who just want to know what makes DirectX tick. If you're one of those "C++ Gods" that beleive they could write Quake in just a few days with a few lines of Assembly Code, then get another book. The book's only drawback is the fact that after the author explains the details of DirectX, he provides a game engine that insulates the average programmer (like myself) from having to handle the details of DirectX. This is an advantage in the fact that you can go ahead and start programming your own games quickly. However, I found myself skipping a few chapters at the end of the book to see what the new features of the engine would be and, as a result, passed off everything else as a reference. Still, this does not detract from the usefulness of the book. If I ever want to go back and write a few wrapper functions of my own to make my game programming go along a bit quicker, then I have a good jumping off place. Overall: This is a great book for the beginner.

I have read several dummies books in the past and quite frankly I told myself I'd never purchase a 'Dummy Book' again because I thought they were all just terrible, and only successful because of the marketing team at IDG. :) But I had to purchase this book for one of my classes in college. I was actually suprised that it wasn't bad at all and quite good. The writing style is pretty clear cut with no ambiguity. A good brief overview of DirectX. In some cases the author is not very clear about things because he would have to get into lengthly language sematics or OO abtract concepts like COM but if you know C or C++ with Data Structures you shouldn't have any problems with this book at all. In fact, if you are an aspiring game programmer this is probably one of the best books to get your start in, you can then move on to more advanced stuff later like 3d programming.

This book will not teach you C or C++! You have to already know it and contrary to the cover stating that you need a little C (probably there to generate sales), you should at least know data strutures (stacks, queues, linked lists, binary trees, etc...). If you know that you won't have any problem with this book and you can breeze right through it and you'll be writing video games in no time, but not 3d games it does not cover that. The reason why I say having data structures is important because it was proven in my class, the only students remaining in the class at the end of the semester had a data structures class already or were concurrently taking one. Everyone with just a C class or some C experience dropped.

My only complaint with the book was that in some sections the author would just skim over material sometimes not providing any explaination on what is going on. But if you know how to research you can find it elsewhere which is usually a trait of a successful developer.

I've outline my opinion on the requisites to this book and hopefully will help you in your buying decision, I definately recommend this book even if you want to just write games for fun or just want to see how it is done.

This is one of the best programming titles I've read, for someone who knows 'C' and a bit of C++. It covers most of the basics of Windoze programming (enough to get you going) and then covers DirectX quite well.

The title is a mistake. It is not "for dummies" (e.g. a beginners primer). If you have little or not programming experience you will get lost very quickly. It also undersells the book - it is a good book for experienced programmers who want to tinker with DirectX.

The *only* flaw I could find was that Lost surfaces don't appear to be mentioned, or handled by the code. It would be nice if Direct3D was covered, but this would involve the book being 6 times its current size.

If you want to learn 3D, read the author's "Black Art" book which is Dos-based, but very good.

This book is not a COMPLETE guide on writing games in Windows. It would take an entire library to handle such a topic in a thorough manner. Rather, this book gets you started down the road to windows programming and directx. Be forwarned, though, that there are a few errors in the code listed in the book (a missing (HBRUSH) cast being the most notorious), and that the final result of the book is a directx wrapper that is supposed to be a game engine. On the plus side, this book has the single best windows api crash course I have read to date, and Andre has a great style of writing, so you won't get bored with the material. You will learn the BASICS of directx, but will definitely need to suppliment your knowledge with some other source (I suggest the internet).