This review is a work in progress as I read this book I will update this review.
Book Quality - The book is glue bound with regular printer type paper and looks as if it was printed with a regular ink jet printer. You can see the strips across the images from the print head. The images are legble for reading the words in the images fine though. Everything is in black and white. The text in the book is also a good size, not to small or to large.
There are quite a few typing errors and/or grammer, including some code that was typed incorrect
Chapter 1 - Mostly intro stuff for the book it's self, though has a section for tips and tricks which are quite handy.
Chapter 2 - Setting up a basic project and importing assets, including: Texture/Mesh/Sprites/Audio/Prefabs and building a scene in a modular fashion. Also contains information about setting up lights and simple light baking.
Chapter 3 - All about the Notification class for event management. Uses a custom NotificationManager class, which in turn uses the built in Component messaging system with unity. However this system uses a lot of strings which could be somewhat inefficient. It is quite simple which is a good trade off in many cases. Also contains some info about generics in C# namely List<T> and Dictionary<Key,Value> which are used in the event system. This system would be good for most games, though if you are making a large project with lots of messaging, you should refactor this class for optimization.
Chapter 4 - This chapter covers the pickup ( called powerups ) creation and implementation. While covering that it touches on co routines which in the use case he uses probably could of been avoided with just an Update function call, but at least they are well explained. Creating these sprites as billboards is covered. Simple collision detection with triggers and OnEnter events is used as well. After the pick ups the chapter moves on to the GameManager singleton and putting the NotificationManager inside. Overall its a pretty good chapter.
Chapter 5 - Creation of a cross platform first person controller is the main focus of this chapter. Including head bob, player events, and object collection. Also some minor discussion about OnGUI and creating a gui texture. Mechanim (unity animation system (new) )is also used a little.
Chapter 6 - Setup of the weapons. Almost everything in this game is 2d, except for the level itself and some props. So the weapons are just a 2d sprite. I'm not sure why he chose to do it this way but it just feels weird. Also attacking has no collision detection just a ray cast from the center of the screen for both weapons ( fist and hand gun ), the only real difference is the range.
Chapter 7 - Setup of the enemies. These are also just 2d sprites ( billboards ) that move around using unities nav mesh features, and a simple state machine for the enemies. The state machine uses co routines and a method for each state.
Chapter 8 - GUIs. In this chapter a custom gui system is built. The author talks about the dev community not being pleased with the built in gui features in unity, so he decides to roll his own code. Which is kinda cool and kinda not cool, depending on which route you wanted to take. If you wanted to learn about unity gui, this chapter is not for you.
Chapter 9 - Covers persistent data. Storing data on the drive in various ways to keep data from game to game or level to level. It covers playerprefs unity's default way of storing persistant data. Also it covers using mono's xml reading and writing classes.
Chapter 10 - Sort of an odds and ends type of chapter. Just a list of things you could improve on if you wanted to.
Here is my opinion of this book. It's not a pro level book, it's not a beginner book either. It's really a intermediate level book. Many of the design decisions of the game, resulted in less knowledge being learned by the reader. For example there is no animations in a 3d sense, all animations are done with 2d sprites. A unity professional would need to know how to implement a 3d animation and probably with mechanim.
The notification class uses the slow SendMessage functionality from unity. In chapter 10, he even dedicates a section to using other types of message systems including .net/mono event/delegates, and has several code snippets. He should of just used these in the first place, it's a feature that a pro would want to use, not the slow SendMessage.
Overall though the book is pretty good if you go in knowing its just an Intermediate level book. There are some typos and code errors but the source code from the site works so you can figure out the errors in the book this way. I give it 4 stars, -1 for typos and no 3d mesh animations.