Customer Reviews

Macromedia Flash MX 2004 Game Design Demystified

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

 

 

First off, I loved Jobe's first book (Flash MX Game Design Demystified). It was full of concepts for motion, collision, physics, A* Path finding as well as applied Actionscript code. EXCELLENT!

So I was very eager about the additional new concepts and applied game development in this Flash MX 2004 Game Design Demystified -- things like what performance tweaks for Flash Player <7 will now screw up for Flash Player 7. squeezing more game power out of Flash via Java or Director, actionscript performance profiling, more benchmarking normal AS2.0 script vs hand-rolled FLASM, more multi-player projects on other platforms besides Electrotank's multiplayer server, et al.

I didn't find it here.

This felt like it was a lateral move translating AS1.0 into AS2.0.

IMHO, if you _don't_ have the original Flash Game Design Demystified book _or_ you feel you would have a hard time converting AS1.0 code/concepts into AS2.0 code, then I'd recommend that you pick this book up.

Flash is one of the easiest tools to make games nowadays. With that book on hand, this task becomes child's play. Jobe Makar has a fantastic didacticism and he still manage to write a pleasant text. It is not necessary to be an advanced programmer to understand the codes, by the way, with the visual examples, even designers pursuing the basics of Actionscript can learn the hints. After reading the book, the reader besides being qualified to project you own game, he will be much sharper in Actionscript 2.

The book begins with a short introduction on how to plan the concept of games: choosing a theme, a gender (action, adventures, cassino and so on), defining the technology, the number of players, to know the audience and calculating the hardware requirements. That part of the book is weak and the author admits that this is an annoying subject for him.

However, from the moment that he begins to speak about programming, his enthusiasm multiplies by one thousand. The guy was graduated in physics, then he knows how to explain comprehensive all those formulas that we learn at the high school without knowing why.

If the book only had this part, it would not lose a lot. In fact, it would be even more interesting, since the title of the book could be "Flash MX 2004 Game Development Desmystified". Concept and design of games are subjects that would deserve a exclusive book to them.

Holding on, the author approaches the necessary math and physics to create dynamic games that simulates real world characteristics. He teaches tricks to simplify some formulas, reducing the workload of the processor. That is descisive for Flash games, since Flash Player is much slower than other platforms (Shockwave, for instance).

The code that he prints in the book is highly visualizable, in other words, it is not necessary to be in front of the computer when reading the book. He explains in long paragraphs what each code line is doing, but without being annoying. Measuring the reader advances through the pages, he doesn't waste time repeating what it was already several times repeated.

The code is all object oriented Actioncript 2. But don't worry, you only need to have a basic notion of variables, operators and the concept of functions, only. The rest he will teach little by little, showing the advantages of the technics.

By the way, it is very important to program games with object oriented programming. As we progess improving code to get it more efficient, we only need to change the value of one variable in one place and the whole code of the game is in the first frame. It is not necessary to open movieclips, seeking for that damned code that do some undesired thing. And I'm not talking about the size of the code that decreases and the legibility that increases.

Ok, now we're going to say the practical things. The book will train teach you how to:

* detect collisions among objects (it is not simply as using hittest() function)
* project reactions for the collisions (billiard balls colliding)
* control objects through the keyboard
* build an isometric world (that panoramic 3D vision)
* manipulate objects in that isometric world
* create artificial intelligence for enemies
* optimize sounds and images

The third part of the book describes step-by-step the building of four games:

* Word Search (high algorithms)
* Multiplayer chess online (through socket server)
* 501 Darts game
* Cone Crazy (drive a car in a 3D environment and hit cones like a lunatic driver)

The last one is the most interesting and the more complex. However, all the concepts applied to this project was extensively elucidated back in the book. Therefore, it is easy to understand and the results are impressive. For speaking the truth, it is the only game that meets the requirements of the advergames market, those games used for branding.

It's worth to remind that the source-codes of all the examples that the author uses in the book are contained by the accompanied CD-Rom. The code is well commented, allowing you to alter parameters and quickly see the results. There are still some bonus game in the CD, not too much special.

I found this book great to learn programming basic game physics but it is certainly one of the worst book to pick if you want to upgrade your ActionScript knowledge from 1.0 to 2.0.

The source codes are ALMOST NO DIFFERENCE from ActionScript 1.0. It is almost as if the arthur thinks that by adding variable declarations, ActionScript 1.0 becomes ActionScript 2.0.

No true Object-Oriented Programming practices (which is the true strength of ActionScript 2.0) at all. The coding style are simply ActionScript 1.0 structure (with variable declarations).

Still, this book is great to pick if you are new to game development. However, be aware that this book is NOT demonstrating how to program in ActionSctip 2.0 properly.

This book is worth reading if you are trying to develop flash games but don't read it as your first book on the topic ;) It gets into pretty advanced stuff that if you know nothing about Flash or ActionScript you will get a headache. I bought 6 Flash game dev. books and I think I tried to read this one second or something....I quit it and had to read the other books and then I read this last instead :D

