What?

NUIverse

NUIverse is an application, written to give me a sandbox for exploring “Natural User Interaction” with a large, multi-dimensional dataset. This build for the Samsung SUR40 with Microsoft PixelSense demonstrates multi-touch gestures, multi-user and multi-directional UI, and object-interaction with transparent Byte Tags. This site provides brief instructions for installing, using, and configuring NUIverse.

NUIverse is not intented as an accurate simulation of the solar system and surrounding universe, since it was written in my spare time and the focus was on interaction rather than accuracy. There are many existing applications available for this purpose, such as Microsoft WorldWide Telescope, Celestia, Space Engine etc.

The following video shows the application demonstrated on a Samsung SUR40 with Microsoft PixelSense at WPC 2012.

NUIverse for Windows

As previously discussed, my manipulation processor now supports WM_TOUCH messages, which means that I can do native multitouch on both Windows 7 and Windows 8. I have therefore updated NUIverse for a Windows-release, as shown below in Figure 1.

There are some key differences to the PixelSense-release, as follows:

• No support for tagged objects, since it does not use the Surface 2.0 runtime, nor require PixelSense hardware (though it will run on the latter outside of the Surface Shell).
• Since horizontal form-factor multitouch hardware is generally less-common than vertical form-factors, I have added a single-orientation configuration setting. This is true by default, since even if mounted horizontally, many touchscreens will not deliver the multitouch performance required for simultaneous multi-user interaction.
• Since the Surface Shell added chrome to close the application and by default the application runs full-screen, either drag in a menu control (see note below) and use the exit menu, or press ESC if a keyboard is present.

One of the current issues when running a full-screen desktop app on Windows 8 is that the operating system captures initial touches used for edge-swipes. If touch is maintained after an initial edge-swipe, further edge-swipes are not captured and therefore will add NUIverse controls to the screen. An alternative is to touch the screen and simultaneously edge-swipe, or to use two fingers when edge-swiping.

Several key configuration settings (in NUIverse.exe.config) are worth mentioning. Note that there is no graphical interface for these settings, and that the configuration file needs to be edited by hand (I would recommend saving a copy first):

• PixelWidth and PixelHeight control the resolution used for both windowed and full-screen mode.
• FullScreen controls whether the application runs full-screen (true) or windowed (false).
• For the configuration settings specified in mm to work correctly, set PixelsPerMm to the appropriate value, taking account physical screen size and either PixelWidth or PixelHeight (square pixels are assumed).

To install NUIverse for Windows, proceed as folows:

1. Install the XNA 4.0 runtime.
2. Download and extract NUIverse for Windows (2.75Mb) to a suitable location.
3. Low-resolution textures for several planets and moons are included, but extras can be created or downloaded from http://nuiverse.com.

Here's a snap of the app running on my Windows 8 notebook;

I said there was extensibility?

Extensibility Model Part 2

I previously mentioned that I had implemented an extensibility model, and thought it useful to discuss an example of adding a simple model to earth orbit, as shown below in Figure 1 (further images of which are in the gallery).

Figure 1. Model added to earth orbit. Colonial Raptor model (based on new TV series) by Coxxon.

The "extra" is defined as a folder containing the following items:

• A model in XNB format. XNA has built-in content importers for .x and .fbx (2009.1) formats.
• An optional pair of textures for both diffuse and emissive textures. These are standard image files.
• An XML file defining the "extra", in this case as shown below in Listing 1.

This configuration file specifies that the model should be added to the planetoid "earth" in the "solar" system, both of which are defined in system.xml configuration file.

In order to scale the model correctly, a scale factor is applied to normalize the model to unit length. This can either be applied in the XML scale attribute, or specified in the XNA content processor scale attribute, in which case the XML attribute can be set to 1. A size attribute then defines the maximum length of the model in km. The Colonial Raptor shown in Figure 1 was defined with a size of 8.6m.

The textures are defined in sub-folders "texture" and "emissive". If an emissive texture is not available, an all-black image (e.g. JPEG file) can be used.

The rotation period defines how long it takes for the model to rotate while orbiting the planetoid. If this is the same as the P orbital element, then the same face of the model is presented to the planetoid throughout the orbit. The remaining standard orbital elements specify that the model is in a circular equatorial orbit at an altitude of 500km (the earth has a radius of 6,371km).

