XNA 4.0 Game Development by Example: Beginner's Guide – Visual Basic Edition


XNA 4.0 Game Development by Example: Beginner's Guide – Visual Basic Edition
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
  • Visual Basic edition of Kurt Jaegers' XNA 4.0 Game Development by Example. The first book to target Visual Basic developers who want to develop games with the XNA framework
  • Dive headfirst into game creation with Visual Basic and the XNA Framework
  • Four different styles of games comprising a puzzler, space shooter, 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

Book Details

Language : English
Paperback : 424 pages [ 235mm x 191mm ]
Release Date : December 2011
ISBN : 1849692408
ISBN 13 : 9781849692403
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 – setting 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 – creating the GameBoard.cs class
        • Creating the game board
      • Time for action – initializing the game board
        • Updating GamePieces
      • Time for action – manipulating the GameBoard
        • 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
              • Modules, modules, 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 module
                • 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 module
              • Time for action – building the Player module
                • 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 module
                • Time for action – building explosions
                • Time for action – spark effects
                • Adding weaponry
                  • The WeaponManager
                • Time for action – beginning the WeaponManager module
                  • 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...
                • Pathfinding
                  • The A* Pathfinding 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 module
                • 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 module
                  • 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 module
                    • Constructing the Tile Engine
                  • Time for action – the TileMap module – part 1
                  • Time for action – the TileMap module – part 2
                    • Drawing the Tile Map
                  • Time for action – the TileMap module – 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 AnimationStrip 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 module
                    • Time for action – building the LevelManager module
                      • Gemstones
                    • Time for action – building the Gemstone class
                      • Scoring
                    • Time for action – implementing score tracking
                    • Enemies
                    • Time for action – summoning 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.

                    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 – Visual Basic Edition +    Unreal Development Kit Game Programming with UnrealScript: Beginner's Guide =
                    50% Off
                    the second eBook
                    Price for both: $39.00

                    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

                    In Detail

                    XNA Game Studio enables hobbyists and independent game developers to easily create video games, and now gives that power to Visual Basic developers. XNA lets you bring your creations to life on Windows, the Xbox 360 and the Windows Phone platforms. The latest release of XNA has added support to Visual Basic and therefore, Visual Basic developers now have the power to give life to their creativity with XNA.

                    This book covers both the concepts and the implementations necessary to get you started on bringing your own creations to life with XNA. It presents four different games, including a puzzler, space shooter, multi-axis shoot 'em up, and a jump-and-run platformer. Each game introduces new concepts and techniques to build a solid foundation for your own ideas and creativity.

                    This book details the creation of four games, all in different styles, from start to finish using Visual Basic and the Microsoft XNA framework. 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 for using Visual Basic with Microsoft XNA to create 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 Visual Basic would be needed to kickstart your game development.

                    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