Customer Reviews

AI for Game Developers

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

 

 

Oh dear. This is a really poor book, and I'd advise you to save your money and buy something else.

Bourg's first book on game development (on Phyiscs) suffered poor reviews for being shallow, not presenting real-world techniques, and glossing over huge gaping problems in his approach. This book has all the same problems, and even more strongly in places.

Firstly he makes a big point of saying that the book is aimed at novice developers and he will cover only a few techniques designed to get you up and running. In his list, however, he has genetic algorithms, neural networks and production systems, all of which large AI teams for major developers find it very hard to get working usefully (e.g. finding an application suited for a GA in a game is just about impossible). His approaches are in places laughable.

Secondly he then lauds completely inappropriate algorithms. His steering system is based on potential functions, for example, and he proposes this because he says it allows you to mix several different movement concerns. This is completely disingenuous to his readers. The technique is very simple and useful only when several concerns are NOT blended together. When you mix things you ALWAYS get wells-of-attraction and your characters get stuck hopelessly. Just about ANY other technique would improve on this (and there's no use just saying 'do pathfinding' either: there's much more mileage in steering algorithms).

And the final thing that annoyed me was his approach all the way along of saying 'I'm only going to show you a few techniques'. Trying to make the selling point of the book that it doesn't cover anywhere near enough ground to get your AI up and running!

Just about every chapter had significant problems in it. His knowledge of the subject wouldn't pass a sophomore AI exam (I've taught AI courses at University: I'm not exaggerating). It is full of innaccuracies (e.g. he says 'new AI' is non-deterministic, while 'old AI' is deterministic - a moronic comment).

If you are a novice trying to get going in AI, this book will seriously harm you development. Try John Funge's new book, or the new Morgan Kauffman book (you'll have to wait a few months). Even reaching through the two AI Programming Wisdom will see you far better prepared for real development, despite the odd lemon of an article in them.

Terrible and useless even for a book on AI for budding game developers. The theory and explanations in this book are sometimes decent but more often than not quite lacking. (es: in one of the first chapter the author uses Bresenham algorithm without taking the time to explain it). The use of tile based examples introduce unnecessary overhead, and the continuos attempts to introduce physics related code and references to the author's other book on game physics are just plain annoying. The range of subjects covered is very broad (chasing and evading, pathfinding, emergent behaviours, rule based reasoning, bayesian networks, neural networks, fuzzy logic, finite state machines, genetic algorithms), definitely too broad to treat each of these subject in decent depth and with clarity. Example code is of low quality and just superficially object-oriented. If you are looking for a decent introduction to game AI I recommend Matt Buckland "Programming Game AI by Example" and "AI Techniques for Game Programming".

AI for Game Developers is a book aimed at beginner game programmers that want to apply AI techniques in their games. The range of topics covered is vast, chasing, flocking, pathfinding, state machines, bayesian networks, neutal networks, genetic algorithms, fuzzy logic and more.

The authors spend time to explain these AI concepts from the ground up, with numerous code samples and accompanied by full programs including GUIs & simulations, downloadable form the book's website.

So far all good, but not really so if you look a little closer. For a programmer with more experience than the complete novice, many problems become apparent quickly:

The code listings ("examples", as the authors uncommonly call them) are lacking in many aspects. The code is of low quality. C++-- some call it, and it's an appropriate name for the code of this book (take a big program with a bunch of globals and void foo(void) operating on them, wrap it all (public) in a class, and call it Object Oriented). The principal author is a scientific programmer, which shows well since the code looks sometimes like a port from Fortran. The code is also poorly typeset, in a font almost identical to the text, which makes samples hard to spot and follow. The authors also paste huge amounts of code in the book that sometimes fill whole pages, without any apparent reason. Another little deficiency is the typesetting / overall formatting quality of the book - some diagrams are simply missing, fonts are uncomfortable (especially the mix of code & text)...

It seems that most of this book's problems are about the code, though. On the conceptual level, the book is not bad. As far as I can judge, the explanations are clear and even novices should have no trouble understanding how the algorithms work. Just look away from the code, please !!

In games, developers often concentrate on improving the graphics, because this is the first thing that catches people's attention. But suppose you've done that successfully. Beautiful, fast rendered, high resolution images. How then do you KEEP the player's attention? Especially vis-a-vis other games.

