1485080219 Programming Role Playing Games with DirectX (Game Development Series) - Game Programming - Books - Books - GameDev.net

Jump to content

  • Log In with Google      Sign In   
  • Create Account

Game Development Books

Top Selling Books

  • You cannot edit this book

Programming Role Playing Games with DirectX (Game Development Series) **---

Programming Role Playing Games with DirectX (Game Development Series) By Jim Adams
Published June 2004
List Price: $49.99, Your Amazon.com Price: $31.90

Amazon.com Sales Rank: 1,473,711
Availability: Usually ships in 24 hours

No game draws a player into its world in quite the same way as a role-playing game does. In role-playing games, players break through the barrier that exists between their actions and the fantastic world that they're navigating through and instead become an inhabitant of that world. Get ready to put your creative ideas in motion and try your hand at creating your own role-playing game! Programming Role Playing Games with DirectX, 2nd Edition will show you how to do it as you create cool graphics and combat engines, handle players in your game, use scripts and items, and make your game multiplayer-capable. This book breaks a role-playing game down into its essential components, examining the details of each and showing you how to use them in your game project. Learn how to draw with DirectX Graphics, play audio with DirectX Audio, network with DirectPlay,and process input with DirectInput. By the time you finish, you'll possess the skills you need to create a complete role-playing game.

Similar Books:

Buy it now:



  • You cannot edit this book


Great book if your into RPG's. I sometimes struggle with the conceptualizations on how to get specific things done and this book helped to get my head straight around topics like handling inventory, a spell system, and melee combat.

If your not a beginner then you can probably skip over the first few chapters quickly (although they are still worth a persusal to see where the author is headed), for me the book picked up around the Chapter on DirectPlay which I hadn't had much experience with.

If you ARE a beginner then this is an excellent book to pick up as the first few chapters are the obligatory intro to Windows programming followed by a clear (though quick) intro to DirectX.

When your done you have a (somewhat chessy) basic game of sorts. its a bit crude in the graphics department but since my modelling skills are only slightly above stick figures it was good enough for me. It has all the basics that you'd look for and the best part is that the author went over it all in repectable detail.

I wont give the book a 5 since it didn't dazzle me, but it was a very good book and worthwhile read.
Yes, this book was informative and interesting to read. However, skip to the end, the final project (ch 16) doesn't compile with the SDK provided on the CD (if you update to the latest DX SDK, it get's worse, but we can't hold that against the writer). The support site listed in the appendix (http://home.att.net/~rpgbook/) doesn't mention the 2nd ed, and hasn't been updated since May 2002. I tried the contanct link from that page, and have not received a response.

So, yes, it was fun to read, but becomes a complete waste of time since the code doesn't actually work and there's no support.

Author should be more carefull to make his code compiles all the way , not waisting time of Games Spec for someone who couldn't make a Tetris working , but overall very good for
intermediate C++ coder starting with DX.
Rarely do I look at a book in a bookstore, buy it, take it home, read around 2/3 of it, and decide before going to bed that night that I have to take the book back to the store for a refund.

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

The one quick 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 pieces 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), 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.

I can't comment on the samples on the CD - I never opened the CD package for the book. It's a shame too - I had high hopes for this based on the description on the back cover of the book and flipping through the table of contents... you live, you learn...
I was very disappointed in this book. I attempted to re-build the sample game and found that there were several libraries that need to be included that weren't mentioned in the book.

