Channel 9 - Entries tagged with XNA framework

Teaching angles with Kinect Angles 2.4

Greg Duncan — Mon, 28 May 2012 13:00:00 GMT

Today we revisit a popular project, Kinect Angles Version 2 - Learning angles by doing, that has just been updated and officially kid tested...

Kinect Angles v2.4

This release features a new camera sound when the game takes a picture, improved keyboard entry for high score names and other minor bug fixes. It is for Kinect SDK v1.0.3.190 or the new v1.5. I have decided to stop updating the beta version and concentrate on releases which work with the new commercial SDKs.

Project Information URL: http://drenton72.wordpress.com/2012/05/23/kinect-angles-v2-4/

Project Download URL: http://bit.ly/JpTGrW

Project Source URL: http://bit.ly/KTqDx8

Contact Information:

Blog: http://drenton72.wordpress.com
Twitter: @drenton72

Welcome to the IGF, Indiefreaks Game Framework

Greg Duncan — Wed, 16 May 2012 13:00:00 GMT

Today's project is a kind that I don't usually highlight, one that relies on a commercial third party SDK, but I really appreciated the author's intent and goals with it. I just can't get enough of people taking their hard learned lessons, packaging them up and then sharing them freely with the world.

Indiefreaks Game Framework

The Indiefreaks Game Framework or IGF is a set of .Net libraries compiling a few years of experimenting and prototyping design patterns developing games for Microsoft Xna Framework using the SynapseGaming SunBurn graphics engine.
The goal here is to share with the community what I consider as best practices so they can avoid going through the same steps as I did. The Indiefreaks Game Framework is totally free (like in free beer) to use but it still requires you to acquire a SunBurn engine license (learn more here).
Core Features
Target Platforms: The Indiefreaks Game Framework works on Windows Vista, Windows 7, Xbox 360 and Windows Phone 7.1 platforms.
Application Framework: One of the core features of the Indiefreaks Game Framework is to provide a full application life cycle framework to ease the creation and maintenance of games splitting logically how games are generally developped.
Smart Content Management: IGF encapsulates the Xna ContentManager class to load content as WeakReferences avoiding therefore the developer the need to manage Content memory. You can also easily asynchronously preload content while rendering a custom thread safe loading screen.
Input Management: InputManager handles GamePad related XBLIG requirements through a set of Connection, Disconnection events and a LogicalPlayerIndex enumeration you can use to know which PlayerIndex is in your game. Also includes a Virtual GamePad using Keyboard & Mouse or WP7 touch mapping to buttons and sticks.
2D & 3D Rendering
SunBurn Rendering: The Indiefreaks Game Framework implements Forward and Deferred rendering using the core SynapseGaming SunBurn engine rendering capabilities. (Deferred rendering requires a SunBurn engine Pro license and isn't available on WP7)
Easy Hardware Instancing: Save your game framerate using the builtin InstancingManager to render hundreds of similar meshes using 10 lines of code while keeping direct control on each instance world transforms.
Cameras: The framework includes a set of 2d & 3d cameras easily extendable (static and controlled by input) that plug nicely to the SunBurn engine using a CameraManager residing inside the SunBurn SceneInterface Managers.
Sprite System: The Indiefreaks Game Framework extends SunBurn 2d features with a Sprite system enabling developers to benefit from the SunBurn rendering as well as 2d world transform and collision.
GUI & Menu System: Adding a Main Menu, Pause Menu, a Heads Up Display (HUD) or any other Graphical User Interface for your game is now easy, expendable and framerate friendly thanks to IGF. Thanks to IGF Smart Input System, it supports both GamePad and Mouse+Keyboard input devices switching 2 properties.
Particle System: Through Mercury Particle Engine integration as SceneEntity instances, IGF lets you emit & trig particles with a few lines of code & movable within SunBurn Editor.
Post Processing Effects: Add Depth Of Field, God Rays (under development), SSAO (under development), Motion Blur (under development) post processing effects to your games simply adding them to your SunBurn PostProcessorManager instance and setting a few properties that can be tweaked at runtime. (requires SunBurn Pro).
Physics & Collisions
BEPUPhysics v1.1.0.0 integration: IGF allows you to replace SunBurn's default CollisionManager with the impressive BEPUPhysics system. It supports:
Dynamic & Static Box Colliders
Dynamic & Static Sphere Colliders
Dynamic & Static ConvexHull Colliders
Static Mesh Colliders
Game Logic
Abstract Network System: IGF comes with an abstraction layer for networking concepts. It allows the developer to make single or multiplayer games without caring much how the network calls, client & server concepts are implemented.
Xbox Live: As part of the Abstract Network feature, IGF fully implements the Xbox Live features provided within the Xna framework (as well as Games For Windows Live).
Lidgren Network Library: Since Xna doesn't support Games For Windows - Live except for development purposes, IGF comes with an equivalent implementation using the Lidgren Network Library (Only for SinglePlayer & Local Area Network for now).
Local Session: If you want to make a single player game, the Local session system will be your best choice as it provides much of Xbox Live features (Player Identification, Game session management, ...) for a single player game. Moreover, it eases a lot moving your game from Single Player to Multi Player using any of the network library implementations above.
Logic Components & Behaviors: Ease your game logic implementation with Player & Non Player Agents that accept your own Behavior scripts written in C# and plug them to any SceneObject or SceneEntity in your scene. Moreover, they work seemlessly with any of the above Network implementations letting you code once your game logic and play it on Local session, Xbox Live or any other network implementation.
Steering Behaviors: IGF implements Steering Behaviors for Autonomous Agents that can be applied to 2D or 3D game entities independently. Easy to setup and configure Seek, Arrive, Flee, Evade, Pursuit, Obstacle Avoidance, Cohesion, Alignment and much more…
Finite State Machines: Create your desired game entities states and add them to IGF Finite State Machine system using a simple enumeration. Simply add a StateMachineAgent component to your SceneEntity or SceneObject instances and they’ll get a brain.
Goal Driven AI: For more complex AI entities, IGF provides a Goal Driven system that can be applied to your game entities. Define their goals, implement the desirability computation and add them to the GoalBrain SunBurn Component and you’ll see your game entities make smart decisions!
Development Requirements
Microsoft Xna Game Studio 4.0 refresh
SynapseGaming SunBurn Engine Indie or Pro editions
Windows Vista® (x86 or x64) with Service Pack 2 - All editions except Starter Edition
Windows 7® (x86 or x64) - All editions except Starter Edition
Object Oriented Programming concepts
C# programming
Microsoft Xna Framework
SunBurn Engine for advanced rendering

So that sounds great, but how do you get started with it? Check out this eight part video tutorial series on building a game with IGF;

Ace on Steroids

Ace on Steroids is a game project using the Indiefreaks Game Framework which purpose is to demonstrate how to use the framework to make a full 3D game through a set of live development recorded videos.
This is an experimental tutorial process and hopefully will satisfy your needs.
Feel free to share your feedback about these with us in the Comments of each video.
01 - Getting Started
02 - Adding a custom Splash Screen
03 - Add a Start Screen
04 - Add your Game Title & a Root Main Menu
05 - Adding Keyboard and Mouse support And Gameplay GameState
06 - Player Physics & World Transforms
07 - Wrapped Screen Behavior
08 - Asteroids & Collisions

So lets take a quick peek at the IGF Solution.

That's the collapsed to the project level...

BTW, the project source shown in the tutorial is also available.

A final bright spot is that there is a free version of the SunBurn engine, but it's a version behind the commercial release, which IGF is dependent on. Why is that a bright spot? Because once the free version makes the jump to v2, Philippe plans on making sure IGF supports it too.

If you're already a SunBurn engine user, then this project looks like it's easily worth a bit of time to check out. If you're on the fence about using SunBurn, then maybe work like this is all you need to help you make the decision. Even if you are not in either camp, but are still looking at learning from the hard lessons of others... well here you go.

"Game Development with XNA and Microsoft Technologies: Kinect Development"

Greg Duncan — Tue, 15 May 2012 13:00:00 GMT

Teaching resources have a special place in my heart and in seeing this course, 34 class rooms sessions, with all the lesson plans, resources, labs, etc for learning to develop with the Kinect, well, how could I not share it?

Game Development with XNA and Microsoft Technologies: Kinect Development

These Kinect lessons are intended to be project-based classes for high school and older students, with the teacher introducing the topic, showing a quick demo, discussing the code with the students, and then letting the students work. The teacher will assume the role of a guide, support, and class assistant. Student learning will be facilitated by labs and activities.
The goal of this series of lab assignments is not to make students experts on specific code, but rather to provide opportunities to use and experience the code with enough explanation to allow them to quickly begin writing their own games, simulations, and activities.
The following material is contained in this file:
Teacher Roadmap: A scope and sequence for classroom implementation and teaching suggestions.
The Kinect EXPLORER demonstrates the depth and video cameras and shows the skeleton tracking provided by the SDK. Download this file of samples if they are not available in the Kinect SDK.
Unit 1 will review the Kinect sensor, how it can be used, how it connects, setup, testing, and how to write programs which interact with it.
Unit 2 will introduce receiving and displaying live video from the Kinect sensor. Additionally, you will use skeletal tracking and a version of depth tracking, so that they can bring in the background and body image in 2D and 3D. Students will explore a simple version of “virtual” reality. It is important to note that some of the code in this section, especially the specific code to communicate with the Kinect camera for video and for color, is quite complex.
Unit 3 will focus on an aspect that may be one of the most interesting, and less known, features of the Kinect SDK - the ability to receive and interpret audio input. The Kinect SDK comes with a complete voice recognition system! The recognition system is relatively simple to use and incredibly powerful to the developer.

Project Information URL: http://www.facultyresourcecenter.com/curriculum/8965-Kinect-Development.aspx

Project Download URL: http://www.facultyresourcecenter.com/curriculum/8965-Kinect-Development.aspx

Project Source URL: http://www.facultyresourcecenter.com/curriculum/8965-Kinect-Development.aspx

Here's a snip from the Teacher's Roadmap;

These Kinect lessons are intended to be project-based classes, with the teacher introducing the topic, showing a quick demo, discussing the code with the students, and then letting the students work. The teacher will assume the role of a guide, support, and class assistant. Student learning will be facilitated by labs and activities.
The goal of this series of lab assignments is not to make students experts on specific code, but rather to provide opportunities to use and experience the code with enough explanation to allow them to quickly begin writing their own games, simulations, and activities.
...
Similarly to Unit 1 and Unit 2, Unit 3 Labs provide an introduction to the capabilities of the Kinect. The main goal is to introduce what is possible, try to stir students’ imagination, give sufficient knowledge and hands-on experience for success, and offer opportunities to explore the SDK further based on the students motivation and abilities.
Especially with audio, getting the audio stream ready to be “heard” and interpreted requires a great deal of setup work. Part of the reason for that comes from the fact that the speech engine is a generic engine that is can be able to be used for any language, even local dialects. The good news is that once the required code is entered, writing code to create cool programs is pretty straight forward.
...
Pedagogy:
Some of the code involved in accessing and interpreting data from the Kinect sensor can be very complicated. Not only the algorithms, but the code as well, might be more than your students can do on their own. There is a balance you will need to discover between their ability to “understand” the code and their experiences “using” the code to accomplish tasks.
This series of lessons attempts to balance those concerns, but will always err on the side of USING the code to accomplish new tasks and instilling excitement and eagerness to learn more computer science. Certain sections of code can extremely complicated but it is included in these lessons because it is necessary to accomplish a specific task and can be a step in developing the students’ problem solving skills. As the teacher you will need to decide on the balance. Is it more important that they can use existing code to help accomplish new tasks, or is it more important to spend time studying the existing code to understand why it works? Both are important, so finding that balance is crucial.
The lab exercises can be completed either by going through the step-by-step tutorials or on-your-own by using the information provided in the descriptions and videos. The goal in either approach is for the students to conceptually understand what tasks and procedures are required to complete the program. In the on-your-own scenario students are responsible to create a plan to accomplish the tasks, and then implement a program without the assistance of the tutorials.
These lessons are intended to provide a wide range of activities and experiences for students to build their programming skills. There are a variety of options in using these labs.
1. Follow the Leader: Students work through the tutorials step-by-step on their own or with a partner. Then students attempt the extensions for each lab.
2. Students and teacher read through the tutorials together to get a feel for the logic of implementing the program and then students write the programs on their own without using the lab tutorials.
3. Flexible Plan: The teacher can build a custom scope and sequence by assigning only those lessons and labs that will be most appropriate based upon the students’ computer science experience, level of expertise, time restraints, or course objectives. Students would complete only those labs with or without the step-by-step tutorials. More time can be allocated for the MYOKA (Make Your Own Kinect Application) at the end of each unit, a large project chosen, planned, and implemented by the students that can be used as a major assessment tool. Use the short preview videos and the activity descriptions to help select labs and activities.
Prerequisite skills
Basic XNA development skills
Experience with handling input in XNA
Mastery Objectives/Results:
Unit 1:
Use the Kinect sensor as an active user interface in contrast to mouse and keyboard
Access and interpret the data that is being streamed by the sensor
Use code to identify a body skeleton
Analyze the data from the sensor to interpret position and location in 2D
Evaluate the data from the sensor to interpret action and intention
Create programs that will respond based upon interpreting data from the sensor
Unit 2:
Use the Kinect sensor to receive and display live video feed
Access and interpret the data that is obtained by the camera
Analyze the data that is obtained by the camera to interpret position and movement in 2D and 3D
Create a program which will take an action(s) as a result of interpreting video data from camera
Create a program which will allow the person in the video to interact , or have impact upon, the objects that are not actually in the video
Unit 3:
Use the Kinect sensor to receive audio
Access and interpret the audio data that is received by the sensor
Analyze the audio data
Create a program which respond to the audio data
Suggested Timeline
The Lesson Plan document for each unit includes a detailed timeline and description of the labs and activities. Class period is defined as a 50-minute session.
Unit 1: 13 days
Unit 2: 10 days
Unit 3: 11 class periods + additional days or weeks for the optional capstone project

Real-Time Motion Capture using Kinect, XNA and the DigitalRune Engine

Greg Duncan — Thu, 19 Apr 2012 13:00:00 GMT

Real-time motion capture is one of the more common requests I see for the Kinect so when I saw this...

Do note that this requires a third party project, the DigitalRune Engine, but you can get a free 30 trial for it AND if you're using this non-commercially you can get a free license too.

Real-Time Motion Capture using Kinect and XNA (Part 2)

Our last post about real-time motion capture using Kinect seems to be pretty popular. And for the small amount of time (only a few hours) that we put into this example, the results are satisfying – but we can do better! We have updated the project and included a brand new sample. The new sample uses skeleton mapping to animate 3D models using Kinect. The code is much simpler, and exchanging the 3D model is a lot easier. We have also updated the example application to use Kinect SDK v1.0 instead of Kinect SDK beta2. You can download the sample project (including the source code) at the end of this post.
...
Description
The new sample project demonstrates 2 different methods to animate 3D models using Kinect in real-time:
The Skeleton Mapping Approach
The first sample uses Skeleton Mapping to animate the XNA Dude model and a Space Marine model. There are three different skeletons involved: The Kinect player skeleton, the Dude skeleton and the Space Marine skeleton. All three skeletons are different, i.e. have different bone names and a different number of bones. DigitalRune Animation contains a SkeletonMapper which can be used to transfer an animation from one skeleton to another skeleton with a different structure. (Take a look at the documentation to learn more about Skeleton Mapping.)
Setting up the bone mapping for a model is not very difficult. This is the setup for the Dude model:
...
The source code, which can be downloaded below, contains additional comments and explanations.
The setup for the Space Marine model looks similar – only the bone names are different.
In each frame the SkeletonMapper is called to transfer the current pose of the Kinect player skeleton to the skeleton of the 3D model:

Kinect sensor input is not perfect and causes jittering. Jittering can be reduced by applying a low-pass filter to the bone orientations.
The Marionette Ragdoll Approach
The second example uses the approach that we have shown in the previous post: A physics ragdoll is created for the Dude, which is used to animate the model. Certain joints of the Kinect player skeleton are used as target positions (e.g. hands, elbows, head, knees, etc.). The ragdoll is attached to the target positions using weak ball joint constraints. – This is like a marionette: The ragdoll is the puppet and the ball joints are strings that pull on the marionette.
...
Requirements
Microsoft XNA GameStudio 4.0
Microsoft Kinect SDK v1.0
DigitalRune Engine

Project Information URL: http://www.digitalrune.com/Support/Blog/tabid/719/EntryId/154/Real-Time-Motion-Capture-using-Kinect-and-XNA-Part-2.aspx

I was able to download the 30 trial, the sample code from the article (click through for it) and was playing with this in just a few minutes. Simple and painfully easy...

That's me (kind of)

Contact Information:

Blog: http://www.digitalrune.com/Support/Blog/
Twitter: @DigitalRune

See? Farseer is easy to see (in your next game)

Greg Duncan — Wed, 18 Apr 2012 13:00:00 GMT

The second in our game theme week is a topic that's a favorite of mine, physics (well game physics anyway). It's another tutorial that shows that adding physics to your game doesn't have to be hard and isn't scary...

Farseer tutorial for the absolute beginners

This post is inspired (and somewhat a direct copy) of a couple of posts Emanuele Feronato wrote back in 2009 about Box2D (his tutorial was ActionScript 3 based for Box2D, this is C# XNA for the Farseer Physics Engine).
Here’s what we’re building:
What is Farseer
The Farseer Physics Engine is a collision detection system with realistic physics responses to help you easily create simple hobby games or complex simulation systems. Farseer was built as a .NET version of Box2D (based on the Box2D.XNA port of Box2D). While the constructs and syntax has changed over the years, the principles remain the same.
This tutorial will walk you through exactly what Emanuele create for Flash but we’ll be doing it using C#, XNA and the Windows Phone platform.
The first step is to download the library from its home on CodePlex. If you have NuGet installed, you can install the library itself using the NuGet package that but we’ll also be using some code from the Samples source that can only be obtained by downloading the library.
Once you download and unpacked the zip file into a folder and open the solution, this is what you will get:
The Samples XNA WP7 project (and content) have all the demos for Farseer. There’s a wealth of info here and great examples to look at to learn. The Farseer Physics XNA WP7 project contains the core libraries that do all the work. DebugView XNA contains an XNA-ready class to let you view debug data and information in the game draw loop (which you can copy into your project or build the source and reference the assembly).
The downloaded version has to be compiled as it’s only available in source format so you can do that now if you want (open the solution file and rebuild everything). If you’re using the NuGet package you can just install that. We only need the core library and we’ll be copying in some code from the samples later.
Your first Farseer experiment
Start Visual Studio and create a new project using the Windows Phone template can call it whatever you want.
...

Bill then provides a block of code and then points out and explains the important parts

Here's a clip of it in action;

If you've thought using Farseer might be outside your skillset, hard or scary, hopefully this tutorial shows you otherwise...

The Kinect gives you (or a loved one) the ultimate Barbie dress-up experience

Greg Duncan — Mon, 16 Apr 2012 13:00:00 GMT

Today's inspiration project is a cross between augmented reality and a girl's dream experience...

Make sure you check out the second post below, where some details about how this was created with the Kinect, Kinect for Windows SDK and XNA were used...

Kinect for Windows Helps Girls Everywhere Dress Like Barbie

This week, Barbie lovers in Sydney, Australia, are being given the chance to do more than fanaticize how they’d look in their favorite Barbie outfit. Thanks to Mattel, Gun Communications, Adapptor, and Kinect for Windows, Barbie The Dream Closet is here.

The application invites users to take a walk down memory lane and select from 50 years of Barbie fashions. Standing in front of Barbie’s life-sized augmented reality “mirror,” fans can choose from several outfits in her digital wardrobe—virtually trying them on for size.
The solution, built with the Kinect for Windows SDK and using the Kinect for Windows sensor, tracks users’ movements and gestures enabling them to easily browse through the closet and select outfits that strike their fancy. Once an outfit is selected, the Kinect for Windows skeletal tracking determines the position and orientation of the user. The application then rescales Barbie’s clothes, rendering them over the user in real time for a custom fit.
One of the most interesting aspects of this solution is the technology’s ability to scale - with menus, navigation controls and clothing all dynamically adapting so that everyone from a little girl to a grown woman (and cough, yes, even a committed father) can enjoy the experience. To facilitate these advancements, each outfit was photographed on a Barbie doll, cut into multiple parts, and then built individually via the application.

Project Information URL: http://blogs.msdn.com/b/kinectforwindows/archive/2012/04/12/kinect-for-windows-helps-girls-everywhere-dress-like-barbie.aspx

Barbie’s ‘Dream Closet’ XNA Kinect App

A sneak peek at our XNA Kinect App we built for Gun Communications and their client Mattel. This was an early version of the app with a few things left to polish.
The technical solution consisted of a custom-made application using Microsoft’s XNA Game Studio combined with the Kinect for Windows hardware and software development kit (SDK). The user interacts with the application through a natural gesture and overlay interface, augmented with audio and visual cues. Skeletal tracking is used to determine the position and orientation of the user and various Barbie™ outfits are rescaled and rendered over the user in real time. After selecting an outfit the user is prompted to strike a pose, and after a short countdown the resulting postcard-style photo is uploaded to a Pyramid-powered web server. All approved images (users aged 13+ only with guardian consent) can then displayed in a gallery section of the Barbie® Australian Facebook page.
The app will be launched at a media event in Sydney on April 11, 2012. A series of public events will then be executed at Westfield centres during school holidays, commencing at Westfield Parramatta (NSW April 12 – 15), Westfield Doncaster (VIC June 28 – July 1), and Westfield Chermside (QLD Sept 27 – 30).

Project Information URL: http://adapptor.com.au/2012/04/barbies-dream-closet-xna-kinect-app/

On a final note, if you'd like to give a like experience to your mom's, wives, daughter's, etc, but don't live in Australia, check out http://barbiethedreamcloset.com/. This site lets you do some Kinect like NUI with just your webcam. It's not near as cool as live augmented reality, but it might be enough for a smile from a loved one and what more do you really need?

Escape the fear of writing XNA games for Windows Phone 7.5 and XBOX 360

Greg Duncan — Mon, 16 Apr 2012 13:00:00 GMT

This week we're going to be doing a gaming theme, mostly focusing on getting started writing games (Pretty much in the hope that all of you that aren't already writing games, start doing so and thereby give us something to blog about here... see how that works? I'm tricksy hobbit/man/guy/what-ever...)

We kick off the week with a tutorial, from start to gaming, on writing an XNA Windows Phone 7.1(5) game. One of the main points I'd like to stress in this tutorial is that you don't have to be afraid of writing a game. It's not as scary or hard as you might think...

Tutorial: Creating a XNA 4.0 game for Windows Phone 7.5

In this tutorial we are going through the process of creating a simple game from A to Z using Visual Studio 2010 and the Windows Phone 7.1 SDK – Targeting Windows Phone 7.5.
This game was created during a presentation and took about 45 minutes, and patched as the session went on by feedback from the audience. I just documented the process and shared it on this blog.
First of all, if you haven’t done so yet – you will need to download the Windows Phone SDK.
...
1. Designing the game
The first thing you should do when creating a game is to come up with an idea, story and how you should go through that story. It’s important to be able to explain the game in one sentence – if you can’t, the players/gamers/consumers will have trouble understanding the game. If you can, it will be much easier to market and sell the game!
...
2. Creating the graphics
Most games require some graphics. In this game I want to have a playfield that represents the floor in a ghost house, a ghost, a player, some text that display high scores and some dot’s that show where I just walked (path).
...
3. Game logic
Next we should think how we should play the game, what’s the logic, how is the enemies moving, how should the player move and so on.
...
4. Implementing the game
The games classes we will implement
Be sure do download the source for the applications so you can follow the implementations. Or you can follow the steps below and create the game as we go, but not all details will be covered.
...

At this point the post takes you through the development process and explaining the major code points.

Finally...

As an added bonus, not only is the source for this game available (click through for the download links), but the author has also already ported it to the XBOX 360 (and made that source available too!)

Xbox 360 game with source: Escape

I just quickly ported the game Escape (created in this tutorial) to Xbox 360. The code is quite similar with two exceptions:
- I had to handle the safe limit zone and various screen resolutions
- I changed the controller from being touch-based to GamePad-based, and also considering that the player might use a gamepad that is either player one, two, three of four.
I also removed the online high score system since when it comes to the Xbox 360, we have to use a completely different approach when it comes to online storage.

If you already know C# and are thinking about writing XNA games for Windows Phone 7 or the XBOX 360, this tutorial would be a great place to start...

Making some magic with XNA with Mage Defender Deluxe

Greg Duncan — Wed, 21 Mar 2012 13:00:00 GMT

Today's project is cool little C# XNA 4 game. Not only is there the game, but also a couple "editors" too. This game shows off a number of things, from creating games with custom content to particle engine usage and more...

XNA 4.0 Game with Source: Mage Defender Deluxe

Mage Defender Deluxe was created as a remake during a workshop/presentation I had. It was made pretty fast but I decided to share the source anyways.
In the game, you will need to defend your castle at all cost. Shoot the enemies that move towards you with multiple spells and strategies to take them out one by one. After each wave, you will be able to visit the shop to upgrade abilities, buy new spells, mana/health potions and upgrade your castle (Gameplay video can be found below).
The original game was a DOS game made by Dark Codex in 1999 and looked like this:
The new version contains more enemies, spells, upgradable castle, skill points, attributes, homing spells, controllable spells, many enemies with basic AI and much more.
The game works with the XBox360 controller, just connect it to your PC and play.
You can find the source for the game at GitHub:
https://github.com/petriw/MageDefenderDeluxe/downloads
Click the “Download as zip” button to download the latest source.

Some snaps from the game;

Here's what the Solution looks like

Here's some snaps of the two editors;

Here's a quick code snip;

/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// 
/// Provides a snapshot of timing values.
protected override void Update(GameTime gameTime)
{
     engine.Update();

     gameManager.Update(gameTime);

     if (gameManager.IsGameStateChange())
     {
         switch (gameManager.GetNextState())
         {
             case (int)MageDefenderStates.PressStart:
             {
                 gameManager.ChangeToState(pressStartState);
                 break;
             }
             case (int)MageDefenderStates.MainMenu:
             {
                 menuCue.Stop(AudioStopOptions.Immediate);
                 ingameCue.Stop(AudioStopOptions.Immediate);

                 menuCue = soundBank.GetCue("menuMusic");
                 if (!menuCue.IsPlaying)
                 {
                     menuCue.Play();
                 }
                 gameManager.ChangeToState(mainMenuState);
                 break;
             }
             case (int)MageDefenderStates.Story:
             {
                 gameManager.ChangeToState(storyState);
                 break;
             }
             case (int)MageDefenderStates.Level:
             {
                 menuCue.Stop(AudioStopOptions.Immediate);
                 ingameCue.Stop(AudioStopOptions.Immediate);

                 ingameCue = soundBank.GetCue("ingameMusic");
                 if (!ingameCue.IsPlaying)
                 {
                     ingameCue.Play();
                 }

                 gameManager.ChangeToState(levelState);
                 break;
             }
             case (int)MageDefenderStates.Shop:
             {
                 gameManager.ChangeToState(shopState);
                 break;
             }
             case (int)MageDefenderStates.GameOver:
             {
                 gameManager.ChangeToState(gameOverState);
                 break;
             }
             case (int)MageDefenderStates.Credits:
             {
                 gameManager.ChangeToState(creditsState);
                 break;
             }
         }
     }

     base.Update(gameTime);
}

And a snap from the LevelState screen

public void PrepareNextLevel()
{
    pressTimerPrimary = 500;
    pressTimerSecondary = 500;
    pressTimerSpellBrowse = 500;
    drinkPotionTimer = 500;

    Level nextLevel;
    try
    {
        nextLevel = Game.Content.Load("Levels/level" + (castleHandler.Castle.Level + 1));
    }
    catch(Exception ex)
    {
        nextLevel = new Level();
    }

    isCurrentLevelABoss = nextLevel.IsBoss;

    if (isCurrentLevelABoss)
    {
        if (!nextLevel.BossCodeName.Equals("None"))
        {
            enemyHandler.BossBehaviour = Game.Content.Load("Bosses/" + nextLevel.BossCodeName);
        }
        else
        {
            enemyHandler.BossBehaviour = null;
        }
    }
    else
    {
        enemyHandler.BossBehaviour = null;
    }

    string[] spawnEnemiesofTypes = nextLevel.SpawnEnemies.Split(',');


    spellHandler.NextLevel();
    enemyHandler.NextLevel();
    castleHandler.NextLevel(nextLevel);

    player.Mana = player.MaxMana;
    player.Health = player.MaxHealth;

    foreach(String s in spawnEnemiesofTypes)
    {
        if (s.Equals("Slime1"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Slime);
        }
        if (s.Equals("Slime2"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Slime2);
        }
        if (s.Equals("Slime3"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Slime3);
        }
        if (s.Equals("Slime4"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Slime4);
        }
        if (s.Equals("Ghost"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Ghost);
        }
        if (s.Equals("Zombie"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Zombie);
        }
        if (s.Equals("Skeleton"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Skeleton);
        }
        if (s.Equals("Boss"))
        {
            enemyHandler.SpawnEnemyTypes.Add(GameObjects.EnemyHandler.Enemies.Boss);
        }
    }
}

If you're interested in XNA based game writing, this is a project you might like to dig through...

Getting the Kinect under your skin... Kinect XNA Skinned Model

Greg Duncan — Thu, 15 Mar 2012 13:00:00 GMT

While this project is a little rough around the edges, the output looks to be worth the effort. It's also something I've seen asked for a number of times, the mapping of Kinect gestures to a character model...

XNA Skinned Model - Kinect Rig

This is a XNA application, written in C#, using the Kinect skeleton tracker.
It's possible to animate in real time a skinned model, in this case a warrior (the data is not being recorded, but it could be). The difference to the existing tutorial on msdn's code sample is that they use manual key frame animations.
http://create.msdn.com/en-US/education/catalog/sample/skinned_model
The joint positions given by the kinect skeleton data are being used to calculate the relative angles between adjacent body parts, and then these angles are used for the rotation matrices on each logic bone, present on the 3d model.
In terms of code, nothing needs to be changed in order to use a different 3D model, as long as it uses the same Bone Hierarchy.

----------------------------------------------- Code walk-through
The SkinningSample from MSDN has animation logic over time, and reads each keyframe's transformations from the 'dude' file.
But we want kinect to provide the animation data, so i removed that keyframe part from the code.
The model has Bones, and a Mesh (skin and clothes).
The mesh is linked to the bones, so if we manage to transform a bone using a matrix, we will be automatically transforming the respective body section.
For example, if we add a rotation matrix to the left hip, the whole left leg will be rotating, also because of the bone hierarchy.
In the AnimationPlayer class, you will find UpdateWorldTransforms, UpdateSkinTransforms, and the most important, the UpdateBoneTransforms method. They fill these arrays:
Matrix[] boneTransforms;
Matrix[] worldTransforms;
Matrix[] skinTransforms;
If instead of reading keyframe data, the UpdateBoneTransforms method uses kinect's skeleton data to create transformation matrices for each bone, all we need to do is render.
Kinect provides us with 3d coordinates of each joint of the player, so that would give us a Translation Matrix, but for each bone we already the position, what we need is the rotation, for the leg for example.
So how do you turn points into angles, for the rotation matrix?
You take 3 points, like the kinect positions of: left ankle, left knee and left hip, and you create two vectors (like in physics).
Normalize these 2 vectors, use the Dot product on them, and get their angle using the ArcCos mathematical function (c#: Math.Acos()).
Consider this thread from msdn: http://social.msdn.microsoft.com/Forums/en-AU/kinectsdknuiapi/thread/8516bab7...
Create a rotation matrix for the XY plane using Vectors with z = 0.
Create a rotation matrix for the ZY plane using Vectors with x = 0.
Add your calculated matrix to the boneTransforms[] array, at the correct index.
(I analyzed the example 'dude.fbx' on a text editor, and saw that the order of the bones in the file gives you the index: index 1 is the Pelvis, 3 is the Spine, 7 is the Head, 13 is the Left upper arm, etc...)

------------------------------------------------- Replacing the Model
A while back I tried some tutorials for the "3ds max" modeling software, where you learn to edit bones, (specifically bipeds), and use "Envelope" and "Physique" modifiers to attach these bones to the 3d mesh of your model.
http://www.youtube.com/watch?v=hgL7W8NdTIY
In order to change the model we animate through the kinect device, using the same XNA code/program, we need the same bone hierarchy, so let's copy them.
I didn't have time to try this myself, this is what i will do:
...

Bizzy Bees - A XNA for Windows Phone 7 game building walkthrough

Greg Duncan — Mon, 12 Mar 2012 13:00:00 GMT

Today's Mobile Monday (note: in the future, there might also be Metro Monday projects too... but that's for the future...) is a simple, straight forward and very educational series for creating a XNA based game for Windows Phone 7

XNA for Windows Phone Walkthrough–Creating the Bizzy Bees game

The game is called Bizzy Bees and you can download and play it for free from the Marketplace.
The idea of the app is quite simple… the goal is to collect as many rainbow flowers as you can before all the flowers hit the bottom. You collect flowers by matching flowers and bees, so a yellow flower matches with a yellow be, a pink flower with a pink bee etc. and all bees match up with rainbow flowers
In this series we’ll walk through creating a subset of that game from start to finish.
Step 1: Setting the stage (projects and assets)
Step 2: Drawing the scene
Step 3: Adding flowers
Step 4: Making things move
Step 5: Adding some bees to the mix
Step 6: User interaction
Step 7: Rounding it up
...

What's coolest about this, besides the source we get to play with (see Solution below) is that Tess walks us through all the steps in creating the game...

From a short introduction to writing games in XNA (which is very different than Silverlight) and getting the initial assets (i.e. bitmaps, etc.) setup in, Bizzy Bees Step 1: Setting the stage (XNA walkthrough);

To making stuff actually move in Bizzy Bees Step 4: Making things move (XNA Walkthrough);

And onto the final touches, homework for the reader in Bizzy Bees Step 7: Rounding it up (XNA Walkthrough);

In just about every post Tess provides code snips, graphics, details, how to avoid common problems/issues and commentary related to the task at hand.

If you're looking for a friendly and easy to follow tutorial series for creating XNA based games for Windows Phone 7, this is a series you're going to want to read.

Where there's smoke, fire and explosions... there's the 3D particle engine, Tranquility

Greg Duncan — Mon, 30 Jan 2012 14:00:00 GMT

Today's Mobile Monday project is one that's both simple, yet complicated. Simple in that this project is just one piece of the overall picture of where you can use it. Complicated in that this might be something the average dev might not be able to just knock out.

Let's say you're writing a cool game and you need an explosion to cap it off. You'd don't want a cheesy one, but your not sure where else to go?

Go here...

Tranquility 3D Particle Engine

Tranquility is a compact, easy to use and highly extendible 3D particle system for Windows Phone 7 XNA projects.
For installation/integration, check out the Getting Started Guide. To learn how to use Tranquility check out Using Tranquility.

Using Tranquility

Using Tranquility is easy; most tasks can be achieved in a couple of lines of code. The demo project included with the source showcases more advanced scenarios including AppHub’s fire, smoke and explosion samples.
Particle Manager
All particle properties, behavior and drawing are managed by Tranquility's ParticleManager. ParticleManager is a DrawableGameComponent that can simply be added to your Game’s component collection.
....
Using Tranquility
Using Tranquility is easy; most tasks can be achieved in a couple of lines of code. The demo project included with the source showcases more advanced scenarios including AppHub’s fire, smoke and explosion samples.
Particle Manager
All particle properties, behavior and drawing are managed by Tranquility's ParticleManager. ParticleManager is a DrawableGameComponent that can simply be added to your Game’s component collection.
The ParticleManager needs to know how your world is being viewed. Use the SetMatrices method to set the view and projection matrices.
Particle Systems
A ParticleSystem defines a group of particles that share a texture representation. There are two base particle system types in Tranquility:
StaticParticleSystem: All particles in this system have static properties. Once a particle is added to this system type, it cannot move, grow, change color, etc. Although particles can be added and removed to/from this system on the fly, it is ideal for static allocation of particles.
DynamicParticleSystem:A dynamic particle system contains particles that can have a velocity, rotation, lifespan and can be affected by various affectors.
Creating and registering a particle system
To create a system, specify the maximum capacity and the texture to be used for this system in the LoadContent method. For example, create a dynamic particle system:
..
Particles
The overloaded AddParticle method can be used to add particles to any system. The RandomHelper class can be used to randomize the generation of particles. For example:
particleSystem.AddParticle(
RandomHelper.Vector3Between(Vector3.Up, Vector3.Down),
RandomHelper.Color(),
RandomHelper.NormalizedVector3(),
RandomHelper.Float(),
TimeSpan.FromSeconds(RandomHelper.IntBetween(1, 3))
);
Particle Emitters
Emission of particles can be automated using a particle emitter. To create a custom particle emitter, implement the IParticleEmitter interface:
   1:  public class CustomParticleEmitter : IParticleEmitter 
Implementing the Update method will allow the emitter to automatically emit particles in the particle system it is added to. The Emit method can be used to emit particles manually.
...
Particle Affectors
A particle affector can affect one or more properties of all particles in a system. There are three default affectors in Tranquillity that use the particle’s age as the time factor:
Decelerate: Slows a particle down to a complete stop towards the end of its lifespan. This affectors affects only particles that have a velocity.
Fadeout: Reduces the alpha of a particle until it becomes completely transparent towards the end of its lifespan.
Shrink:Reduces the size of a particle until it disappears completely towards the end of its lifespan.
...

Here's a snap of the Solution. As you can see, it's not crazy or insanely complicated (nor uses another other libraries).

Here's a snip from the Demo;

public FireParticleSystem(int maxCapacity, Texture2D texture)
     : base(maxCapacity, texture)
{

}

public override void Update(GameTime gameTime)
{
     EmitParticles(gameTime);

     foreach (DynamicParticle particle in liveParticles)
     {
         particle.Color = Color.Lerp(particle.InitialColor, new Color(1.0f, 1.0f, 1.0f, 0.0f), 1.0f - particle.Age.Value);
         particle.Scale += 0.001f;
     }

     base.Update(gameTime);
}

private void EmitParticles(GameTime gameTime)
{
     particlesEmitted += (float)gameTime.ElapsedGameTime.TotalSeconds * (float)EmissionRate;

     int emittedCount = (int)particlesEmitted;

     if (emittedCount > 0)
     {
         for (int i = 0; i < emittedCount; i++)
         {
             AddParticle(
                 RandomPointOnCircle(),
                 new Color(255, 255, 255, 100),
                 RandomHelper.Vector3Between(new Vector3(-0.25f, 0.0f, 0.0f), new Vector3(0.25f, 1.0f, 0.0f)),
                 RandomHelper.FloatBetween(-0.01f, 0.1f),
                 TimeSpan.FromSeconds(RandomHelper.IntBetween(1, 2)),
                 true,
                 RandomHelper.FloatBetween(0.0f, MathHelper.TwoPi),
                 RandomHelper.FloatBetween(0.05f, 0.075f));
         }

         particlesEmitted -= emittedCount;
     }
}

This is one of those projects that will help you add that final touch, help you apply a nice bit of polish to your app or game...

ScriptTD: So You Want To Build a Tower Defense Game?

Larry Larsen — Wed, 27 Jul 2011 17:50:33 GMT

As you may have heard me say before, I love Tower Defense games. In fact, I've always wanted to build one or two but the main problem is that I'm better with ideas than programming. On the other hand, TD games are all very similar—creeps go in, creeps (try to) go out. Meanwhile you try your best to build a maze of defensive towers that make sure no creep is left standing. The biggest difference between many TD games is graphics and gameplay. From this the ScriptTD Tower Defense Game Engine was born. Under the patient shepherding of Coding4Fun's Clint Rutkas and with the coding prowess of Michael Quandt, we built this game engine that will let you tweak some graphics, sounds, and XML to make any kind of Tower Defense game you can dream up. If you thought you couldn't make a Windows Phone game, you're probably wrong.

After you hit http://ScriptTD.CodePlex.com for the source code, this tutorial will walk you through each of the XML files that make up ScriptTD and how they should be tweaked to create your own TD game. You are free to submit your game to the Zune Marketplace and hopefully make a little lunch money. If you make a game from ScriptTD, please let me know so I can help get the word out.

To get started with ScriptTD, please check out the ScriptTD Coding4Fun project and download the code from Codeplex, and to try playing the game on your Windows Phone, visit the Zune Marketplace.

ScriptTD: Tower Defense Made Easy

Clint Rutkas, Michael Quandt — Tue, 26 Jul 2011 21:51:15 GMT

ScriptTD is an open source project that allows anyone to easily create a new Tower Defense game for the Windows Phone 7 platform, without any prior programming knowledge. The project lets you create new art & audio and edit some XML files to bring it all together into a polished game without having to write all of the code required to make the game work.

If you are looking to just create a game without coding, this article isn’t for you, head to http://scripttd.codeplex.com and follow the instructions there to get started.

Extending the Code

You can easily get away with editing the XML and adding new assets to make a whole new Tower Defense game with ScriptTD as it is. If you know a bit of C#, however, you can take it further and extend the game to make a unique creation. The entire source code for the project is available for free on Codeplex (see links above), so feel free to download that and change any part of it that you want.

There are three key areas that are easy to change in ScriptTD:

Weapons
The GUI
The Game Screens (Menus)

In this article we are going to focus on the main one you might want to edit—the weapons.

Straight from the Labs

The game already has a number of different weapon types, ranging from projectiles to earthquake generators; the laser included with the project, however, only fires along one of the four cardinal directions (N, S, E, W).

We will extend the code to add in a new type of laser, one that follows a target as it shoots. Remember that the code simply defines the behavior of the weapon, so you could change the art into flame images and create a flamethrower, without changing any of the code you are about to create.

Getting Started

This first thing you need to do before you can start creating your custom weapon is grab the source code for ScriptTD from Codeplex.

Every weapon in the game implements the IWeapon interface, which is provided by the engine. This allows the game to interface in a common way with each weapon type. Once you implement that, simply register the weapon type when the game starts up, and then refer to it in the XML data files when you need to. For the purposes of this article we will work with the sample game, though everything you learn here can easily be applied to your own version of the game.

First begin by creating a new class in the Coding4Fun.ScriptTD.Sample project and name it TrackingWeapon. Once you are done you should have an empty class that looks like this:

 using System.Collections.Generic;
using Coding4Fun.ScriptTD.Engine.Data;
using Coding4Fun.ScriptTD.Engine.Data.Abstracts;
using Coding4Fun.ScriptTD.Engine.Logic;
using Coding4Fun.ScriptTD.Engine.Logic.Instances;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace Coding4Fun.ScriptTD.Sample
{
    public class TrackingWeapon : IWeapon
    {
        public Texture2D Texture { get; set; }
 
        public TowerData TowerData { get; set; }
 
        public bool CanFire()
        {
            throw new System.NotImplementedException();
        }
 
        public bool TargetAndFire(ref List enemies,
            ref Vector2 towerPos, float gridCellSize)
        {
            throw new System.NotImplementedException();
        }
 
        public void Update(float elapsedSeconds, ref GameSession session)
        {
        }
 
        public void Draw(GraphicsDevice device, SpriteBatch sb)
        {
        }
    }
}

When working with weapons in this project, you need to remember that weapons act purely as logic operating on the provided data. Accordingly, the game will provide the texture and specifications for the tower, and you need to make use of that to make the weapon behave as it should. Inside the base class above, we have two properties that are set by the game: Texture and TowerData. These will be set automatically upon creation, so you can generally ignore those unless you want to get info from the texture whenever it changes.

Next we have the CanFire method; this is usually used to check if the tower has finished reloading. Depending on your tower, however, you could do other checks here. The key thing is that this is just telling the game if the tower is ready to fire, rather than if it has any targets.

Finding targets is done in the next method, TargetAndFire. This is where you have access to the list of enemies that you can test against for range/suitability, and based on that choose a target and fire.

After that we have the usual Update and Draw methods, which let you manage shots in flight as well as keeping track of reloading.

For this weapon, we won’t worry about reloading. Instead the weapon will constantly fire at its closest target.

1, 2, 3, Fire!

First we need to tell the game it is ok to fire at any time, so simply make CanFire() return true:

public bool CanFire()
{
    return true;
}

Once that is done, we can begin with the code of the weapon, the TargetAndFire() method. And so we will we doing the following:

Check which enemy is the closest
Make sure we are allowed to shoot at the enemy
Make that enemy the target

First we need a variable to keep track of the closest enemy, and their distance, so we need an EnemyInstance variable and a float. I have named them closest and distSq, respectively, and initialised distSq to float.MaxValue (you’ll see why shortly):

EnemyInstance closest = null;
float distSq = float.MaxValue;

Once we do that, we need to prepare our Min and Max ranges so that we can ensure we only target enemies within that area. To do so, we need to add the following code:

float maxRange = TowerData.MaxRange * gridCellSize;
maxRange *= maxRange;
float minRange = TowerData.MinRange * gridCellSize;
minRange *= minRange;

The MaxRange is stored as the number of cells, so we need to expand this into the actual distance by multiplying with the provided cell size. Then we square it because we will be doing all of our distance tests using the squared length values. We do this to save on performance, and since a square root operation (as required by the Length formula) can be costly, we instead use the squared distance, and as long as everything uses squared distance, it will all be correct.

Next we need to loop through every enemy and check the following:

Can we target the enemy?
- Is it a flyer or land enemy, can we target either?
Is it the closest?
Is it within the Min/Max range

If all of the above is true, we set the enemy to be our closest, and continue iterating through the list of enemies:

for (int i = 0; i < enemies.Count; ++i)
{
    if ((TowerData.CanShootFlyers && enemies[i].Data.CanFly)
        || (TowerData.CanShootLand && !enemies[i].Data.CanFly))
    {
        float d = (enemies[i].Position - towerPos).LengthSquared();
        if (d <= distSq && d <= maxRange && d >= minRange)
        {
            distSq = d;
            closest = enemies[i];
        }
    }
}

Next, we set the closest enemy as the target, and store some helper data for when we draw later. This helper data includes the position of the tower and the size of a grid cell. Finally, we return true if we have a target, which lets the game know if it should play the "Shoot" sound effect:

_towerPos = towerPos;_cellSize = gridCellSize;
_target = closest;
return _target != null;

I’m Taking Damage!

Now we need to make the weapon actually damage the enemy, to do this we add the following code to the Update method:

if (_target != null)
_target.TakeDamage(TowerData.FullName, TowerData.DPS * elapsedSeconds);

If we are currently targeting something, we tell it to take damage based on the information inside TowerData. We do this every update because the tower instantly hits the enemy, and will never miss. The enemy itself will handle decreasing its health and applying any resistances it may have, the only thing we need to do is get the correct damage from the DPS (Damage Per Second) value by multiplying it with the elapsedSeconds variable.

Draw their Fire!

Now we will draw the laser as it fires. First check if we have a target to shoot at:

if (_target == null)
    return;

Now we can start preparing the data we need to create a continuous line of fire towards the enemy:

var origin = new Vector2(Texture.Width / 2f, Texture.Height / 2f);float numSteps = (_target.Position - _towerPos).Length() / _cellSize;

Here we get the center of the texture; we will use this as the origin when drawing in order to ensure it rotates correctly. We also get the number of grid cell sized textures to draw between the tower and the enemy. Then we can loop through this to draw each texture:

for (float i = 1; i < numSteps; ++i)
{
    float x = MathHelper.Lerp(_towerPos.X, _target.Position.X, i / numSteps);
    float y = MathHelper.Lerp(_towerPos.Y, _target.Position.Y, i / numSteps);    Vector2 pos = new Vector2(x, y);
    Vector2 dir = _target.Position - pos;
    dir.Normalize();
    float angle = (float)Math.Atan2(dir.Y, dir.X);    sb.Draw(Texture, pos, null, Color.White, angle, origin, 1, SpriteEffects.None, 0);
}

Here we loop through each step, drawing the texture at an interpolated position. Note the i=1 in the for loop, this lets us start drawing after the tower, so it looks like the laser is emerging from the tower, rather than behind it.

Next we get the X and Y coordinates for the texture. To do this we need to interpolate along the line from the tower to the enemy. We can make use of the built in Lerp function to do this by providing the start and end coordinates (the tower and enemy respectively) and then getting a value from 0 to 1 based on which step we are drawing.

Next we need to ensure the texture is rotated correctly, we do this using some math by getting the direction vector, normalizing it, and then getting the ArcTan value.

Once we have all of the data, we call the appropriate Draw method inside SpriteBatch. The parameters in order are:

The Texture
The Position to draw the texture
A Rectangle describing what portion of the texture to draw (in our case: all of it)
The tint to apply (in our case: no tint, which is Color.White)
The angle with which to rotate the texture around its origin
The origin of the texture
The scale (In our case: 1, we don’t scale the texture)
The SpriteEffects to apply
The depth at which to draw the texture (in our case: in front with everything else)

Weapons in the Armory

Now that we have completed the behavior for the weapon, we can register it with the game, ready for use.

To do this, find the SampleGame class inside the Coding4Fun.ScriptTD.Sample project and scroll down to the RegisterWeapons() method (around line 84).

Add the following line anywhere inside that method:

Armory.AddWeaponType("Tracking", typeof(TrackingWeapon));

Here we are registering the weapon type, and telling the game that it will be called "Tracking" inside the XML files. This lets us use friendlier names whilst maintaining naming conventions in our code.

Now we just need to add this weapon to a tower and try it out.

From the root directory for the project, navigate to:

Coding4Fun.ScriptTD.Content\Data\Towers

And open laser.xml and change the WeaponType attribute from "Laser" to "Tracking".

With that done, compile the game and run it! You can find a laser inside Mission 4, so to try it out select that mission and place the fourth tower. Wait for it to build and for enemies to arrive, and then bask in the glory of your new weapon.

Conclusion

You now know how to add a completely new weapon type to the game, which will let you add a unique touch to your Tower Defense game. There are other areas in the game that you can extend in code, and there is a lot of power in the XML definition files. So if you are interested in learning more, browse the code and the documentation at the Codeplex link at the start of the article. Play around with the behavior, create a new tower in XML, and tweak the values. If you find the sound annoying you can add a delay in between changing targets, or completely remove the sound from the XML. Make whatever you want using the tools available—turn it into something you made. Remember, the tools are free and with some creativity you can make a really great game!

About The Author

I am a student at the University of Technology Sydney, and an R&D Engineer for Orion Integration Pty Ltd, specializing in 3D Visualization, as well as Computer Vision. I have a strong interest in game development, particularly on the Graphics and GPU programming side. I am also a Microsoft Student Partner at my university and the State Lead for the MSPs in New South Wales.

You can contact me at michael@mquandt.com or visit my blog at http://mquandt.com/blog. Feel free to also follow me on Twitter: @quandtm. If you have any questions or suggestions, contact me through one of the above methods, or if you find any issues with ScriptTD, report them on the Codeplex page.

XNA: Game Development – Creating Player Animation

Tina — Mon, 25 Apr 2011 18:46:39 GMT

Animating objects in your game requires setting them up right. In this video, David Thany walks you through creating a sprite strip that animates your player character. Watch, then follow along at http://create.msdn.com/education/tutorial/2dgame/animating_the_player.

We will be featuring a new XNA Game Development video each Monday for the next ten weeks. If you simply can't wait and would love to jump ahead, here are the links to the videos for the entire series.

XNA: Game Development - The Game Loop

Tina — Mon, 18 Apr 2011 18:18:02 GMT

The Game Loop is the beating heart of your gameplay. In this video, Josh Foss and Elbert Perez dissect this critical component of game development. Watch, then code along with the tutorial at http://create.msdn.com/education/tutorial/2dgame/creating_the_player.

XNA: Game Development - Playing Sounds

Tina — Fri, 01 Apr 2011 17:32:18 GMT

Sound and music are the extra kick that makes games truly immersive. In this video, David Thany explains what great games sound like and how to choose the right audio feel. Watch and follow at http://create.msdn.com/education/tutorial/2dgame/playing_sounds.

XNA Game Development on Windows Phone 7 in One Sitting

Bruce D Kyle — Fri, 01 Apr 2011 16:23:27 GMT

A small mobile app development shop of professional video game developers who create XNA games for Windows
Phone 7 in their spare time. This video features their founder, Jason Weimann, talking about their Alpha Strike game, which these developers made virtually in one sitting.

Jason explains how he was able to get his development environment set up using the BizSpark program. Microsoft BizSpark is a global program that helps fast-track the success of early stage technology startups with all the right resources, including software, support & marketing visibility.

Jason talks with Aaron Stannard, ISV Architect Evangelist.

Get Started with Windows Phone 7 Game Development

Tools are free. Get started on Windows Phone 7 or XBox at App Hub.

See the free developer training course for Windows Phone 7 on Channel 9.

Windows Phone 7 in 7 tutorials on MSDEV. Each short, to-the-point video in this series highlights a feature of Windows Phone 7 in less than 7 minutes. This is a series for developers who want to pick up the basics quickly with brief explanations and hands-on examples. Demonstrations and code samples are based on the beta release of the Windows Phone 7 Developer.

Free Help for Windows Phone 7

Join Microsoft Platform Ready for free assistance in developing and marketing your Windows Phone 7 applications.

Up to Date News for ISVs and Software Developers

See US ISV Community blog.

XNA: Game Development – Creating A Beautiful Background

Tina — Thu, 31 Mar 2011 03:19:28 GMT

You don’t have to be a famous artist to make great game art. In this video, David Thany walks you through creating a background that sets the stage for your game. Watch, then draw along with the tutorial at http://create.msdn.com/education/tutorial/2dgame/drawing_the_background.

XNA: Game Development - Designing the Game

Tina — Thu, 31 Mar 2011 03:18:04 GMT

What’s a game made of? In this video, follow Josh Foss as he maps out a 2D shooter game design from start to finish in just four minutes. Watch, then code along with the tutorial at http://create.msdn.com/education/tutorial/2dgame/design.

XNA: Game Development - Creating Player Animation

Tina — Thu, 31 Mar 2011 03:15:10 GMT

XNA: Game Development - Introducing Debugging

Tina — Thu, 31 Mar 2011 03:13:48 GMT

Games can go wrong, but they don’t have to stay that way. In this video, Elbert Perez demonstrates how you can find and squash problems in your code with the debugger. Watch, then code along at http://create.msdn.com/education/tutorial/2dgame/creating_enemies.

XNA: Game Development - Making Games Respond with Collision

Tina — Thu, 31 Mar 2011 03:12:41 GMT

Games are only really games if things bump into one another. In this video, Josh Foss and Elbert Perez show you how and why collision works in both 2D and 3D. Watch, then code along at http://create.msdn.com/education/tutorial/2dgame/collision.

XNA: Game Development Intro

Tina — Thu, 31 Mar 2011 03:11:55 GMT

Get ready to jump into games! In this video, Charles Cox outlines the game you’ll create, the platforms you can choose from, and the toolset you’ll use. Watch this video, then follow the tutorial at http://create.msdn.com/education/tutorial/2dgame/getting_started.

XNA: Game Development - Loading Content Into Your Game

Tina — Thu, 31 Mar 2011 03:11:21 GMT

Dropping graphics and sound into your game is easy. But what are the nuts and bolts
behind it? In this video, Josh Foss and Elbert Perez explain the Content Pipeline. Watch and follow along at http://create.msdn.com/education/tutorial/2dgame/explosions.

XNA: Game Development - Creating a User Interface

Tina — Thu, 31 Mar 2011 03:10:43 GMT

Playing a game should be a no-brainer. This is where user interface can save the day. In this video, David Thany and Elbert Perez explain how to design great UI on all platforms. Watch and code along at http://create.msdn.com/education/tutorial/2dgame/drawing_user_interface.