XNA 4.0 Game Development by Example: Beginner's Guide


XNA 4.0 Game Development by Example: Beginner's Guide
eBook: $26.99
Formats: PDF, PacktLib, ePub and Mobi formats
$22.94
save 15%!
Print + free eBook + free PacktLib access to the book: $71.98    Print cover: $44.99
$44.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Support
Sample Chapters
  • Dive headfirst into game creation with XNA
  • Four different styles of games comprising a puzzler, a space shooter, a multi-axis shoot 'em up, and a jump-and-run platformer
  • Games that gradually increase in complexity to cover a wide variety of game development techniques
  • Focuses entirely on developing games with the free version of XNA
  • Packed with many suggestions for expanding your finished game that will make you think critically, technically, and creatively
  • Fresh writing filled with many fun examples that introduce you to game programming concepts and implementation with XNA 4.0
  • A practical beginner's guide with a fast-paced but friendly and engaging approach towards game development

Book Details

Language : English
Paperback : 428 pages [ 235mm x 191mm ]
Release Date : September 2010
ISBN : 1849690669
ISBN 13 : 9781849690669
Author(s) : Kurt Jaegers
Topics and Technologies : All Books, Game Development, Beginner's Guides, Games, Microsoft


Table of Contents

Preface
Chapter 1: Introducing XNA Game Studio
Chapter 2: Flood Control – Underwater Puzzling
Chapter 3: Flood Control – Smoothing Out the Rough Edges
Chapter 4: Asteroid Belt Assault – Lost in Space
Chapter 5: Asteroid Belt Assault – Special Effects
Chapter 6: Robot Rampage – Multi-Axis Mayhem
Chapter 7: Robot Rampage – Lots and Lots of Bullets
Chapter 8: Gemstone Hunter – Put on Your Platform Shoes
Chapter 9: Gemstone Hunter – Standing on Your Own Two Pixels
Index
  • Chapter 1: Introducing XNA Game Studio
    • Overview of the games
    • System requirements
    • Installing XNA Game Studio
    • Time for action – installing XNA Game Studio
    • Building your first game
    • Time for action – creating a new Windows game project
      • Anatomy of an XNA game
        • The declarations area
    • Time for action – adding variables to the class declaration area
      • The Game1 class constructor
      • The Initialize() method
  • Time for action – customizing the Initialize() method
    • The LoadContent() method
  • Time for action – creating the squareTexture
    • The Update() method
  • Time for action – coding Update() for SquareChase
    • The Draw() method
  • Time for action – draw SquareChase!
  • Time for action – play SquareChase!
  • Summary
  • Chapter 2: Flood Control – Underwater Puzzling
    • Designing a puzzle game
    • Time for action – set up the Flood Control project
    • Introducing the Content Pipeline
    • Time for action – reading textures into memory
    • Sprites and sprite sheets
    • Classes used in Flood Control
    • The GamePiece class
      • Identifying a GamePiece
    • Time for action – build a GamePiece class – declarations
      • Creating a GamePiece
    • Time for action – building a GamePiece class: constructors
      • Updating a GamePiece
    • Time for action – GamePiece class methods – part 1 – updating
      • Rotating pieces
    • Time for action – GamePiece class methods – part 2 – rotation
      • Pipe connectors
    • Time for action – GamePiece class methods – part 3 – connection methods
      • Sprite sheet coordinates
    • Time for action – GamePiece class methods – part 4 – GetSourceRect
    • The GameBoard class
    • Time for action – create the GameBoard.cs class
      • Creating the game board
    • Time for action – initialize the game board
      • Updating GamePieces
    • Time for action – manipulating the game board
      • Filling in the gaps
    • Time for action – filling in the gaps
      • Generating new pieces
    • Time for action – generating new pieces
      • Water filled pipes
    • Time for action – water in the pipes
      • Propagating water
    • Time for action – making the connection
    • Building the game
      • Declarations
    • Time for action – Game1 declarations
      • Initialization
    • Time for action – updating the Initialize() method
      • The Draw() method – the title screen
    • Time for action – drawing the screen – the title screen
      • The Draw() method – the play screen
    • Time for action – drawing the screen – the play screen
      • Keeping score
    • Time for action – scores and scoring chains
      • Input handling
    • Time for action – handling mouse input
      • Letting the player play!
    • Time for action – letting the player play
    • Play the game
    • Summary
  • Chapter 3: Flood Control – Smoothing Out the Rough Edges
    • Animated pieces
      • Classes for animated pieces
    • Time for action – rotating pieces
    • Time for action – falling pieces
    • Time for action – fading pieces
      • Managing animated pieces
    • Time for action – updating GameBoard to support animated pieces
      • Fading pieces
    • Time for action – generating fading pieces
      • Falling pieces
    • Time for action – generating falling pieces
      • Rotating pieces
    • Time for action – modify Game1 to generate rotating pieces
      • Calling UpdateAnimatedPieces()
    • Time for action – updating Game1 to update animated pieces
      • Drawing animated pieces
    • Time for action – update Game1 to draw animated pieces
      • SpriteBatch overloads
  • SpriteFonts
  • Time for action – add SpriteFonts to Game1
    • Score display
  • Time for action – drawing the score
    • ScoreZooms
  • Time for action – creating the ScoreZoom class
  • Time for action – updating and displaying ScoreZooms
    • Adding the GameOver game state
  • Time for action – game over
  • The flood
  • Time for action – tracking the flood
    • Displaying the flood
  • Time for action – displaying the flood
    • Difficulty levels
  • Time for action – adding difficulty levels
  • Summary
  • Chapter 4: Asteroid Belt Assault – Lost in Space
    • Creating the project
    • Time for action – creating the Asteroid Belt Assault project
    • Another definition for "sprite"
      • Building the Sprite class
    • Time for action – declarations for the Sprite class
    • Time for action – Sprite constructor
    • Time for action – basic Sprite properties
    • Time for action – animation and drawing properties
      • Collision detection
    • Time for action – supporting collision detection
      • Animation and movement
    • Time for action – adding animation frames
    • Time for action – updating the Sprite
    • Time for action – drawing the Sprite
    • A sprite-based star field
    • Time for action – creating the StarField class
    • Time for action – updating and drawing the StarField
    • Time for action – viewing the StarField in action
    • Animated sprites – asteroids
    • Time for action – building the AsteroidManager class
      • Positioning the asteroids
    • Time for action – positioning the asteroids
    • Time for action – checking the asteroid's position
    • Time for action – updating and drawing asteroids
      • Colliding asteroids
    • Time for action – bouncing asteroids – part 1
    • Time for action – bouncing asteroids – part 2
    • Player and enemy shots
    • Time for action – adding the ShotManager class
    • Time for action – firing shots
    • Time for action – updating and drawing shots
    • Adding the player
    • Time for action – creating the PlayerManager class
      • Handling user input
    • Time for action – handling user input
    • Time for action – updating and drawing the player's ship
    • Enemy ships
    • Time for action – creating the Enemy class
    • Time for action – waypoint management
    • Time for action – enemy update and draw
      • The EnemyManager class
    • Time for action – creating the EnemyManager class
      • Managing waypoints
    • Time for action – setting up the EnemyManager class
    • Time for action – spawning enemies
    • Time for action – updating and drawing the EnemyManager
    • Summary
  • Chapter 5: Asteroid Belt Assault – Special Effects
    • Explosion effects
      • Expanding on sprites – particles
    • Time for action – constructing the Particle class
    • Time for action – updating and drawing particles
      • Particle explosions
    • Time for action – the ExplosionManager class
    • Time for action – creating explosions
    • Time for action – updating and drawing explosions
    • The collision manager
    • Time for action – creating the CollisionManager class
      • Handling collisions
    • Time for action – player shot collisions
    • Time for action – player collisions
    • Time for action – using the CollisionManager class
    • Sound effects
      • Generating and finding sound effects
      • Sound in XNA
    • Time for action – building a sound effects manager
    • Time for action – using the SoundManager class
    • The game structure
    • Time for action – structuring the game
    • Time for action – drawing the game structure
    • Summary
  • Chapter 6: Robot Rampage – Multi-Axis Mayhem
    • Statics, statics, everywhere
    • Time for action – creating the Robot Rampage project
    • A world larger than the screen
      • Defining a camera
    • Time for action – creating the Camera class
      • World-aware sprites
    • Time for action – building a new Sprite class
      • Visualizing the view
    • Time for action – viewing the Sprite and Camera classes in action
    • The game world – tile-based maps
      • Tiles
      • The tile map
    • Time for action – creating the TileMap class
      • Map squares
    • Time for action – dealing with map squares
      • Dealing with tiles
    • Time for action – handling tiles
      • Drawing the map
    • Time for action – drawing the tile map
      • Generating a random map
    • Time for action – random wall placement
    • Adding the player
      • Building the Player class
    • Time for action – building the Player class
      • Moving around the world
    • Time for action – handling input
      • Staying in bounds
    • Time for action – staying in bounds
      • Running into tiles
    • Time for action – accounting for walls
    • Summary
  • Chapter 7: Robot Rampage – Lots and Lots of Bullets
    • Visual effects
      • Revisiting particles
    • Time for action – the Particle class
      • The EffectsManager class
    • Time for action – the EffectsManager class
    • Time for action – building explosions
    • Time for action – spark effects
    • Adding weaponry
      • The WeaponManager class
    • Time for action – beginning the WeaponManager class
      • Weapon upgrades
    • Time for action – new weapons
      • Shot to map collisions
    • Time for action – shots colliding with tiles
      • Power-ups
    • Time for action – power-ups
      • We still have a problem...
    • Path finding
      • The A* path-finding algorithm
      • Implementing A*
    • Time for action – the PathNode class
    • Time for action – beginning the implementation of A*
    • Time for action – finding the path
    • Time for action – adjacent squares
      • Safely placing power-ups
    • Time for action – updating the WeaponManager class
    • Player goals
      • Computer terminals
    • Time for action – building a computer terminal
      • Spawning computer terminals
    • Time for action – the GoalManager class
    • Enemy robots
      • Enemy basics
    • Time for action – building the Enemy class
      • Moving enemies
    • Time for action – enemy AI methods
      • The enemy manager
    • Time for action – the enemy manager
      • Updating the WeaponManager
    • Time for action – destroying enemies
    • Game structure
    • Time for action – the GameManager class
      • Keeping score
    • Time for action – awarding points
      • Updating Game1
    • Time for action – updating the Game1 class
    • Summary
  • Chapter 8: Gemstone Hunter – Put on Your Platform Shoes
    • Borrowing graphics
    • Time for action – creating projects
    • A more advanced tile engine
    • Time for action – the MapSquare class
      • Rebuilding the camera
    • Time for action – the Camera class
      • Constructing the tile engine
    • Time for action – the TileMap class – part 1
    • Time for action – the TileMap class – part 2
      • Drawing the tile map
    • Time for action – the TileMap class – part 3
    • Time for action – adding the tile map to the game project
    • The map editor project
      • Creating the map editor project
    • Time for action – creating the level editor project
      • Adding a form
    • Time for action – adding a form
    • Time for action – adding event handlers
      • Filling Out Our Form
    • Time for action – creating the menu bar
    • Time for action – tile selection controls
    • Time for action – scroll bars
    • Time for action – final controls
      • Updating the Game1 class
    • Time for action – updating Game1
    • Time for action – the Game1 Update method
      • Connecting the form to the game
    • Time for action – completing the editor – part 1
    • Time for action – fixing the scrolling delay
      • Loading and Saving Maps
    • Time for action – implementing loading and saving
      • Passability
      • Map codes
    • One last issue
    • Time for action – handling the FormClosed event
    • Summary
  • Chapter 9: Gemstone Hunter – Standing on Your Own Two Pixels
    • Animation strips
    • Time for action – building the Animation class
    • Animated game objects
    • Time for action – building the GameObject class – Part 1
      • Drawing, animation, and movement
    • Time for action – building the GameObject class – part 2
      • Map-based collision detection
    • Time for action – building the GameObject class – part 3
    • The Player
    • Time for action – creating the Player class
      • Running...
    • Time for action – overriding the Update() method – part 1
      • ...and jumping
    • Time for action – overriding the Update() method – part 2
      • Staying on the screen
    • Time for action – repositioning the camera
    • Loading levels
      • The LevelManager class
    • Time for action – building the LevelManager class
    • Gemstones
    • Time for action – building the Gemstone class
      • Scoring
    • Time for action – implementing score tracking
    • Enemies
    • Time for action – summoning up the zombies
      • Player-enemy interaction
    • Time for action – interacting with zombies
    • Level transitions
    • Time for action – supporting map transitions
    • Processing other codes
    • Time for action – handling codes
    • Game structure
    • Time for action – implementing game states
    • Summary