So there is intense pressure on you, the developer, to make your characters more sophisticated. Bourg and Seemann offer help. The title says AI, but this can be intimidating to some. You can instead consider this as an algorithms book, that eases you gently into what can be topics of astonishing depth. Many important ideas are covered, like cellular automata and artificial life flocking. (Surprisingly, Conway's Game of Life isn't cited.) From physics, we see the use of potential functions to control character movement. We get simple explanations of finite state machines, fuzzy logic, neural networks and genetic algorithms.

The virtue of this book is that the topics are understandable to developers. Hitherto, using those ideas would have required you to be a specialist in the fields. Crucially, there are code snippets that illustrate the core concepts of each major idea. Sounds like a trite statment perhaps. But if you have ever cracked open a monograph on fuzzy logic, say, and then tried to go from it to writing code, you'll understand the usefulness of what this O'Reilly book offers.

I found AI for Game Developers to be a great introduction to many AI techniques in the context of computer games. The book is well written, concise (as are all O'Reilly books), and easy to read. It remains accessible to novices by staying away from ostentatious academic lingo and presents the material in clear English with many code examples to back up the text (every chapter has at least one code example implementing the technique being discussed).

One of the really nice things about this book is that it presents different approaches to accomplishing the same thing. For example, chasing, evading and obstacle avoidance is demonstrated using steering algorithms, line of sight and interception techniques, as well as potential functions. The authors also show how to handle strike prediction for fighting games using two different techniques - rules versus statistical. This gives a comparison of the strengths and weaknesses of each technique.

Further, the book introduces more advanced algorithms like fuzzy rules systems, Bayesian decision making, neural networks, and genetic algorithms in very clear language with solid code examples. In fact, based on this book I'm using the genetic algorithm and neural network approaches to model adaptive creatures in a role playing game that I'm working on.

All in all, this book is accessible and useful.

I'm not a game developer by trade but I still found an excellent introduction to some interesting algorithms in this book. For me these included an introduction to neural networks (at the end of the book), probability theory, and finite state machines. I've read (and looked over) a number of books on game development and they, in general, seem to prattle on about the games themselves, or spend an inordinate amount of time on the graphics or the presentation. That stuff is important, but at the heart of these systems are algorithms animate the game and bring it to life. This book concentrates on those algorithms by expressly playing down the graphics elements.

I can safely recommend browsing this book to almost any software engineer. You may find some stuff that interests you and you can use even if you aren't a game developer.

This book gives people that are new to AI in game programming a quick start in that area. If you are interested in looking at the broad fields of AI with direct application to game programming, this will show you a bit of everything. The text is clear and doesn't require any higher understanding of mathematics than some basic trigonometry. I think that the problem most people have with this book is that none of the chapters covers its subject in depth. Thus, people looking to learn AI from this book that ignor the "Game" part of the title will be disappointed. Full C++ sample programs are available on the books web site-the book is all in C++, and you should have no problems understanding the code with moderate C skills. Bresenham's line algorithm, line-of-sight-chasing and intercepting are all explained in a pretty simple way. My biggest complaint is that, even within the construct of game programming, the presentation of Bayesian systems and probability was too short for my taste. The following is a description of the book from the context of the table of contents:

Chapter 1, Introduction to Game AI - Defines game AI and discusses the current state of the art as well as the future of this technology.

Chapter 2, Chasing and Evading - Covers basic techniques for chasing and evading as well as more advanced techniques for intercepting. It also cover techniques applicable to both tile-based and continuous game environments.

Chapter 3, Pattern Movement - Pattern movement techniques are common to many video games and developers have been using them since the early days of gaming. You can use these techniques to preprogram certain behaviors such as the patrolling of a guard or the swooping in of a spacecraft.

Chapter 4, Flocking - The flocking method examined in this chapter is an example of an A-life algorithm. In addition to creating genuine looking flocking behavior, A-life algorithms form the basis of more advanced group movement.

Chapter 5, Potential Function Based Movement - Potential-based movement is relatively new in game AI applications. It can handle chasing, evading, swarming, and collision avoidance simultaneously.

Chapter 6, Basic Pathfinding and Waypoints - Game developers use many techniques to find paths in and around game environments. This chapter covers several of these methods, including waypoints.

Chapter 7, A* Pathfinding - No treatment of pathfinding is complete without addressing the workhorse algorithm of pathfinding; therefore, this whole chapter is devoted to the A* algorithm.

Chapter 8, Scripted AI and Scripting Engines - Programmers today often write scripting engines and hand off the tools to level designers who are responsible for creating the content and defining the AI. In this chapter, you'll explore some of the techniques developers use to apply a scripting system in their games.

Chapter 9, Finite State Machines - Finite state machines are the nuts and bolts of game AI. This chapter discusses the fundamentals of finite state machines and how to implement them.

Chapter 10, Fuzzy Logic - Developers use fuzzy logic in conjunction with or as a replacement for finite state machines. In this chapter, you'll learn the advantages fuzzy techniques offer over traditional logic techniques.

Chapter 11, Rule-Based AI - Technically, fuzzy logic and finite state machines fall under the general heading of rules-based methods. This chapter covers these methods as well as other variants.

Chapter 12, Basic Probability - Game developers commonly use basic probability to make their games less predictable. Such cheap unpredictability enables developers to maintain substantial control over their games. Here, basic probability is covered for this purpose as well as lay the groundwork for more advanced methods.

Chapter 13, Decisions Under Uncertainty--Bayesian Techniques - Bayesian techniques are probabilistic techniques, and in this chapter you learn how you can use them for decision making and for adaptation in games.

Chapter 14, Neural Networks - Game developers use neural networks for learning and adaptation in games for anything from making decisions to predicting the behavior of players.The most widely used neural network architecture is covered here.

Chapter 15, Genetic Algorithms - Genetic algorithms offer opportunities for evolving game AI. Although developers don't often use genetic algorithms in games, their potential for specific applications is promising, particularly if they are combined with other methods.

Appendix, Vector Operations - How to implement a C++ class that captures all of the vector operations that you'll need when writing 2D or 3D simulations.

All the chapters in this book are fairly independent of each other. Therefore, you generally can read the chapters in any order you want, without worrying about missing material in earlier chapters. The only exception to this rule is Chapter 12, on basic probability. If you don't have a background in probability, you should read this chapter before reading Chapter 13, on Bayesian methods. I would recommend this book if you are looking to implement AI into a game without wanting a complete explanation of the theory. If a complete explanation of the concepts is what you require, you will be disappointed.

This book introduces the reader to three key AI programming ideas, broadly, movement, pathfinding, and decision making.

The movement section covers intercepting and following, pathfinding provides a lot of good practical information on problems and algorithms to solve them, and the decision making section provides a good introduction to genetic algorithms, neural nets and fuzzy logic, topics which are hard to study abstractly on one's own time (at least for me.)

There are lots of code examples, and the math is accessible to anyone who at least suffered through high school calculus, regardless of whether any useful memory remains :). The intent of the code is explained after the code snippets, which is an excellent and thoughtful addition to such a book, since so many authors write code snippets, and force the reader to thoroughly understand them in order not to miss important points in the work, even though the reader may have no intention of ever actually implementing that code, and as a result, would rather not laboriously dissect tens or hundreds of code snippets in order to understand the full work.

