Customer Reviews

Microsoft XNA Game Studio 3.0 Unleashed

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

 

 

I have the author's first book that covered XNA Game Studio 1.0 Refresh. This book was not a simple name change - it has actual coverage of the new 3.0 topics as well as great coverage of the 2.0 topics that other books just gloss over.

There are a total of 9 new chapters in this book. These 9 chapters are worth the price of the book in and of themselves. There seems to be some changes to the original content, but just in order to make it work effectively with the latest version of the framework.

Out of the 9 new chapters, 2 are on Zune development. Once done with those chapters I had my own visualizer and ported over the 2D game I created. I tend to stick with 3D, but having a neat handheld device to create games on is pretty cool so I will probably create another game - especially if Microsoft opens up the Zune Marketplace for us to sell games on like that did on the Xbox LIVE Marketplace. In fact, 2 of the 9 new chapters discuss best practices for developing games for the Xbox LIVE Marketplace and discusses what is needed to actually submit XNA Community games.

The other 5 chapters are all about networking. It amazes me how much detail the author put into these chapters. If you are even thinking about creating a multiplayer game for Windows or the Xbox 360 or the Zune then you have to get this book just for those chapters. The first chapter is excellent information to help with understanding networks and the physical speed limitations of sending data across the internet. The next chapter moves past the theory and shows how to create a bare-bones, "just the facts", multiplayer demos for Windows, the Xbox 360 and the Zune. The third chapter of the five takes time to build a skeleton (which can be easily turned into template in Visual Studio) complete with a game lobby and session lists. All of the menu functionality is built using knowledge from the game state chapter earlier in the book. The fourth and fifth chapters actually create a turned based card game and a real-time chase/evade game. The multiplayer chapters are excellent. I wish the other 2.0 books that came out last year had spent time going through the details the author spelled out here.

I'll repeat what I said about his first book:
I really enjoyed his perspective on performance. It helped me in my day job as well ... can you say Garbage Collector? The physics chapter is great. I also enjoyed the chapter on Artificial Intelligence. Both are short, but to the point and helped me know where I need to look for more information. The particle system is excellent. I liked the force field created by particles ... cool. The chapter on the content pipeline was excellent. I enjoyed the advanced topics he has as well like Render Targets, Parallax and Relief Mapping.

So in summary, if there is only one XNA book you can buy ... get this one. You won't regret it!

The book is labeled Intermediate to Advanced for a reason.

If you look at the different reviews on the site, you can pretty easily tell which people decided - hey I want to program games even though I have very little experience in programming and those that understand topics such as polymorphism, inheritence and design patterns.

The other item I see in these reviews is complaining about the order of items. The author very plainly states why he chose to order it the way he did. Personally, this helped me a lot. I am making a 3D game currently and hope to have it up on Xbox LIVE in the Indies channel before too long.

An excerpt from "How This Book Is Organized" section of the Introduction (Good thing Amazon has a preview option available for this book):
... With a book that is designed to be read from front to back, the main drawback is a larger time commitment. However, there is usually deeper understanding by the time the task is complete versus the same amount of time spent looking at particular topics on the subject from online tutorials and blog posts. Both are very important, ...
... I do believe this book's order is important, and I did not change it from the first edition. ... The next chapter jumps right into talking about the Xbox 360. Even though there are people who do not have anXbox 360, it is important to put this chapter up front so you can be aware of certain things when creating games using XNA. It is always important to know what you are up against before you start. It is for this same reason that the very next chapter is on performance. ...
... The first real game code that is present in the book is written for 3D. Many people are shocked that 2D is not discussed until Chapter 9, "2D Basics." The reason for putting 3D before 2D in this book is because picking up 3D is not any harder than learning 2D. ... Granted, there are some complex topics surrounding 3D, and those are covered later in the book. However, by getting started by drawing models and responding to input, you'll see there is not a huge difference in the knowledge need to write 3D games versus 2D games.

If a person does not actually read the book in order as it is intended, then it can definitely appear to jump around. However, if you spend time on each chapter making sure you understand the concepts being presented, the following chapters make a lot of sense. This book gets 5 stars from me.

Also, on the authors website XNA Essentials he is active in answering questions on the forums.