Kurt Jaegers

Kurt Jaegers is an Oracle Database Administrator and Windows Network Administrator, as well as a long-time hobbyist game developer. He has built games for everything from the Commodore 64 to the Xbox 360. He is the owner of xnaresources.com, and the author of XNA 4.0 Game Development by Example: Beginner's Guide (C# edition) and XNA 4.0 Game Development by Example: Beginner's Guide – Visual Basic Edition, both of which were published by Packt Publishing.

Sorry, we don't have any reviews for this title yet.

Code Downloads

Download the code and support files for this book.


Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


Errata

- 14 submitted: last submission 28 Mar 2013

Errata type: code | Page number: 318

at step 3, it says: gameForm.SizeChanged += new EventHandler ... where instead it should say pictureBox.SizeChanged += new EventHandler ...

 

Errata Type: Code page no:150

On the 6th step it says "In the Draw() method of Game1, add the following after the ShotManager draw call:" [...] In reality it should say enemyManager instead of ShotManager. The ShotManager is not used in the Draw() method of that class. On the example project available on this site you can check the code and see it's just as I say.

Errata Type: Code Page no:52-53

page 53 refers to CheckScoringRow method, however method is named CheckScoringChain on page 52

Errata Type:Code Page no:76

Step 2 of the ScoreZoom class instructs the reader to add: using Microsoft.Xna.FrameWork.Graphics; However, in order for C# to recognize the term 'Color' in step 3, the reader needs to include this as well: using Microsoft.Xna.Framework; Without this, the code will not compile as the compiler does not know how to interpret lines such as: public Color DrawColor;