Still, I'd recommend it if you are trying to make a flash game beyond 'click the monkey'... ^_^'

This book does not use the typical approach where various games of increasing complexity and size are used to explain concepts throughout the chapters. Instead, part of the book is dedicated to small games pieces or recipes and another to full games. In any case, there are many areas of Flash game programming that are covered. Some of the topics include game math, level editors, artificial intelligence (AI) and even multiplayer games. Of course not ever topic is covered with as much detail as others. But, plenty of references to both web links and books are provided throughout the chapters and in the appendix for more information on certain topics. The book includes a CD with demo software, game files, PDFs and other various files.

The first chapters (Part I) start with an introduction to gaming, including terminology and genres. Then is a description of Flash's capabilities and limitations. Surprisingly, there is no basic introduction to Flash or ActionScript that is frequently seen in other books. The rest of this section is dedicated to general development issues including game design and planning.

The core material of this book was cover in Part II (Chapter 3-14). Here many of the fundamentals of game programming were explained through small example scripts and incomplete games. Game math is one of the first topics introduced, followed by physics and then collisions (detections and reactions). Following the math and physics related scripts did get a bit difficult at times. However, full understanding is not necessarily required since the many scripts provided can be easily implemented into other games. Also, the PDF files on the CD consisted of some of the equations used in the scripts with the math worked out in pencil. Aside from the math intensive chapters, there was still a lot of useful material in the remaining chapters. The chapters on tile and isometric based games provided good information on how to handle them more easily and efficiently. In addition, the chapter on AI was original, since it covered maze creation and path finding as well as the usual enemy attack/pursuit scripts that many books focus on. There was even a decent, although single and short, chapter on sound, including using it in Flash and creating your own. All the material in these chapters were explained in detail and included numerous images.

The final part of the book concludes with discussion on several full functioning games. There is one game for each of the remaining chapters (15-18). Not all of the code from each game could be discussed, as the chapters from Part II took up the bulk of the book. Nonetheless, the key areas of each game were described in detail and the .fla source files on the CD did include comments. The CD also provided additional source files for a handful of full and incomplete games. Still, the games in these chapters were each complex and large enough to have warranted more coverage. The multiplayer chess game, which used a socket server (Chapter 16), could have definitely benefited from more content. Ultimately there were probably too few pages to fairly discuss the games in the final chapters.

This book is certainly not for a beginner, since it does not have a Flash or ActionScript primer that most of these books would include. On the back cover it is categorized as intermediate to advance and I agree for the most part. It was at least a notch above in difficulty from beginner level books I have read so far. However, with little coverage on object oriented programming (OOP), it probably can not be considered a true advanced book. Some of the examples did use exported class files, but actual discussion on them was limited. In the end, I found the middle part on game pieces to be more helpful. Nevertheless, "Macromedia Flash MX 2004 Game Design Demystified" is still a good book and will work as both a reference and a standard guide.

Rating: 4/5

I was hoping that this book would shed some light on how to apply practical mathematics to AS2.0 in order to produce some realistic effects. It provides a good start and even gives good descriptions about the inner workings of some of the concepts.

I took two years of H.S. physics, trig, and calc and I still find the explanations lacking for those of us that require the "why's" to all our questions.

The examples on the CD are extremely helpful IF you understand the code. Sorting through the files to find the code is hard and some of the files seem unfinished.

I would get this used if given the chance to do it all over again.

I would suggest any books by Colin Moock or the Robert Penner book "Programming Macromedia Flash MX" over this book. I bought this book because I hoped it would explain some physics applications that I was having trouble with and because it dives into topics like multiplayer games. To be fair, I haven't gotten to the multiplayer games section yet, so it's possible that that part is clear and useful. The physics part is only helpful if you are content to simply copy and paste code into your flash apps. I'd like to really understand the topic at hand and for me this book failed miserably.

1. This book is poorly edited. I know it is difficult to make sure there are no typos when you're reading through code examples, but somehow O'Reilly press gets it done very well. I found several examples in the first few chapters, some of them actually interfering with my comprehension of the text.

2. This book does a very poor job of explaining complicated topics. In some places, the authors suggest readers turn to pdf files on the included cd for further explication. The pdf files I looked at, however, were simply scans of handwritten notes. This would have been acceptable to me, but the notes really didn't explain anything any more than the book or code examples did.

When explaining how to test for collisions between graphic objects, the book attempts to describe a quadratic equation. This appears to be a difficult thing to describe; however, this does not excuse shortcuts such as simply not explaining how/why the authors solve the problem the way that they do. I am particularly frustrated by an example of code in which the variables are named a, b, c, d, e, f, g, h, i, j... Yes, the authors need to create a number of temporary variables and perhaps this method was optimized. But for a didactic text? Use variable names that actually mean something, that actually convey what is being done.

Look elsewhere for your flash informationl.

Very informative as far as what it teaches, but I noticed it's written for the experienced user...so why does it come with a demo of the software you're being taught? If you're experienced, you already own it, I think.