Make sure you read through the rest of his NUIverse, and other, articles as they are very interesting and informative... (like his holographic Princes Leia recording post... that's just cool!)

As they clearly states it's not "done" but there is a Windows Store app based on it in the Store, so it might be done enough for you too! 

ANX

This software is not completely production ready and work in progress. We started in September 2011 and many things are still to do and unfinished but we are on a good way. See Current Status for a overview how much of XNA compatibility ANX has reached. This software is mostly usable in a production environment but not all features are finished.

The first goal is to create a 1.0 version which has the same features as XNA and which behaves the same way.

Project Summary

The ANX.Framework is a platform independent game framework which is compatible with Microsoft's XNA Framework.

BTW: ANX is the acronym for 'ANX's not XNA' and XNA is the acronym for 'XNA's not acronymed'

BREAKING NEWS
Today the first ANX game was approved for the Windows 8 store: Whac-A-Hamster by our team member rene87. You can download it here: http://apps.microsoft.com/webpdp/de-DE/app/whac-a-hamster/659d78c8-2eb4-4fe7-8560-d56c849f5827. This is no AAA game and it has a easy concept but it is a great proof-of-concept for our work. It proves that you are able to create Win8 ModernUI games with ANX.

What is the purpose of the ANX.Framework?

The ANX.Framework is a framework which is source compatible with Microsoft's XNA framework 4.0. Source compatibility means, that you can "translate" a XNA game project to be a ANX game project by simply replacing all namespaces from Microsoft.XNA.Framework to ANX.Framework. The advantage of ANX is simply that you are able to swap the RenderSystem, the InputSystem and the AudioSystem. By swapping this systems you are no more limited to run your game using DirectX9 which XNA is using. ANX comes with a DirectX10 RenderSystem as a default. A DirectX 11, DirectX 11.1 and a OpenGL 3 RenderSystem is currently in development. This will make it possible to run your games on Linux and other platforms which are supported by OpenGL etc. simply by swapping the namespaces.

After finishing the work on the core functions of porting the XNA framework over to ANX we will concentrate on finishing more RenderSystems, InputSystems and AudioSystems.

Another important point of the ANX.Framework is the fact, that the DirectX10 RenderSystem (and the DX11 and 11.1 RenderSystems too) are based on the awesome SharpDX project which is known as the fastest managed DirectX wrapper existing.

Current State of the project.

The current state is that we reached the goal of having the same signature as XNA (The way you can call all classes from your project) and we also got a first rendering sample to run on Ubuntu. This doesn't mean we have all of the features implemented yet! However we're making great progress and are working hard on implementing all the features XNA does. The RenderSystems are becoming more stable all the time and also the InputSystem is progressing. The next big task will be the AudioSystems.

...

Is this "yet another game engine"?

No, ANX is not another game engine but it is perfectly suited as basis of your game engine. ANX is a graphics, input and sound framework. It gives you a nice and easy to learn interface to the beasts that handles all the graphics stuff like DirectX and OpenGL. ANX will make it easy for you to dive into game development but you have to code. It is low level but it hasn't a steep learning curve like DirectX and OpenGL.

...

What's also cool is that you get the source for it all, ANX, samples, the whole thing. Is it active? Well there was a check-in just days ago, so yep, it's active.

Heck they even provide a tool to make it easy to convert your XNA game over to ANX.

Documentation - HowTo/ConvertXna

For converting an XNA Game to the ANX Framework you can use the ProjectConverter Tool.

You can choose if the Project should be converted directly, so the result is saved in the source directory, or if it should be saved in a different path.

The tool can be used as a GUI- and a CMD-Variant.
This tool is still in development. If you encounter any errors, please open an Issue for it.

What the tool is doing

Since the ANX Framework is code compatible with XNA it's very easy to convert projects between these two.

The tool simply removes the XNA assembly references in the csproj file and replaces them with the corresponding ANX assemblies.

Then the tool iterates through all the code files associated with the csproj file and replaces all XNA usings with the ANX ones.

It can also convert XNA Content Projects to ANX Content Projects.

Using the Graphical User Interface

If you do not pass any arguments to the application, it will automatically start in GUI mode.

The UI looks like this and should be self explanatory.

Using the Command Line Interface

When starting the tool via cmd you can choose between different operation modes by passing parameters:

...

Included is even a Sample Browser...

If you've got XNA experience and would like to leverage that to build Windows Store apps, or want to use the power of DirectX but don't want to play in the C++ world, or just looking for some interesting code to read, looks like ANX is your ticket!

We're about coding right? So how about we wrap up the year highlighting a open source, c#, game library that will help you build your own cool game? You've undoubtedly have heard of Minecraft? You've maybe wondered if you could create your own like "block" game? Well my friends, today's is just for you!

Voxeliq

Voxeliq is a block engine crafted with C# that can be used to develop block based worlds with any type of gameplay you can imagine. Sandbox games, RPG’s or even RTS games within a blocky world! Engine is still being developed & optimized for production though we already started kicking in our first games with it.

raistlinthewiz / voxeliq

voxeliq is an open source block-based game engine implementation developed with C#. It uses XNA or the Monogame as the basis. It can be compiled with Microsoft .NET or Mono, which means you can run it on Windows, MacOS, and Linux. Please see the file LICENSE for license details.

Copyright (C) 2011 - 2013, Voxeliq Studios

This program is free software; you can redistribute it and/or modify it under the terms of the Microsoft Public License (Ms-PL).

Stay awhile and listen

• Read the FAQ and check the wiki before asking!
• Check out the forums.

More info

• Voxeliq website
• IndieDB
• Steam Greenlight
• voxeliq@github
• voxeliq@codeplex
• voxeliq@reddit
• voxeliq@twitter
• voxeliq@youtube
• voxeliq@facebook

DevLog Videos

• Devlog-IX - MonoGame support
• Devlog-VIII - Speed Test
• Devlog-VII - Bloom Effect
• Devlog-VI
• Devlog-V
• Devlog-IV - Infinitive Terrain 2.0
• Devlog-III - Infinitive Terrain
• Devlog-II
• Devlog-I
• Bonus - Techno Visualizer

The engine and sample game downloaded and ran for me with no problems. If you're using Visual Studio, you'll need to open it in VS 2010. Due to its usage of XNA, it won't load in VS 2012. You'll also obviously need the XNA Game Studio installed too.

Anyway, once opened, here's a snap of the solution.

Here's some snaps of it running on my notebook;

The cool thing is that this sample game really have very little code behind it itself, with the engine doing all the hard work.

There's bascially two CS files for the entire sample game;

The Program.cs is the usual setup stuff;

The VoxeliqGame.cs just setups the environment, UI, etc, telling the engine what's needed and then runs;

And that's about it. The engine does everything else.

Here's a snap of the engine;

So think you've got the idea for the next killer block game? Voxeliq might be just the thing to get your engine started!

• [0:49] Sharing Code: Windows 8 and Windows Phone (Matt Hidinger)
• [2:51] MVP Monday - Connected Apps Made Wicked Easy with Windows Azure Mobile Services (Scott Seely)
• [5:13] TouchDevelop: The Fast Path to Windows 8 and Phone Apps [Clint Edmonson]
• [8:44] Web Development CSRF and XSS Cheat Sheets (Christopher C. Kane), Cross-Site Request Forgery (CSRF) Prevention Cheat Sheet , Cross-Site Scripting (XSS) Prevention Chat Sheet
• [10:22] Windows 8 Game Development using C#, XNA and MonoGame 3.0: Building a Shooter Game Walkthrough – Part 1: Overview, Installation, MonoGame 3.0 Project Creation (Tara E. Walker)
• [14:07] Channel 9 Highlight: Productivity Power Tools for Visual Studio 2012 (Robert Green, Krishna Hosabettu Kamalesha)
• [17:11] NETMF 4.3 Released (Colin Miller )
• [20:25] Channel 9 Highlight: Building Apps for Windows Phone 8 Jump Start (Andy Wigley, Rob Tiffany)
• [22:04] Subscribe! (Clemens Vasters)

Picks of the Week!

• Rick's Pick of the Week: Nokia Launches Magical Slideshow App PhotoBeamer for Windows 8 Lumia Phones
• Duncan's Pick of the Week: Channel 9 App (No link yet...)

1. How to implement the settings charm
2. How to implement the sharing charm
3. How to deal with file reading and writing, threads, and any other topics which vary between platforms
4. How to prepare art assets for Windows
5. A list of links and resources for further reading

Instructor: Alex Schearer, XNA/Monogame gaming expert.

Looking for developer events in Belgium? Your one-stop-shop is here: http://msdn-events.be.

Windows 8, XNA and MonoGame - Part 3, Code Migration and Windows 8 Feature Support

In Part 1 of this series I introduced you to MonoGame for Windows8, an implementation of the XNA namespace that allows you to get your XNA code running on Windows 8 as a Metro Style App.

In Part 2 I documented how to get your development environment configured using GitHub and Visual Studio 2012

In Part 3 I will cover migrating XNA code to Windows 8.and the Windows 8 features you will need to support in order to make your game Windows 8 Store worthy.

What is MonoGame? Bob's covers that well in Part 1;

Using the XNA Framework is not a choice for building a Metro Style App. Official Microsoft guidance on game development is documented here. The recommended way to build highly immersive games on Windows 8 is to use HTML5/JS, XAML/C#, XAML/VB or C++ and DirectX, all great choices. But if you have been developing with XNA and have an existing code base, your only option it would seem is running as a desktop app.

This is where MonoGame comes in…

MonoGame is an Open Source implementation of the Microsoft XNA 4 Framework. The goal is to allow XNA developers on Windows & Windows Phone to port their games to the iOS, Android, Mac OS X, Linux with both PlayStation Suite and Windows 8 support currently under development.

NOTE : This project is not linked with Microsoft or any of it subsidiaries. It is a non-profit, open source project. MonoGame is licensed under the Microsoft Public License (Ms-PL)

MonoGame provides a cross platform XNA Framework implementation for XNA developers who want to take their code to non-Microsoft platforms as well as the ability, thanks to Tom Spillman and James Ford of SickHeadGames, Dean Ellis and several other talented developers, to target Windows 8. Using MonoGame for Windows 8  you can take your XNA code and with a recompile and some additional platformisms create a Metro Style App worthy of the Windows 8 store.

MonoGame is still under development and so any use of it should come with a note of advice to stay on top of that effort. Also as game developers we should always be looking at expanding our game development skills on Windows using HTML5, XAML and DirectX in order to get the most out of the platform. But given that so many developers have XNA games, MonoGame for Windows 8 is a viable migration solution in the near term.

...

...

Part 2 covers getting your MonoGame dev environment setup and ready for coding.

In Part 3 he gets to work converting and writing XNA Windows 8 Store app's (which he gives you the Source for too

Metro Tic-Tac-Toe

My next project with MonoGame was to build a simple 2D game from scratch and add the feature support necessary for Windows 8 Store submission. I decided to implement the ancient game of strategy, intrigue and cunning…tic-tac-toe.

...

One of the great tips was how to deal with XNA Content Pipeline projects (which VS 2012 doesn't have support for yet);

The Content Pipeline

From XNA Content Pipeline Overview

The Content Pipeline is a special set of assemblies included with XNA Game Studio that use MSBuild to compile game assets such as image and sound files into streamlined, pre-processed binary files called XNBs (so named for the fact that the file extension of the compiled version of a source file is changed to .xnb) which load quickly at run-time.

At this time, MonoGame does not have an implementation of the Content Pipeline and Visual Studio 2012 RC does not have native support for XNA development therefore we will need another way to create the XNB files from our graphic and sounds assets.
That is where Visual Studio 2010 comes in. You can use Visual Studio 2010 to compile your graphics assets and then add them to your Visual Studio 2012 MonoGame project.

...

Finally he provides the information and tips for making your MonoGame a Good Windows 8 Store Citizen

Supporting Windows 8 Features to Make Your App Store Worthy

Once you have your XNA application running on Windows 8 you will want to add the features that the Windows 8 Store requires for all Metro Style Apps. Chris Bowen has written a great piece called The Top Ten Secrets of App Success that details several of the most critical features you need to support. I will cover some of these here. These features include but are not limited to:

• App Tiles and Splash Screens
• Using the MessageDialog
• Screen Management – Snap, Landscape and Portrait
• Process Lifetime Management (PLM)

...

While you do have to jump through a number of hoops to make this work, if you have a good bit invest in XNA and don't want to jump to DirectX directly MonoGame could be a viable option for you.

So when I saw the two mixed in this proof of concept, a example of running XNA inside of Unity3D (let alone that the Platformer Sample was used), well...

Announcing UnityXNA – XNA Inside Unity3D

I had a theory that it would be straightforward to get XNA games running in Unity3D so I decided to give it a go.

This is a proof of concept showing the Platformer XNA sample running inside Unity3D. Zero code changes have been made to the original game code. Using a mixture of new code and some code from MonoXNA I’ve implemented XNA emulation by having a game object with a script attached run an XNA game performing updates and drawing.

You can see the game in your browser here and download the source here.

Implemented so far:

1. Basic game loop and GameTime calculation.
2. ContentManager loads Texture2Ds, SoundEffects and Songs, each wrapping the relevant Unity3D object.
3. SpriteBatch Draw implemented using a draw queue, specifically created for the purpose. Currently supports colour tinting, source rectangles, and sprite effect flip modes.
4. SpriteBatch DrawString has limited support, rendering the text in the correct position and with the correct colour.
5. Support for playing Songs through MediaPlayer and playing SoundEffects
6. KeyboardStates emulated for a limited set of keys which are mapped from their XNA values to Unity3D KeyCodes.
7. Zero code changes to the game needed to run Platformer sample

Known issues, immediate areas for improvement:

1. SpriteFont is not supported, all DrawStrings render with the default GUI Label font.
2. Frame rate is currently vsync’d at 60 frames per second. When vsync is disabled GameTime is not calculated correctly.
3. Windows Media Audio (.wma) is not supported by Unity3D, so I’ve converted the sample audio files to Ogg Vorbis (.ogg).
4. Keyboard input is currently limited to a small set of keys, more mappings between XNA Keys and Unity3D KeyCodes need creating.
5. Mouse, gamepad and touch input are not currently implemented.

If you're interested in seeing how it's done, check out the source on Github here.

If you just want to see it work, via the Unity3D Web Player, check it out here.

• [0:25] Windows 8 has reached the RTM milestone [Brandon LeBlanc]
• [1:48] Visual Studio 2012 and .NET 4.5 Complete! (S. Somasegar)
• [2:34] Introducing HTML & JS Templates for Metro Apps (Caleb McElrath)
• [4:03] Writing a Visual Studio 2012 Unit Test Adapter (Mathew Aniyan)
• [6:09] Windows 8, XNA and MonoGame – Part 1, Overview, Windows 8, XNA and MonoGame - Part 2, Getting Started (Bob Familiar)
• [7:02] Channel 9 Highlight: HTML5 & CSS3 Fundamentals: Development for Absolute Beginners (Clint Rutkas, Bob Tabor, Golnaz)
• [8:15] FoxIE (Christian Heilmann, Rey Bango)
• [9:18] Hidden Gems inside .Net Classes (Dean Hume)
• [10:15] First Release of Factual C# / .NET Driver, About Factual

Picks of the Week!

• Brian's Pick of the Week:[11:43] Outlook.com
• Dan's Pick of the Week:[13:42] Keeping an eye it with an object tracking .Net Gadgeteer robot

Next Steps:
Step #1 – Download the Tools for Windows 8 App Development
Step #2 – Download Visual Studio Express for Windows 8
Step #3 – Start building your own Apps for Windows 8

Subscribe to our podcast via iTunes, Zune, or RSS

If you're interested in learning more about the products or solutions discussed in this episode, click on any of the below links for free, in-depth information:

Websites:

• Random Salad Games
• Getting started with Windows 8 Apps
• How to Sell Your Apps and Make Money in the Windows Store
• Attend a Windows 8 Developer Camp and Hackathon in your area!

Blogs & Articles:

• Jerry Nixon’s Blog

Videos:

• Microsoft DevRadio: Building and Publishing Great Apps in Windows 8
• Microsoft DevRadio: “ Lessons Learned” Developing a Windows 8 app for the “Rock, Paper, Azure” challenge
• Microsoft DevRadio: How to Convert Your Windows Phone App into a Windows 8 Application
• Microsoft DevRadio: Developing for Windows 8 in 1/2 the time (Part1) Getting Started

Virtual Labs:

• Windows 8 Release Preview Virtual Labs

Looks like I wasn't the only one. Via the magic that is OSS, Steve Dunn forked the project and released an XNA 4.0 version. Now we can GLEED2D with the latest XNA...

SteveDunn / Gleed2D

Usage under the Microsoft Public License (Ms-PL)

Detailed information on the wiki: http://github.com/SteveDunn/Gleed2D/wiki

**IF YOU'RE DOWNLOADING THE ZIP FILE OF THE SOURCE, ENSURE YOU UNBLOCK IT IN EXPLORER BEFORE YOU BUILD IT, OTHERWISE YOU'LL GET AN SGEN ERROR IN VISUAL STUDIO!!**

This is a re-write of the original GLEED2D tool (at http://gleed2d.codeplex.com/)

This version is plug-in based.  All the shapes you see are plug-ins.  The behaviours and lighting are also plug-ins.

Apart from the plug-ins, the other major differences are:

• Loading of levels is now done by including the Gleed2D.InGame assembly (there's versions for Windows, XBox, and Windows Phone), and creating a `LevelLoader` object.
• When a Level is loaded, nothing is drawn.  The previous version drew textures, but this one doesn't. Create your own in-game objects to do the drawing.

Although the format of the files have changed, **you can still import your old Gleed files** and save them in the new format.

What is GLEED2D?

Overview

Gleed 2D (Generic Level Editor 2D) is a general purpose, non tile-based Level Editor for 2D games of any genre that allows arbitrary placement of textures and other items in 2D space. This GitHub repository is the home for the new rewritten tool. For the original tool, please see here

Levels are saved in XML format. Custom Properties can be added to the items in order to represent game-specific data/events/associations between items etc.

Gleed 2D is free software and is written in C# and XNA Game Studio 4.0. You need the XNA Framework Redistributable 4.0 (download from Microsoft) and the Microsoft .Net Framework 4.0 to run it.

See here for some videos of the tool.

Features

• placing & editing textures (move, rotate, scale, flip, tint)
• multiple layers
• several tools (align horizontally, etc.)
• primitive items (rectangle, circle, path)
• Custom Properties per item/layer/level
• undo/redo
• save to XML
• editing multiple items at once
• toggle visibility per item/layer/level
• preview in your application
• parallax scrolling

It is based on the original tool of the same name. The difference here is that the code has been reworked so that everything is a plug-in. All the elements here are plug-ins. Examples of the plug-ins are:

• Shapes (Rectangle, Path, and Circle)
• Lighting (Lights, Hulls)
• Behaviours

The tool generates an XML file. In your game, you instantiate a component in the Gleed library which reads this XML and you end up with an in-memory object model of your level.

There are two pieces to the Gleed project:

• The main Gleed tool which produces the XML output
• Components that read the XML (versions for Windows, XBox360, and Windows Phone 7.1)

Here's some things you might want to know about:

• Loading a level in your game
• Overview of the code
• What plugins are available
• The format of the XML output

So you not only get a cool level creator for your game, BUT you get the source for that level editor too.

Here's a snap of the Solution, which compiled and ran for me the first time with no problems or issues;

Here's some snaps of the running app.

If you are creating a game and need a level creator/editor, thinking about writing one or just looking for something fun to mess around with, GLEED2D is singing your song...

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

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

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

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

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...

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?

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...

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.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
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<Level>("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<BossBehaviour>("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...

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:

...

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.

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...

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.

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<EnemyInstance> 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.

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 Intro
XNA: Game Development - Designing the Game
XNA: Game Development - The Game Loop
XNA: Game Development - Creating Player Animation
XNA: Game Development - Creating a Beautiful Background
XNA: Game Development - Introducing Debugging
XNA: Game Development - Making Games Respond with Collision
XNA: Game Development - Loading Content Into Your Game
XNA: Game Development - Playing Sounds
XNA: Game Development - Creating a User Interface
XNA: Game Development - You did it! Now what?

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 Intro
XNA: Game Development - Designing the Game
XNA: Game Development - The Game Loop
XNA: Game Development - Creating Player Animation
XNA: Game Development - Creating a Beautiful Background
XNA: Game Development - Introducing Debugging
XNA: Game Development - Making Games Respond with Collision
XNA: Game Development - Loading Content Into Your Game
XNA: Game Development - Playing Sounds
XNA: Game Development - Creating a User Interface
XNA: Game Development - You did it! Now what?