Errata Type:Code related Page no:28

"When multiple version of the same method are declared with either different parameters lists or different return values, each different declaration is called an "overload" of the method." 1. I think it should say "parameter lists" instead of "parameters lists" 2. In C# all overloads must have the same return value. Maybe it was more of a language independent statement about overloads, but overloading only by return value is a strange concept in an OO language.

Errata Type:Code Page no:64

not "wrong" but... in each of the update functions RemoveKeys.Enqueue(thisKey.ToString()); calling .ToString() on a string is a bit redundant.

Errata Type:Grammar Page no:19

This is the Kindle eBook version. The very minor error is in the sentence "...as sequential Draw() calls would provide no benefit nothing in the game state will have changed." which I think was intended to read "...as sequential Draw() calls would provide no benefit *since* nothing in the game state will have changed."

Errata Type: Page no:124

On page 124 you call playerSprite.Velocity.Normalize(); It does nothing to call that on a property wrapping a struct. You need to create a variable like you do in the imposeMovementLimits function. You also need to check for a zero vector because normalizing that will mess things up. Here's my code: Vector2 velocity = playerSprite.Velocity; if (velocity != Vector2.Zero) velocity.Normalize(); playerSprite.Velocity = velocity; Thanks for the great book

Errata Type:Code Page no:127