Plus, the code doesn't play well with the directx version that comes with the book. The output is, well, uuugly.
The content of the book is great, and it covers alot of material.
However alot of the source code isn't compilable which is very frustrating. Does anyone know if the author has an updated set of code for this book?
I encourage the author to give his code one more re-write, possibly for a 3rd Edition. I worked through the compiling bugs others have mentioned and got it all to work - mostly having to do with the D3X helper routines changing from year to year. But even after this, the code is only good up to Summer 03 version of DX9c that comes with the book. The next change in summer 04 obsoleted the authors handling of skinned meshes, and Microsoft simply says you must rewrite your code for that. And there was a tendency to use older versions of DX features, some of which are deprecated.
There was a lot of C style code - a legacy probably from the first revision.
By comparison another book - Programming a Multiplayer FPS in DirectX by Vaughn Young - is more up to date in the use of object oriented code, and uses the latest techniques for handling skinned meshes (although I had to make a few changes to get everything to run on my computer too, but far less work than the RPG code).
Like everybody else, I found all the bugs in the code to be very annoying. Apart from that though, I thought it was pretty good. The RPG stuff is all fairly easy to modify, so if you want more advanced stats and inventory systems and stuff, it's quite simple to implement.
Being a beginner at programming, I finished Beginning C++ Game Programming and was hoping to start learning how to put a game together. This book didn't help much. The 1st chapter is hard to understand and seems to be a big jump into unknown territory. It would've also been nice if the book came with a trial version of Visual C++, not the cheapest of things to buy being a teenager. I wouldn't recommend this book for anyone beginning to learn game developement.
I bought this book, when i was a beginner. The book has some good information for someone that has never used DirectX. The author explains the very bascis of each component of a game. But there is one problem. The author most of the time "dictates" instructions on how to write the code, i mean, instead of explaining why something happens or not, it makes the reader to have some faith in what is really going on. It is kinda frustating to end coding an engine exactly the same as the author's.

Anyway. For a mere begginer who has never programmed a game it is a good book, it explains some good technics for 2D grahpics(tiles, maps, etc), how does a game loop works, and introduces basic 3D and very basic scripting.

About the code, well, i never tried to compile the sources, i just run the already done exe and thats it.

Something i didn't like to much was the D3DX dependence, i mean, it uses it like if D3Dx will always fix all your problems.

I think thats, it.
I bought this book about a year ago, and read the entire thing, only to find out that half the source code won't compile. I tried contacting the author, Jim Adams, but I received no reply. I had to have a member send me the source code that he revised.

Other than that, it has good concepts, and includes a full game with the source.
I find the book kinda poor since he never explains why he does something a certain way or alternate ways of doing it. Code is nice, but ideas and methods are better. He also doesn't even mention certain aspects, especially if they are difficult or confusing even though they relate to the section he is listing code for. I haven't read other game programming books, so this may still be great comparatively.
I dont have this updated edition of the book, but I doubt it's much better from the edition I bought.
This book try to teach you how to use DirectX, but it dosent!
in almost each aspect of DirectX, the author tells you something like this: "This book dosent cover it because there is not enough space in it".
What's the deal with that?
So what do this book is trying to teach you? how to use the library that the author created?
The thing that really pissed me up is that it dosent show you how to use animated meshes because the autor was going to publish a new book about animation, forcing you to buy it...
Alot of the code in the book dosent compile, and you need to change alot of it to work.
I haven't yet finished it, but so far Jim Adams is explaining everything really well. I think that the 1st chapter is a bit difficult and tells a lot of unknown stuff, but with a little search in the web I finally understood it. Besides it's not really necessary to read it and understand before carrying on! Also, so far there's no code bugs or problems! I think that this is a MUST BUY/READ BOOK for beginners(not totally beginners, though)!

Programming Role Playing Games With DirectX is a bit of a broad subject around which to wrap one's mind. First off, there's the question of "what is a Role Playing Game", and that's not as simple an answer as would seem. While the term used to mean "a game in which you pretend to be the character and conduct yourself as such", computer gaming has bowdlerized the term into something akin to "games that take place in a medieval-style fantasy setting". And that appears to be exactly what this book is going for, although it's still pretty ill-defined. Why medieval fantasy anyway? Is there something intrinsic to such a setting that would make a book ill-suited to writing a game about pirate warfare or fighting aliens on Mars?

The other half of the title, DirectX, is a bit easier to quantify. In the case of this book, it means DirectX 9.

While I seemed to digress in the first paragraph, this problem with the title manifests itself throughout the book, and this is a problem with scope. The book seems to be heading towards something like "How to write a Diablo knockoff using Direct3D", but it gets lost along the way. And this goes back to scope. While writing a Diablo knockoff in Direct3D sounds fairly straightforward, in actuality it encompasses a great number of subjects, ranging from rendering animated objects in 3D to sound to control (joystick and keyboard) to network communications to packaging the whole thing together into a neat little bundle with an install program. And all that content simply won't fit into a single book. Even a really big book. So what you end up is not five books that cover the entire breadth of developing a DirectX RPG but a single big book that gives cursory treatment to some subjects, no treatment to others, and ultimately doesn't end up with something that's ready to deploy.