I have 3 other XNA 3.0 books besides this one:
Learning XNA 3.0: XNA 3.0 Game Development for the PC, Xbox 360, and Zune
Beginning XNA 3.0 Game Programming: From Novice to Professional (Beginning from Novice to Professional)
XNA 3.0 Game Programming Recipes: A Problem-Solution Approach (Expert's Voice in XNA)

If you are new to programming - get a C# book first. Perhaps, Mile's book Microsoft® XNA® Game Studio 3.0: Learn Programming Now! (Pro - Developer) would be helpful as it assumes you know very little. I've not actually looked at that book, but since it has "Learn Programming Now" in it's title, my guess is it would be a good place to start.

The recipe book is good once you are really familiar with XNA. It would be a good book once you are done with this one - or once you are comfortable with the content of this one.

The other two books are probably decent for those in between. I learned something from all the books, but I learned the most (by far) from this Unleashed book. I like the title Unleashed, because it covers ALL of the features of XNA Game Studio.

Speaking of XNA Framework features, If you are even considering adding multiplayer functionality into your game, you need to buy this book.

Just remember, you will not learn everything about any subject just by reading one book. Like I said, I have several of them and I have learned something from all of them. If you are serious about this, then you will need more than a single resource. For free resources check out Ziggyware and of course the XNA Creators Club website. There is a ton of free stuff available. But if you are like me, you would rather spend your time reading instead of searching.

My dream has been to make games for a long time. With XNA it is now possible. This book jump started my journey and I am now creating my own 3D game (and yes, it has local co-op and LIVE co-op!) thanks to Chad.

I have both the older, 1.0 Refresh edition, and this newer XNA Game Studio 3.0 edition. I must say I was both relieved and happy to see the author's level of commitment in maintaining the quality of the book.

Chad has taken painstaking care to bring in all the corrections and requests his readers have put in through the forums for the 1st edition, and expanded the book to include new topics introduced from the 2.0 to 3.0 release of XNA Game Studio. New topics include multiplayer games, networking, Zune game programming and one of the most neglected areas, but probably one of the most important, best practices for developing a game for the Xbox LIVE Indie channel (was Xbox LIVE Community Games).

One of the best things I liked about the book is that it's kept alive and current by the author's frequent updates and replies to reader queries, via a dedicated website, [...]. Got a question on a possible typo or topic you're not too sure of? Ask, or check and it's most likely answered or will be answered in a day or 2. (And I live on the opposite side of the globe to the author.)

I'm using this as a compulsory text for a module I am teaching to Diploma students, and it brings them quickly up to speed on programming with XNA. My students have agreed that this is the most comprehensive and yet readable book on XNA and an introduction to HLSL.

There are lots of useful code samples and components that you can drop into your own game, using them out of the box. I'm making a mash-up now with code from both Creator's Club and this book.

Readers who complain that the writer moves too quickly should keep in mind that the book is categorized by the publisher as "Intermediate-Advanced" and accurately so.

You should get this if you have programmed in DirectX and/or C++; you'll find it a breeze and be amazed by how many things have been taken care / made much easier by the XNA framework and using a managed language such as C#. If you've programming in Java before, the syntax of C# will look familiar.

Thanks again Chad, for keeping to the promise of excellent and quality work. I look forward to future editions of this book.

This book has a lot of information in it, but very poor organization. The way topics are explained is also very inconsistent. The things that actually *need* explaining will leave you wondering what just happened, and the parts that are obvious get paragraphs (or even pages) devoted to them. On the bright side, it does assume you are a competent programmer (well, more than some other books anyway) and does not waste any time trying to teach you C# or fundamental programming concepts, and that the tone of the book at least tries to be direct and to the point, and not trying to be funny all the time, which almost always ruins a book for me.

When I read a programming book with a code sample, I like the author to just say "here's the code sample", then present it, then go through it line by line. Instead the author builds up the code samples by presenting a few lines at a time, with the code interspersed with comments like: "To do this we'll have to add a private member variable of type Matrix to the class. We'll call this member 'projection'. A few paragraphs later a code fragment is presented that relies on all of this stuff. This is of course a simple example that would be not be too hard to deal with, but when you start having inheritance hierarchies and non-trivial relationships between classes it becomes an issue.

I admit it *seems* like a natural way to present and discuss code, but it doesn't work. You can never just look at a piece of code in the book and figure out what it's doing. There's too many dependencies on paragraphs from 10 pages ago, or a previous chapter, or even worse, code that hasn't even been presented yet! In some cases the author will present code fragments and as you try to read through it you're thinking to yourself "omg where the heck did all of these variables come from?" A few paragraphs later he'll say "notice that in the preceding code fragment we used variables x, y, and z. So we need to declare those in the class as well". It makes it very difficult if you're trying to following the coding sample as it's presented.

As far as explanations are concerned, there are very few *conceptual* explanations. The author spends time walking through each line of code in the samples presented, but it almost looks like what you'd see if you asked a first year computer science to thoroughly comment his homework assignment. Things like "next we increment each of the variables", or "loop through the palette entries and process each one". Well that's great, however it was pretty obvious from looking at the code that that's what was happening. A perfect example of this is in the chapter on 2d animation where some fire is animated to a texture. Not once was there any explanation of the *algorithm* - i.e. how does it work, why does it work? So sure, you can read through the code, and understand each line, but if you were to think "I want to change the algorithm so that the fire looks a little more ______", you wouldn't be prepared.

Another good example of this lack of conceptual explanations / insight is when the author is discussing game components. He says that a game component provides a method by which the framework will automatically notify your object to update and draw itself the correct number of times per second based on the application settings. But that you should be careful and not put too many game components because it can "bring your system to a crawl", instead making so called "manager" components that delegate drawing / updating to other items. Then an example he uses is related to enemies and players. Instead of having every enemy and player being a separate instance of a component, you would have a PlayerManager or EnemyManager component, that would in turn handle drawing / updating all the players and enemies. Well ok, I actually think I know what the issue is and why such a design is better, but does everyone reading the book? It's certainly not obvious if you don't have tons of experience with programming or games. I can imagine many readers will be wondering, "uhh, if you have to draw / update them all anyway, what difference does it make if they're udpated / drawn automatically by the framework because they're individual components, or whether your manager draws/updates them all when the framework invokes the manager's draw/update method".

This is an edited review, because I hadn't read the last few chapters when I first posted it. I'd probably re-rate this book 3 or 3.5 stars now if I had the option, because I think everything from chapter 14 on is actually pretty good. It still suffers from some of the aforementioned problems but I actually found myself learning quite a bit.

When I first bought this book I was a little scared, because I've read some comments about that the code doesn't work properly, and some code in the book is different in the CD that it brings with it.

Well, I have managed to get to chapter 5 without any problems.
For now, the book has been an AWESOME resource of information and a pretty good tutorial in all the ways I expected it to be.
I'm not a beginner in XNA though, I've read another book called: Beginning XNA Game programming (I think that is the name for it), but for sure I'm no professional either experienced user on the topic.

The book is written in such a way, that is really easy to understand, and it feels like you can actually read it faster than you would expect. It's a big book, but it really has a lot of USEFUL information on it, of course I cannot tell about the WHOLE book since I've just get to chapter 5 (page 100), but for now it has been an awesome experience to read the book.

**ANOTHER IMPORTANT THING to note, is that this book is intended to be for intermediate programmers to experienced, it's NOT a beginner kind of book. You should know how to program on C#, but if you have C++ knowledge it will be easy for you to understand the whole thing. This book is better read if you already have some understanding about the XNA framework and how to program basic games and programs with it.

In summary, it's a good book, and I really don't have any bad opinions about it, just that it's not a for-beginners book.

Sorry for my English, hope this help someone!
(I'm not CarlaVeg, I'm her brother)

I've been developing in C# for years but really don't have any knowledge of game programming or XNA Game Studio even though I've been toying with it since the 1.0 release. I felt the book was a wide but fairly shallow coverage of the entire framework. A total beginner will learn a bit about every part of the framework but probably won't be ready to produce a game as most of the difficulty in creating a game falls outside the realm of this books coverage. I think that people with a great deal of game development experience might like this book as it will allow them to translate thier current experience into the XNA Game Studio style. Ultimately the book was what I expected and I'd recommend people read it.

Published by Sams, I found this book on Xna Gaming to be highly intuitive and well organized. I found the chapter on custom importers and processors to be particularly helpful. The examples were easy to understand and implement in my own practice code. I highly recommend this book and rate it five stars out of five.

I was all-around impressed with the depth and clarity of this book as compared to many other game programming books out there, both XNA and not.

It should be smooth sailing for an intermediate programmer while still accessible to the motivated (& patient!) beginner.

The code examples all work and, for the most part, are interesting. You wind up with a simple, but extensible 3D game.

It did not give it maximum marks for two reasons:
* I didn't think the chapter order built up concepts as logically it might have, and the code examples always show you methods before showing you the variable declarations. This is a small point, but the practical outcome of this is that you cannot 'follow along' with the text and how the examples continually working. Minor, but frustrating for me at least.
* The book is trying to be 'all-things-to-all-people,' and jam in everything possible, although it is by no means a reference-style book. Realistically speaking, there is a world of different in the issues you wrestle with to develop a PC game vs. XBox vs. Zune, and I would have preferred a series of smaller, more focused books.

This book covers what you need to know about XNA 3.0. That said, I don't know if it's the best beginners book. If you're new to everything game programming; I would suggest you grab another book. But when you're ready for it, this book is good.

It covers more than XNA itself in that it touches AI, physics and more. But again, a warning to people with little to no previous experience.

Most of the criticisms of this book are spot-on, like the time in chapter 4, when the code you are asked to copy from a previous example magically changes, even though at the top of the paragraph he tells you that he plans on changing it. So be warned, this book is not for everyone. This book is not a "how-to" on XNA, but is more about a discipline of XNA programming. You'll need to be at least an intermediate level programmer (whether you are an amateur, hobbyist, or professional) before you even have a chance to enjoy this book. Anyone below that will experience more frustration than the book is worth.

The author moves quickly through the material, making little jumps here and there, and clearly expects the reader to take every word to heart and remember it, even the parts the reader hasn't been given a chance to understand. He also expects you will spend time thinking and reading-up about what is being presented without any cue from him. If you are looking for a book that tells you step by step what you should do, this book is not for you! That said, there is a lot of material covered in the book, and if you can get through this book, you will have a good start on doing your own Xbox360 programming.