when adding frames to the enemy sprite, the first coordinate of the rectangle is initialFrame.X = (initialFrame.Width * x) instead of initialFrame.X + (initialFrame.Width * x)

Errata Type:Code Page no:76

Step 2 in the "Time for Action - creating the ScoreZoom Class" Section reads as follows: 2. Add the following using directive to the top of the file: using Microsoft.Xna.Framework.Graphics; This step is an incomplete statement, as later code references the "Color" struct found in "Microsoft.Xna.Framework". For error free code, the reader must add another using statement. Correction is as follows: 2. Add the following using directive to the top of the file: using Microsoft.Xna.Framework.Graphics; using Microsoft.Xna.Framework; Despite thee omission in the book, the source code available for download contains both using statements that are needed.

Errata Type:Code Page no:150

Step 6 tells me to add code after the ShotManager.Draw() call. Shotmanager is not drawn explicitly in this method. The directions should tell you to add it after the EnemyManager.Draw() call.

Errata Type:Code Page no:300

in step 6, you are looping through the layers (the z integer), but the MapSquare constructor sets all three layers at once.

Errata type: Technical | Page number: 76 | Errata date: 22 July 11

Time for action – creating the ScoreZoom class section Step 2 instructs the reader to add: using Microsoft.Xna.FrameWork.Graphics; However, in order for C# to recognize the term 'Color' in step 3, the reader needs to include this as well: using Microsoft.Xna.Framework; Without this, the code will not compile as the compiler does not know how to interpret lines such as: public Color DrawColor;

 

