Customer Reviews

Programming Role Playing Games with DirectX (Game Development Series)

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

 

 

I found the 1st edition of this book to be the best book on this topic I have found. I use much of the code and many of the concepts from this book in a hobby level multi-user RPG I have written. My review of that book is attached below.

Because I greatly appreciated the content of the 1st edition, I also bought the second edition.

Basically, the second edition is the first edition updated for DirectX 9.0. The text and the code are practically verbatim with small changes here and there to account for changes in technology and probably minor improvements the author wanted to make from the first edition.

The most obvious difference (aside from using DirectX 9.0), is that the first few chapters from the first edition have been removed. The discussion on how to design rpgs from a story line perspective, intro to C++ and a few other things were removed as well as the last chapter on marketing your game.

Editorially I can see why they did that. It makes the book much more focused on the "meat" of programming an RPG using DirectX. Also, I personally barely paid any attention to those chapters in the first book anyway as I focused on the programming myself. However, I thought they added an element of style to the book that was quite nice, so I miss them a little.

In summary, this book is pretty much the same as the first edition in all of the important ways. Since I thought extremely highly of that book, I think extremely highly of this one too.

------------------------------------------------------------

Review of Programming Role Playing Games with DirectX 8.0

I had a specific objective in mind when I bought this book. I'm in the process of writing a hobby level multi-user RPG for me and maybe up to a hundred or so other players (not many hundreds or thousands). I have a solid background in C++, less so in DirectX.

I've bought many books on game programming to help me with this process and to my surprise I've found this one simply amazing while most of the others I've found to be little more than expensive doorstops. :)

Like all the books of this nature, I read it in very much a "pick and choose" manner, focusing on chapters I liked and extracted code from the CD for places where it helped me. I found the material covered and, more importantly, the code representation of that material to be extremely helpful in my coding process.

I believe the tips and code the book provides (which all compile and provide very reasonable and practical applications for the ideas demonstrated) saved me (literally) hundreds of hours of research (not to mention trial and error) finding methods that work and work well and covered all of the core components I would want in a role-playing game. It covered multi-player over the internet, 2d and 3d rendering in directX, how to construct combat, spells, chat, and inventory systems and a variety of other items.

Naturally, I had to do a lot of customization to make the game do what I wanted it to do and I had to merge several of the ideas discussed into my own framework (for example the multi player network section is covered more or less stand alone where clearly other parts of the book need to be integrated with it to form a real game), but the result is I have a basic game up and running in a fraction of the time it would have otherwise taken, which no other book has ever really brought me.

Jim Adams, Programming Role Playing Games with DirectX, 2/E (Prima, 2004)

It's hard to review programming books sometimes. After all, they're really the kind of thing that already has a target audience; it's either going to be applicable to you or it's not. From there, it's not much more than semantics.

I've read a number of criticisms of the book, and most of them seem to have been shot down effectively by other reviewers. (I must admit, I'm not using the code in its original form; I'm rewriting the engine in C#, so I can't speak to the workability or not of the included C++ code.) There were certain times where I wish Adams had gone into greater detail on certain pieces of the engine, or chosen somewhat more involved/challenging implementations (the scripting engine, especially, reads as being rather simplistic, and optimization is almost left by the wayside entirely), but it's certainly a good, solid conceptual beginning. Like most programming books that draw bad reviews, it's important to note that this is a book that assumes the reader will already be familiar with a number of the technologies addressed. In other words, if you're looking for a beginner book, look elsewhere; this is for intermediate to advanced programmers. If you are one, however, you're likely to find at least something of value here; if you've never written a game engine before, Adams takes you step by step through the process, and if you have, you might find some interesting alternative methods to try.

I found it worthwhile. Some will, some won't. Get out of it what you can. ****

I have read most of the book and I am critical of it.

First, I would propose top-down approach to explaining RPGs instead of bottom-up used in the book. Starting from the high-level overview of the game and elaborating on each component in subsequent chapters will excite the reader. The low-level details of DirectX were so boring that I skept most of the introductory chapters.

On the technical side, the book describes three tires that a game is based upon: the DirectX level, the library level when the user packs useful functionality in a class hierarchy, and the game level itself, for example maps, characters, etc. Using class diagrams would ease understanding of game architecture. Also, it was difficult to read inserts of source code in the text because of too many low-level details.

The scripting language used in many components of the game also raises a number of questions. First, it has binary format which is a bad programming practice. Using a general-purpose language would allow the programmer to reuse the experience. GnuRadio? and ns are examples of projects where Python and Tcl/Tk respectively are used to guide execution. Those languages are backed with a C-language library.

Yes. I read the reviews for this book, and was encouraged, thinking I was getting a good beginner-intermediate level guide for programming games with DirectX. Boy, when I dug in, I was almost immediately overwhelmed by the complexity of the code samples (many of which do not even compile; they use declaration types that are not supported in any includes......yes, I included all of the proper files and linked them). The author gives you several pages worth of code, saying "This class does this; this function does one thing, that function does another thing, call this function to...do whatever"...the list goes on, and on, and on. The author never goes into detail explaining what the code actually does and more importantly, HOW IT WORKS. He just says "create this object to do this, then call that function" throughout the entire book. Never does he explain what you are actually doing and why it is important. It is bad enough that he gives you pages of source code, then he leaves you on your own to make it work. His writing already assumes that the reader knows DirectX through and through. Code samples are also incomplete a lot of times and the reader is left with no clue to what a certain variable/object is because there is no declaration.

AVOID THIS BOOK. IT IS A WASTE OF MONEY.