I bought this book because of the chapter O'Riley had on its site (Flocking) and the general experience I have had with O"Riley in the past. While there is plenty to learn from this text, its not for the faint of heart or new programer. There is a lot that needs to be done to get set up for this.

My first issue is that some of the code seems just a little too complex for a beginner. While I respect the features hes trying to put in, it can clutter up the main point of what is happening, and makes learning the basic principles harder.

It seem the writter assumes you read his other book 'Physics for game programer' since he refers to it several times.Download the sample code for the book and you will see what I mean.

Then there is no discussion of the graphic package being used. I tried to do the stuff with GDI+ and ended up switching to DirectX because the flickering was so bad. Some discussion on setting up a test and development enviroment to run these projects on would have been helpful.

Oh and it was written in C+. Okay, no big deal, but a warning would have been nice. I can handle C+, but I do my work now in C#. Since it was written in an OO language, a little back ground on system design would have been helpful too.

Asking too much? While the info there is good, there are a lot of obstacles for a 'beginner' to handle. I'm motivated though, and bought his phyiscs book just to see if it helps out any.

I'll be honest, I bought this book at a garage sale (read "at a discount"), and it was totally worth it. It's full of awesome examples of how to apply some pretty heavy concepts. However, the code examples frequently won't compile, and are replete with errors.