Unfortunately I do feel like this was a book that was written to justify a title intended to move it off the shelf. Saying "the scope of making a complete and good-quality RPG is simply too much for one book" doesn't sell books, but "Buy this book and you'll be able to wow your friends with your own online hack-n-slash adventure" will.

Perhaps later editions of this book could improve the situation by breaking it up and giving better coverage to the topics, but as it stands I can't recommend this very much.

I picked this book out due to good reviews on the first edition from barnes and noble ($45 with free shipping, would have gotten it cheaper somewhere else aside from the fact that I only had gift cards at the time). If it already sounds like I am displeased with this book then read on.
Just as a disclaimer, I did read a few sections from the first edition via ebook while I was waiting for this one to arrive, so a good comparison might be worthwhile.

The first thing that came to mind as I read the first chapter was "this seems oddly familiar", as it is essentially a cut-and-paste from the first chapter of the first edition, only changing the few times he references the book name to "Programming Role Plying Games With DirectX, second edition". He provides absolutely no updates on this outdated and bloated section on setting up visual studio (even visual studio c++ 2005 makes most of this obselete and unnecessary).
From there, he jumps directly into COM and a bit of poorly-placed primer on windows programming. This really confused me as to what went through his mind when he put this in such an odd place that really would confuse the HELL out of beginners (his target audience). Being someone myself who picked up this book so that I can learn DirectX for my game programming, I was quite perplexed at what he was exactly trying to say here.
Then I noticed how most of his book is just a copy-and-paste from source that's already on the disk, with a few notes here and there. One example is when he tried to describe to the user about the application framework and why it's used. Once he's satisfied with the half-page description of the idea behind it (well technically the last 2 paragraphs are about how to find the exact same thing on the CD), PLOW and you have 3 pages of source. Not just any simple demos either, he's talking about a full windows application with message loop. No windows primer, and the only 2 things he describes in the entire source are a gist of how to use the CreateMainWindow function (ie two short sentences to describe what it basically does), and the RegisterWindowClasses function with a similar-sized description. After giving us this huge (did I say 3 pages? I meant 5 1/2) block with no real description of what it does aside from the short description of "This is a basic application framework, here's what it looks like and what it does." While the only real description of how to alter anything is that he so kindly put a few definitions at the top for you to change, leading to the code itself to be very unfamiliar and the *beginner* not knowing really what everything is really supposed to do. By adding insult to injury, he ends this section with "... it's your job to insert the code that handles the initialization of objects, loading graphics, preframe processing, and so on."
Finally, I noticed an almost horrid state system. I am used to knowing them as "screens", but his gamestate system is the same concept. The thing that I hated about it so much was his stack system only allowed one state to be used at any time. This is fairly limited in practice. For example, if I wanted to place an inventory system *over* the game (ie it still renders the game, and if you wanted to make it fancy, parts of that game still update and render by using a gamestate enumeration to determine if it is paused or not), that's not viable with his current setup. In fact, if one were to learn from these limitations, it might make it more difficult to become accustomed to a more *proper* state system later on.

Still, I gave this 2 1/2 stars for its good beginner introduction into DirectX and combining everything into one piece. He gives *basic* primers on all of the aspects of using DirectX, which really helped me back into building games. Of course I am going to be picking up other books as well to keep on learning, but this book provided a decent start, it just took much more work to get things to fit into what *I* wanted to do.
Just as another disclaimer, it might sound that since I needed some beginner book into DirectX game programming, that I am surely not savvy into a game architecture. I did OpenGL programming a few years ago, but at the time I was not very proficient in C++, and so took 2 years at developing several complex games in XNA before taking another crack at C++ with DirectX. I do wish there were recommendations in general game design with c++/directx for intermediates, but I haven't been able to find anything better than decent (half the books I find use the whole "you can impress your friends by making a game!" as their only selling point).
I seriously disliked this book because he would explain the principle in like 3 sentences (barely scratching the surface), then spits out code that no beginner will ever begin to understand. This is an alright book for reference of DX libraries but is not sufficient for actually learning how it all works. I'm just glad I got it for $5 from Goodwill.