Errata Type: Code Page no:150

On the 6th step it says "In the Draw() method of Game1, add the following after the ShotManager draw call:" [...] In reality it should say enemyManager instead of ShotManager. The ShotManager is not used in the Draw() method of that class.

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

Frequently bought together

XNA 4.0 Game Development by Example: Beginner's Guide +    Refactoring with Microsoft Visual Studio 2010 =
50% Off
the second eBook
Price for both: $44.10

Buy both these recommended eBooks together and get 50% off the cheapest eBook.

What you will learn from this book

  • Install the Microsoft XNA Framework and its required tools
  • Build XNA Game projects and associated XNA Content projects
  • Create a puzzle-style game exploring the concepts of game states, recursion, and 2D animation
  • Add sound effects to your game with a "fire-and-forget" sound effects manager
  • Create a particle system to generate random explosions
  • Implement sound effects, collisions, and particle-based explosions by building a space shooter inside a chaotic asteroid field.
  • Implement the A* path-finding algorithm to allow enemies to track down the player
  • Generate tile-based maps and path-finding enemy tanks amidst a storm of bullets in a multi-axis shooter
  • Combine XNA and Windows Forms to create a map editor for a multi-layered tile map engine
  • Run, jump, and squash enemies in a side-scrolling platform using the maps from your editor
  • Modify your creations for the Xbox 360 platform and deploy your games to the console

 

In Detail

XNA Game Studio enables hobbyists and independent game developers to easily create video games. It gives you the power to bring your creations to life on Windows, the Xbox 360, the Zune, and the Windows Phone platforms. But before you give life to your creativity with XNA, you need to gain a solid understanding of some game development concepts.

This book covers both the concepts and the implementations necessary to get you started on bringing your own creations to life with XNA. It details the creation of four games, all in different styles, from start to finish using the Microsoft XNA Framework, including a puzzler, space shooter, multi-axis shoot-'em-up, and a jump-and-run platform game. Each game introduces new concepts and techniques to build a solid foundation for your own ideas and creativity.

Beginning with the basics of drawing images to the screen, the book then incrementally introduces sprite animation, particles, sound effects, tile-based maps, and path finding. It then explores combining XNA with Windows Forms to build an interactive map editor, and builds a platform-style game using the editor-generated maps. Finally, the book covers the considerations necessary for deploying your games to the Xbox 360 platform.

By the end of the book, you will have a solid foundation of game development concepts and techniques as well as working sample games to extend and innovate upon. You will have the knowledge necessary to create games that you can complete without an army of fellow game developers at your back.

A step-by-step tutorial to using Microsoft XNA by creating four different styles of video games.

Approach

This book is a step-by-step tutorial that includes complete source code for all of the games covered. It adopts an engaging style to teach all the game development concepts. Each block of code is explained, and game development concepts are diagrammed and covered in detail. Each game begins with a concept description and concludes with suggestions for expanding on the finished game.

Who this book is for

If you are an aspiring game developer who wants to take a shot at creating games for the Microsoft Windows platform with the XNA Framework, then this book is for you. Using this book, you can get started with creating games without any game development experience. A basic knowledge of C# would be helpful to kick-start your game development, but it's not essential.

Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Resources
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software