Well, I think that this book is full of compromises today. There are great algorithms explained, and it will really help you to write your own RPG game, but the DirectX part isn't actual today. The problem is, that this book explains writing DirectX games under DirectX 9.0, but this isn't very actual and the source code in this book cannot be used for a game under DirectX 9.0c, because Microsoft changed the API in this newer version of DirectX. The changes in newer API are huge and unfortunatelly it's not about changing the name of the function, structures, parameters and constants have been changed too. The result is, that I'm unable to compile the source code explained in this book with Visual Studio 2005 Standard and DirectX 9.0c SDK, it's simply impossible to update the code for someone without the knowledge of programming under DX9.0c. Theoretical part of the book is written very well, but as I said before, most of DirectX functions explained in this book was deprecated by Microsoft in newer version od DX API. I hope that in newer version of this book (if the newer version will be made) will be the code updated to DirectX9.0c or DirectX 10.

Rarely do I order a book, receive it, read around 2/3 of it, and decide before going to bed that night that I want to return it for a refund.

Quite harsh, I know, but I have to be honest here.

The one quirk that I kept finding more and more (especially in the first 1/2) of the book is the repeated use of "I could cover this in greater detail, but there wouldn't be enough room here", or "to see how this works, look at the sample code". I know the book is rated from beginner to intermediate, but I'd have to place it much more towards the beginner side of things.

The DirectX-specific portions are completely glossed over, and although you are given the basics (how to set up an application, load meshes, render, etc.), there is no in depth discussion of how to make things better. Even as a beginner, I would gladly accept this approach of jumping in "feet first", but at the same time, I would like to learn how to advance beyond the basics. There's barely any discussion of optimization strategies and not even an introduction to anything relatively complex.

- on the role-playing side of things -

Although it gives the reader a high-level overview of various parts of a role-playing game (character attributes, spells, etc.), it's all at an extremely basic level as it only discusses using meshes as levels (i.e. no discussion of terrain algorithms, barely anything on BSP/Portals/Dynamic Loading/etc.), basic character interaction (>very< simplistic NPC's - no AI - not even in the simplest sense), basic inventory, basic spells, basic scripting.

For an absolute beginner, I would think it might be a worthwhile read, but for the motivated beginner, who actually wants to >learn< and not just follow instructions, I'd definately look elsewhere.

First off, I would like to say that the code in the book only compiles when all libraries are properly linked (NOT AUTHORS ERROR!)
Some Visual Studio users complain of errors when compiling examples. They must FOLLOW the instructions in the book to the letter if they wish to run the examples.


Back to the book. It is more or less a Direct X 9.0 version of the original. Which is a very good thing, because it allows readers to learn the latest and greatest.

The author does an excelent job at teaching you how to make RPGs. No it will not let you recreate Diablo 2 or Fable, but it teaches you the basic structures of RPGs.

With the info inside, if you really read and study it, you will be able to slowly expand your knowlage beyond the book. Go back, get an understanding (and I mean really study the concept) and soon, you will realize things that were not explained in the book. Combine it with the Multiplayer FPS book and you will be be making quality games within 3 months.

My Advice:

Do not just read, then copy and paste the samples from the CD. Type them out. It may seem longer, but few realize that by typing it yourself, you will learn twice as fast rather than duplicating.

Customize the code, when you are trying an example from the book try rephrasing the code or changing it altogether. It will let you get a good feel for the code, rather than sticking with the same way to phrase something.

Do NOT skip chapters. Even paragraphs or sentances. You might miss a cruicial step, concept or instruction that the author will not explain again.


Overall, this is the best book if you want to dive in creating a 3D game. Not just an RPG, but any ype of game you want.

I read many different game programming books. I think this one is best. However, I don't think this book is good for a beginner who doesn't know anything about game programming but C++ and Win32 Programming.

Right, some of the sample codes in the book doesn't compile.
However, I can always make the code work and run in VC++.NET after using a new project file and adding a little modification on the code, so I believe it is due to the different version of DirectX SDK you installed.

The best part of this book that differs from the other books is that the author provides a small system to write the RPG game.
The author teaches us how to create serveral different editors/sub-system to create the game. He show us about how to create Item Edtior(MIL Editor), MagicList Editor(MSL Editor, Character Editor (MCL Editor), Character-To-Item Editor(CharICS), and Script Editor(MSL Editor). I found it is especially useful to learn about desining Script Engine and Script Editor in the book. His script engine is simple and good enough so that you can define your own Script syntax. all you left to do is to implement the function that associates with Script Syntax you define and that's it.

If you are good at creating Game Editor, then you're almost good at creating games. of course, you may not able to design a good game. However, at least you will be able to implement a game systematically after reading this book.

Anyone who is serious about learning game programming should buy this book.

Unlike the stands of some others before me, you can really learn from this book if you try, and use the documentation provided with the DX9 SDK. The reason I take off one, but not more stars, is that a few of the example programs in this book do not compile as they are, there are some errors... I don't take off more than one star because this can be a good thing. You can consult the documentation, take time to make literal sense of the code, and see exactly what the problem is. Once you have fixed it, you know you understand it.

While this book does give some useful information and tips, I found that most of the code in the game library is uncommented and the functions and connections between the classes is not clearly documented anywhere (an appendex section with the classes in the library and the relations to the other classes along with descriptions of the methods and members would have been nice). Although I did read the book over about three times, when it came to coding I found that I ended up looking more at the DirectX SDK documentation to figure out what was going on than I did at the book. Considering this is the second edition of the book (the first edition covering DX8), it also would have been nice if there would have been some kind of notification on what changed from DX8 to DX9, especially in the mesh/animation area.

Everything considered, I was really disappointed by the content in this book, or lack there of. If you're going to purchase it, I suggest already being familiar with DirectX 9, having a good C and C++ background, then make sure you have the DirectX documentation at hand so you can search for information when it actually comes to coding.