Behavioral Mathematics for Game AI (Anglais) Broché – 5 mars 2009
|Neuf à partir de||Occasion à partir de|
Produits fréquemment achetés ensemble
Les clients ayant acheté cet article ont également acheté
Descriptions du produit
Présentation de l'éditeur
Aucun appareil Kindle n'est requis. Téléchargez l'une des applis Kindle gratuites et commencez à lire les livres Kindle sur votre smartphone, tablette ou ordinateur.
Pour obtenir l'appli gratuite, saisissez votre adresse e-mail ou numéro de téléphone mobile.
Détails sur le produit
En savoir plus sur l'auteur
Dans ce livre(En savoir plus)
Commentaires en ligne
Commentaires client les plus utiles sur Amazon.com (beta)
There are only a handful of books on AI for Games, and the techniques used in games are quite a bit different than those used in academic AI. Most of the existing books just look at the standard architectures and topics - behavior trees, state machines, scripting, path planning, etc.
Dave takes a novel approach, and looks at techniques for building heuristics that evaluate the game situation and rate the various options. This is a critical part of decision making, it is something which most games with even moderately complex AI need to do, but it is something that up to now wasn't covered very well (if at all) in the literature.
I heartily recommend this book for anybody who's interested in learning more about how to build decision makers - whether for use in games or elsewhere. The material that is here is not something that you'll find somewhere else.
Dave gives the reader a very strong toolkit for building Game AI, and by toolkit I don't mean a large library of code (although there is plenty of code) but fundamental knowledge, such as the concept of utility and how to apply it in a very practical way. Starting from simple example decisions he builds up to much more complicated cases, constantly tying everything back into practical applications of all the concepts he introduces.
Now, I don't mean to imply that this is some dry math book. Dave constantly sprinkles in his very unique brand of humor and ties in family stories that help cement any topic he's trying to get across. I would highly recommend this book to any professional or aspiring AI Programmer, or even just a player who wants a better understanding of whats going on under the hood in his favorite game.
For starters, I do programming for a living. After 10 years of .Net Web sites and databases, I'm looking to expand my skill set. Not games, necessarily, but AI for sure. I tried a couple math books on Game theory, but they were still a few levels away from practical interpretation. This book brought it down to a level I could use.
In a nutshell, it's about how to program dice for an RPG. The scope is a little broader than that, but this is the main idea. In nontechnical language, the author discusses what the goals of AI are, how rational decisions are made, and how to use probability to generate irrational decisions to model an unpredictable world.
Math wise algebra would be a good idea, and maybe some basic understanding of calculus and statistics, but he gives sufficient background so that your understanding would not be hindered. The book doesn't really teach programming per se, so it really doesn't matter what language you use (although the examples are done in C).Specific algorithms, such was swarming and flocking, are also absent. The material here would be used after you have those ideas down...for example, you have your agents flocking, so now how does the flock decide what to do, and when?
This brings me to the one real draw back to the book. I could tolerate his jokes and stories about his kids, but I suspect some UMLs would have done wonders to make the material clearer. Use cases were almost there in his examples, but it just missed the mark. Maybe this was an attempt to keep the thinking less technical and open it to a wider market, but it is something he should have touched on.
I really didn't learn anything new, but rather, how to take a bunch concepts I was already familiar with and bring them together into a cohesive unit. It's got me thinking and planning and trying to figure out how to put it in to use. This is good. This is what the writer wanted.
So, I would recommend this book if you're at the point where you have your AI agents working, but you want them to be more flexible and unpredictable in their actions, or react with more independently to their environment. IF you check the price of this book on the secondary market, you can see its doing pretty well as a used book, which says a lot for anything in the technology field.
If you're looking for good descriptions of challenging topics, this is not the book for you. The diagrams are often confusing (inverting the x-axis for questionable reasons), the code takes up far too much space for the value it is supposed to convey, and the prose is bloated.
The author early on makes the distinction between "proscriptive" and "descriptive" mathematical models - making the point that we're not necessarily trying to find optimal behavior, we're trying to record plausible behavior. This is a reasonable decision, but the amount of work necessary to model the author's favorite example of "4 out of 5 dentists recommending sugar free gum to their patients that chew gum" seems overwrought for what could be accomplished in one line of code.
The author invents a term "response curves", which seems like an awkward name for a selection from a weighted list. He claims that these are necessary, because algorithmic functions don't offer enough flexibility to achieve the results he's looking for. His response curves are piecewise constant functions over a finite domain, and if you want the flexibility of his response curves without the discontinuities, look up splines - well understood, and supported by many libraries already.
The book lurches from dwelling on some easy ideas (scaling the output of a function to be between 0 and 1 and weighted averages) to briefly touching on more complicated ones (marginal utility). The easy ideas are rehashed several times, while the difficult ones are mentioned, but the user is left to figure out how to apply them in their own work, as the author concedes that each application will be different.
In several places in the code, the author omits constructors and destructors, so as to keep things clear, though he makes a point in both the code and the text to call attention to the fact that he's omitting them. Perhaps the ideas would have been clearer if the author had communicated them through pseudocode, rather than collecting snippets of C++ that aren't complete enough for a C++ user to use, and are a stumbling block for someone who doesn't read C++.
Defying the admonition to not judge books by their cover, one might have looked at the poorly designed cover, with the fuzzy fonts and the impenetrable imagery, and got a hint that this was not a book that the publisher believed was worth their best effort.
Perhaps I'm not in the target audience for this book. If you know a bright child who is looking for an introduction to simple mathematical topics, and is eager to write computer games, this might be part of a bundle of books that you get them for the holidays.
This is not a book I will keep as a reference, but will be getting rid of at my earliest convenience.