Customer Reviews

Programming Role Playing Games with DirectX w/CD (The Premier Press Game Development Series)

5 star:		(14)
4 star:		(3)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

This is a great book for anybody thinking about programming RPGs... And even if your not going to I would at least try to take a peak at the book and think about buying it.

First off the book assumes that the reader has a through knowledge of C programming and that you have some experience with coding. And has, like the rest of the series, quite a few pages devoted to C++... (The best thing with this book is you actually make a rpg game following the book and it's practices!)

The first part of the book covers what is role-playing, desiging role-playing games and some basic story-telling. The Jim covers basic programming with C++ as well as some engine architecture that is different from most other books - ex. Tricks from the Windows Game Programming Gurus. It introduces concepts like state managers, process managers and data packages - some great stuff for programming big games. The third part covers basic DirectGraphics concepts ("a whirlwind tour", according to the author). The code does the job really well and the concepts are well-explained.

After that the book covers information about DirectInput and DirectSound, the chapter on DirectInput includes information on programming joysticks, and other information in the book includes: wrappers for Direct3D, DirectSound and DirectInput, and followed by that, octrees and quadtrees, 2d tile engines, mixed 2d/3d engine, collison detection and so on.

The only problem I see is some of the real super newbies will see the book go at a fast rate... It has great explainations but he does move fast. And the author likes to leave out the obvious - so you have to pay attention in the beggining or you'll be turning pages back into the book to see whats up.

Basicaly, pick up this book if you are starting DirectX, pick up the book if you plan on crreating RPG games. The book is great, you'll have a working RPG game after going through the book, you will learn alot about DirectX and storytelling at that! 5 Stars.

I don't have many books about programming, but this one is awesome. You've got whirlwind tour to all aspect of directx before learning about rpgs. This book is a good one to start learning directx. Buy it!

Here is the TOC:
Chapter 1 - A World of Role-Playing
Chapter 2 - Exploring RPG Design Elements
Chapter 3 - Story-Writing Essentials
Chapter 4 - Starting with C++
Chapter 5 - Programming with Windows and Application Basics
Chapter 6 - Drawing with DirectX Graphics
Chapter 7 - Interacting with DirectInput
Chapter 8 - Playing Sound with DirectX Audio
Chapter 9 - Networking with DirectPlay
Chapter 10 - Creating the Game Core
Chapter 11 - Using 2-D Graphics
Chapter 12 - Creating 3-D Graphics Engines
Chapter 13 - Mixing 2-D and 3-D Graphics Engines
Chapter 14 - Implementing Scripts
Chapter 15 - Defining and Using Objects
Chapter 16 - Controlling Players and Characters
Chapter 17 - Working with Maps and Levels
Chapter 18 - Creating Combat Sequences

Chapter 19 - Getting Online with Multiplayer Gaming
Chapter 20 - Putting Together a Full Game
Chapter 21 - Marketing and Publishing your Game

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 programing 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, focussing 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 componenets 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.

The book delivers as promised. By the end of the book, you have a full working RPG mini-game that should help any developer get past the beginning stages. This book doesn't do everything for you. It puts you on the map. If a reader takes the time to understand the given code and READ the book, there will be gains to be had.

The author does go into some basic ideas at the front of the book, but I don't feel the technical material covered is enough to completely educate a pure novice and is too simple for an intermediate programmer. Although ineffective, I don't subtract from my review ratings for additional information.

I felt the author's technique was pretty well thought in this regard however. Someone reading the book finds the foothold where they first understand everything easily. This allows the author and reader to find the common stride needed for the reader to move forward.

There is some issues with the book code that had to be solved, but the author has a website with all the changes. The big problem is more Microsoft's fault rather than the author's. The book was released with DirectX 8.0 and the MS team decided to change a few things with DirectX 8.1. Not to worry, the author has updated his entire book code with an easily downloadable patch.

In Summary,
Best book I've read so far. From Graphics, Sound, Networking, Input and much more, this monster of a book will make you a better game programmer if the time is spent with it. (Beginner to Intermediate C++ knowledge required. A small trip through the DirectX SDK tutorials a plus.)

OK, first off, I have not been fond of Lamothe, or the PrimaTech series in the past. Everyone knows by now that you can get most of the information in the older ones straight out of the DX docs. I almost totally built my first 3d engine in this way, straight from reading through the DX docs and looking at the samples. Now, that is where I find this book shines. I had a few things that I needed some extra help on that are not well documented elsewhere, and I found it here. Advanced topics such as collision detection, skinned meshes, and more are all here.

I will admit, I will probably never read the entire book. It covers the standard n00b stuff that no one wants anymore. What it DOES provide is a valuable reference book and samples to look at when I run into a problem. It covers pretty much all aspects of game programming, and they can be applied easily towards other types of games. (I am actually using certain things from it for my FPS).

So here's the lowdown: Great book, some useless stuff, but there actually is USEFUL stuff. I'd buy it if I were you. Advanced topics are there, and the author does a good job with them. The other books you should look into are Multiplayer Game Programming (by Todd Barron), which is not bad, but could be more advanced, and I hear Isometric Game Programming (by Ernest Pazera) is good, and what I have seen seems good.

All I can say is, of all of the game programming books i've seen, this one is #1! All of the samples are excellent, and work. The final game, The Tower, is impressive for a game created for a book, although i'm sure expert programmers could improve it quite a bit.

But Master of None. Still, this is one of the better books I've read in the Prima Tech series. It starts off with the game development theory, introduces programming concepts, gets nitty-gritty with the game core, and then offers some other advice.

I agree with what the other reviewers said. This book moves FAST. What other books in the series does in 5 paragraphs this book does in about two sentences.

What I didn't like was the fact that it really glossed over some of the advanced DirectX graphics stuff, like multitexturing. That shouldn't be too much of a problem though if you pick up another DirectX book, but it would have been nice had the author included it here.

If all you want to do is to make simple RPGs this book comes very close to being the all-in-one that you are looking for. However, game engines are rarely just bunch of written functions. If you truly want to get into heavy RPG programming, you'll need to learn Windows Programming to develop your own level design tools.

Each segment has enough detail for light work and simple projects, but if you want to get more in depth there are entire books written on those topics, and I highly recommend you get them, as well as OpenGL and OpenAL books.

After finishing this book, you'll gain the knowledge of RPG development, but to seriously use it for profit, you'll need the more advanced books that I hinted above.

It might be early to write my review. I am only 250 pages into the book (1/4). I already feel I have gotten my money's worth, so now is as good of time as any to comment.

If your trying to choose either an opengl or directx book, I strongly suggest that you buy this book and learn directx. I have been using opengl for a short while, mainly because it seemed easyer to use (even though I would have rather learned directx). That's not the case with this book. The author explains the material in a way that makes directx easyer to understand. Even some opengl issues that were unclear to me have been cleared up with this book.

Overall, the author does an incredible job of explaining the material. I am 250 pages through the book and understand every bit of code. I don't think I've ever been happier with a programming book. I can't put it down.

This is definitly the best game programming book focus on direct x,I have ever read.
What I have most appreciated is its perfect balance beetwen theory and practice.
Jim Adams explains the basic of Direct x 8.0 without scaring the reader with too many details...straight to the core, we must not forget that the graphic API is just a tool for a game programmer.
you must not be a direct x guru, to write a game.
It make also an extensive use of the the D3DX library.
Why should we waste time with a bloody theory if MS provide a so advanced library for the most important and common tasks?
Same consideration for the 2D and the 3D graphic engine.
Although they are probably the most advanced game engines now available on the market ,at a semi-professional level,no even one word is spent to inform the reader ,how a smart programmer the author is...just the content of each class and its use, nothing more , nothing less...just meat.
But the most valuable part of the book are the , say , "Tricks of ..." In other word all those technics that are a must for a game programmer.
For example ,there is one whole chapter dedicated to the use of the "scripts" or to "Data structure " etc.
No other game programming book , as far as I know, even mention so important topics.
Last a complete game is supplied.
Jim is a moderator of the GameDev.net, the most important comunity on the web for game programming.
He can rely upon a huge list of FAQ'S, so he knows what a beginner \ intermediate programmer really needs, better than a professional game programmer.
My favourite book for opengl is "Opengl game programming ", also a masterpiece, also written by GameDev.net moderators

It amazes me that people post reviews stating, "Don't buy this book," or "3 stars (but should be less in my opinion)," among many others, because the book doesn't have the quote un-quote "advanced" information they were looking for. According to one reviewer this "advanced" information he was looking for was "a non-Final Fantasy type combat system." This book TEACHES you the IDEAS behind how game programming works, with an emphasis and examples on ROLE PLAYING GAMES. What's the most popular type of role playing game? Final Fantasy type. If you are an "advanced" game programmer and this book didn't help you, then you should be able to use your own knowledge and program your OWN combat system. It seems like you were looking for a book that offered the solution (combat system) that you wanted to cut and paste into your "advanced and superior code." For those that want a book to help their imagination grow and problem solving nodes start firing away after seeing some real-life examples, this book is for you. If you want to buy a book that contains code you are just going to cut and paste into your own source, then you're right, this book is not "advanced" enough.

I rate this book with 3 stars even though my own personal opinion of it is somewhat lower. As has been pointed out in previous reviews the books does cover a lot of ground and leaves you with a complete mini-game. That's why the book might be good for newbie programmers who are looking for an example of how to write a rpg. And that's what earns the book 3 stars in my review.

I just want to stress something that the other reviewers haven't mentioned - this book is *not* for experienced programmers who are working seriously on their own rpg already! It cannot be used as a reference on how to implement those things you haven't done yet because the book tries to cover so much that it only presents very specific solutions for all the topics. There is only *one* type of combat covered for example, and that's a FF7 style turn-based combat. If you're planning for something else this book will be useless for you on this subject. And the same can be said about all the other topics: item management, engine design, level management, automapping, AI etc. Each topic is quickly breezed over and then a specific solution is presented. Take it or leave it. In my case I didn't take any of them...

So in summary: Might be interesting for newbie rpg programmers who wants a guide through an example rpg. But any experienced programmer should leave this book alone!