Customer Reviews

Isometric Game Programming with DirectX 7.0 w/CD (Premier Press Game Development (Software))

5 star:		(22)
4 star:		(10)
3 star:		(3)
2 star:		(2)
1 star:		(3)

 

 

What a incredibly well done book! I have followed Ernest Pazera's articles and work for a very long time in the Gamedev.Net community and I will say that this book is Ernest at his finest! And with the added touch of Andre' LaMothe, it makes this book a programmer's gem. I know that there are a great many aspiring game programmers who will find this book to be the book they have been waiting for. I'll explain what amazed me about this book:

It starts out giving a short review on Windows programming, and GDC (which is good, since sometimes it's easy to forget some of the basics). It's followed with a course in DirectX, and DirectSound, which are given in a way tailored toward our goal of making an isometric or tile-based game. Then the book just takes off. You'll find wonderful chapters on isometric game design, and the overview on how to create your game engine. The chapters that follow cover tile-based programming and tile-based AI and (my personal favorites of the book) chapters on how to handle objects and characters in your game. And it's all done in a very easy to understand and straight-forward manor. He completes the book with chapters on how to make your game's transition into the world of Direct3D. I've been doing tile-based games for years, and yet I found TONS of things in this book that I didn't know. And I think that's one of the main reasons this book is so well done: it's done by a man who loves iso-game programming with an incredible passion, and HE KNOWS HIS STUFF.

I do agree with Dino, though, that one would want to have at least a bit of understanding on game programming before delving in, as opposed to hitting it right at the start. And like Dino said, it makes a GREAT reference for all of those who may have been in the business for a while.

Ernest, you've done a wonderful job on this book. Doing a good book on iso-game programming is no easy task, but you have pulled it off perfectly.

Bottom line: THIS IS A DEFINATE MUST-BUY.

OK, this is not a book for raw newbies. Given that, the basic gloss-over of directDraw and Win32 is a bit redundant. However, I found the directSound chapter useful, as most books ignore that aspect.

Given that, I will admit that I already know my way around DirectX and my current Iso project, being in Java, I didn't really need the DirectX parts. However, Ernest provides some WONDERFUL helper functions for budding DirectX programmers and doesn't hide things in yet ANOTHER framework.

When the book gets into the guts of Iso programming, things really take off. Don't expect to glean everything out of it in the first read (which, unfortunately, too many think is possible). Read it until you get the basics down, and refer to it from then on. Since reading this, I've come a LONG way toward my own Isometric engine, and am still impressed with the information I can glean from it daily. I refer to his book at least once every couple of days.

Ernest has always been a great help to the game programming community with his online tutorials and forum on GameDev.net. This book takes his knowledge and skill and passes this information on. In a world where most game programming books are simply C++ tutorials filled with a few examples, it's good to see all the theory in building an engine in one place.

Get the sequal out, I'll pick it up too.

Richard Ashkettle (aka Eboz)

I bought this book because LaMothe was the editor, and i thought he actually made at least some suggestions to the writer.

I won't take your time, so here it is:
Good:
-Covers everything needed for a basic game, for beginners.
-Couple good ideas, like mouse-mapping, path-finding
Not Good:
-Part I:First 230 pages are about windows programming, an ISO book should not cover 'my first windows program' topics...
-Part II and III:This supposed to cover the ISO stuff, from basic to hardcore (only the basic is there)
-Part IV:World generation and Path finding (the only good stuff in the book)

Recap: The author handles the subject as Civilization II was the ONLY ISO TYPE GAME, and Fallout, Diablo does not exist, however the introduction states you will learn the secrets of creating games like NOX (Diablo clone). Explanation of seamless tile generation is lame (not the real deal), does not cover any of the 'interesting' topics, like: wall transparency, rendering of large objects, different types of scrolling (character centered, character framed), and so on...

Suggestion:
-If you want to write a small, turn based strategy game (definetly with flat tiles), and you are a beginner with programming and windows, buy it.
-If you want to write a Fallout or Diablo-like ISO game, do not buy this book, you can get all the basic info this book cover from the net...

I think i will write a similar 'book', and put it to my webpage, only that will cover all the stuff this one left out...

Edocecrous
System/Game programmer,
Mynergy

Isometric Game Programming with Directx is a perfect read for the Intermediate/Beginner game programmer wanting to program a game using the unique style of an isometric view. Isometric games are now traditionally used for RTS games and RPGs such as the Diablo series. Through the first few chapters Mr. Pazera explains how to set up a win32 program, and shows the ins and outs of win32 graphic programming like GDI and such. After that, he goes into DirectX with DDraw and Direct Sound. All this information is for setting up what the book is really about, Iso Programming. The next several chapters shows the techniques of Iso games, specifically tilebased fundametals with rendering. You can tell that the author knows his stuff, as he covers almost everything that comes to my mind about Iso engines. Finally, the last few chapters goes over how to incorporate direct3d with iso programming. It's a short section, but enough to get you started with direct3d. I recommened this book for anyone that is interested in this area of programming(iso, tile, or hex based games). Overall, it is a very easy read and the source is well documented. TANSTAAFL knows what he is talking about, and his writing style is friendly and not dry at all. Two thumbs up! =]

This book is a must have for anyone who plans on writing an isometric based game. It covers the basics of isometric, various techniques used by more advanced programmers, and explains the theories behind some aspects of isometric game programming. Even though you may not use DirectX 7, it is very useful as a reference guide and most likely you will learn something new from this book.

The bottom line: Use it as a reference book for you more experienced programmers or as a tutorial for all you new programmers. Either way, I highly recommend having it and reading it.

Happy Reading and Kudos to Mr. Pazera.

This is a good buy if you need to know the basics of tile plotting, drawing, world coordinate systems, map coordinate systems, and moving about a map. The code is laid out in such a way that if you follow along closely you'll be able to understand what's going on fairly easily. Earnest does a good job explaining what his code is doing and why it is doing it. However, once you get a good understanding of exactly what needs to be accomplished and the steps to making a tile-based game (like a RPG or a RTS), then I would recommend scrapping his code and replacing it with your own, more optimized code. Granted, his code is very easy to understand and that's the main purpose of this book, to let the reader (you) understand exactly what's going on and leave further optimizations up to you once you understand it. If you were to make a large game project, however, his code would not be useable. It seems to be bulky and slower than it should be.
The Tile engine that you construct throughout the book is suppose to be mainly geared towards making isometric maps and it covers three different types of Isometric maps: Diamond (like in Age Of Empires), Staggered (like in Command & Conquer), and Slide maps (I have no clue who uses this type of map). The book also talks a little about making a Hex map, and a rectangular map (like WarCraft II & StarCraft) but not enough to base a whole game upon what this book talks about. In the end, the book explains how to use Direct3D to render a map. This information on 3D is almost useless. First he uses Direct3D7 instead of DirectXGraphics and he had time to use DirectXGraphics because it had already been released by the time this book was written. He simply neglected to use it. And also, it seem the code is only geared toward rendering a map in Direct3D, and nothing else. Well, my friends, rendering a map is only a small peice of the puzzle when making 3D games.
This book is also full of the useless n00b stuff that seems to waist pages in all the prima tech books like setting up windows, understanding simple Win32 API basics, windows message loop, buttons, menus, dialog boxes, understanding COM architecture, etc, etc, etc, etc, etc.
I recommend this book for all of those who need to get a good understanding of tile-based games. However, if you already know the basics of rectangular and isometric games, then don't buy this book!

This is one of the most well written, easy to understand game programming books I have come across. The author obviously knows the subject matter quite well, and knows how to present it in a clear and consise manner.

If you're a competent C/C++ programmer, but just getting started in game programming, this is a great place to begin. Although the focus of the book - isometric games - is a bit narrower than books like Tricks of the Windows Game Programming gurus, I think you'll be more satisfied with the look of the isometric games you create. In addition, the basics of DirectX and Windows programming are covered in a very understandable manner.

If you're already a game programmer, and just want to pick up some iso techniques, feel free to skip the first part - there's nothing new there. Although the book's title includes "DirectX", the isometric algorithms are not API dependent, and can be easily adapted to other APIs (I was able to convert them to OpenGL in a matter of hours).

My only complaint about the book is that the author obviously lost steam near the end, with the number of demo programs and code samples dropping to a trickle. This also means that there is not a complete game included with the book. However, there is enough good material otherwise that I'm not going to count that against it.

I have to recommend against purchasing this book, even for absolute beginners. The book leaves out far too much important information, focusing instead of aspects of isometric game programming that most programmers could figure out themselves in a few hours (or via a search on google).

For example, consider object selection. The author spends 23 pages on "simple object selection" - basically, figure out which tile a user clicked in and then figure out which units are in that tile. However, the really tricky part of object selection comes when objects are taller than one tile (which is very typically for isometric games; that's what creates the illusion of depth). The author only provides 7 pages on this topic and the lead-in paragraph here is "Since I spent a great deal of time on simple object selection, I can only really give you an overview of pixel-perfect object selection..."!

This is a common occurance throughout the book. For example, the important concepts of "fog of war" and "fine object placement" are mentioned, but no algorithms or code examples are provided.

As a beginner you may think this book will be worthwhile anyway, but trust me, it won't - you'll very quickly want to start working on more complicated concepts and this book will provide only frustration in those areas.

In a few sections, the book admits that it doesn't provide algorithms for real-time strategy type of games (which require complex object selection, fine object placement, etc.). Most of the examples seem to focus on traditional turn-based stategy games (think Civilization). So - if you're implementing a Civ-like game and not interested in branching out beyond that, this book may be worthwhile (hence the two stars instead of one), but if you're anything like me you'll want to expand your horizons beyond that and this book will leave you very frustrated!

I enjoyed this book so much that I just couldn't put it down for two readings. Mr. Pazera manages to cut through the dense fog that usually surrounds books like this. The examples are many and well written. The style is witty but to the point. Here is an author that I would truly like to meet in person. He tackles a subject that could be a tangle of math and myth and puts in plain english and a lot of well commented C. It is such a joy to study, that I can hardly wait to put the code to use in my own projects. I look forward to mare books in this series from Prima publishing.

This my first review for a book. I am doing this for this book because it is the best, in my oppinion, book in the Game Development Series.

The source code is excellent except for that he didn't have a final project really, but that little problem is overcome by all the better parts. One thing that blows my mind is a tileset class that makes loading tilesets easier than pie. He starts it out with an intro, which is very breif but good for non-beginner programmers.

Beginner programmers might have a little trouble understanding the windows intro so that's just a warning. All of the algorithms are great and there are great functions included that make scrolling and isometric a lot easier. The scrolling and tileset classes can be applied to other non-isohex games too. The detail is amazing. He'll add those little details that most books don't. The book is not one to be used as a reference though. I highly recommend using this with some other great books such as Tricks of the Windows GPG by Lamothe or if you want to learn some good 3D, try The Zen of D3D or Beginning D3D.

Overall it is a wonderful book and should be put in ever household!

NOTE: For all of you who don't think isometric is for you, there is more to the book than just isometric, even though that is most of it. I didn't think so either until I read it. Read it to create visually amazing games with good AI and graphic setup and management.