Overview

Last time we met in Part 5 of this blog series, we created an animation to bring the ship to life by simulation of movement and propulsion. We also created and added a more realistic background to the game by the creation of a parallaxing background by layering three distinct images and moving them in and/or of the game screen's view by simulate the sky with clouds moving as the ship flies through the background. In the comments of Part 5, we got some great feedback on the variations of how people handled the Parallaxing background screen refresh on various machines and would not have a smooth jitter. One such comment and example was well throughout and I want to share it with you all so that you can update your game accordingly if desired. Tim Eicher ( teicher) updated the Shooter parallaxing background by creating a function WrapTextureToLeft and WrapTextureToRight (shown below) and changing the position and scale variables (see full code at https://bitbucket.org/teicher/shootertutorial. Thanks Tim for sharing this Excellent code update with us all!

1. private void WrapTextureToLeft(int index)
2. {
3. // If the textures are scrolling to the left, when the tile wraps, it should be put at the
4. // one pixel to the right of the tile before it.
5. int prevTexture = index - 1;
6. if (prevTexture < 0)
7. prevTexture = _positions.Length - 1;
8.  
9. _positions[index].X = _positions[prevTexture].X + _texture.Width;
10. }
11.  
12. private void WrapTextureToRight(int index)
13. {
14. // If the textures are scrolling to the right, when the tile wraps, it should be
15. //placed to the left of the tile that comes after it.
16.  
17. int nextTexture = index + 1;
18. if (nextTexture == _positions.Length)
19. nextTexture = 0;
20.  
21. _positions[index].X = _positions[nextTexture].X - _texture.Width;
22. }

Now on with the tutorial. Let's just into how to create enemies for the game and animate the enemy graphic.

See the Complete Post Here

This tutorial will introduce you to game development on Windows 8 by using the MonoGame open source library, and Visual Studio 2012.

During the course of this tutorial, you will build a 2D game by using MonoGame while becoming familiar with the key concepts of game development.

The focus of this tutorial is writing a game that has multiple elements on screen at the same time. Since the game must keep track of the elements by rendering them, updating them and tracking the ways in which they interact with each other, this will present a challenge from both a logical and performance perspective.

See the Complete Post Here

Hi All:     

As I finalize two great blog posts, I wanted to announce my new blog: www.tarathegeekgirl.net. No need for alarm, however, my MSDN blog (this one) will be maintained and all new blog posts of the MSDN blog be the summaries of the detailed blog posts located at the new blog site. You can visit this blog and check out what technology information, tutorials, and/or code samples are being posted at new blog, and if something strikes your eye simply click the link at the end of the summary for the full post.

Thanks for checking out my blog and joining me on my technical adventures!

Up next 2 new blogs posts:

Part 6 of the MonoGame Shooter Tutorial and walkthrough of my joint Monogame Cross-Platform presentation and code from the great MonkeySpace conference (www.monkeyspace.org) I had the privileged to be a part of that was held in July.

Happy Coding!

In Part 4 of this blog series, we added the ability for the user to interact with the game using all forms of User Input, (i.e. Touch, Mouse, GamePad, etc.). Now, we need to make the game much more graphically astute and provide a more pleasurable experience. To do this we need to add some animation and a more realistic background to the game. When we added the graphics in Part 2 of this series, we included a sprite sheet which has eight (8) pictures of different states of the player ship. We will now use this to create an animation for the ship's movement. If we treat each of the different picture states of the ship as frames, we can cycle through each frame continuously throughout the game loop to given the illusion of ship fluttering; thus providing animation to the game. In order to provide a realistic background to the Shooter game, we need to simulate the sky with clouds moving as the ship flies through the background.

Create Animation class and methods

So now let's add animation to the ship. In order to do this, create a class called Animation. Add a new class to your project by right clicking on the Win8Shooter project and selecting Add and New Item, select Class or by pressing SHIFT + ALT + C, and typing in the name Animation.cs. Press ENTER.

Inside our new Animation.cs code file, replace a few lines at the very top. Delete all the using statements at the top, and replace them with the following lines:

using System;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.Graphics;

Place your cursor just after the {mark inside the Animation class. Add a new line and add the following lines:

// The image representing the collection of images used for animation

Texture2D spriteStrip;

// The scale used to display the sprite strip

float scale;

// The time since we last updated the frame

int elapsedTime;

// The time we display a frame until the next one

int frameTime;

// The number of frames that the animation contains

int frameCount;

// The index of the current frame we are displaying

int currentFrame;

// The color of the frame we will be displaying

Color color;

// The area of the image strip we want to display

Rectangle sourceRect = new Rectangle();

// The area where we want to display the image strip in the game

Rectangle destinationRect = new Rectangle();

// Width of a given frame

public int FrameWidth;

// Height of a given frame

public int FrameHeight;

// The state of the Animation

public bool Active;

// Determines if the animation will keep playing or deactivate after one run

public bool Looping;

// Width of a given frame

public Vector2 Position;

public void Initialize()

{

}

public void Update()

{

}

public void Draw()

{

}

You'll notice, much like the Player class, we have an Initialize(), Update(), and Draw() method; animations need all three to be able to work right. Let's start by filling out the Initialize() method. We will add some parameters that we can pass in each time we create a new animation, and then we will store the parameters to control the animation.

Replace the Initialize() method you just filled in with this version:

public void Initialize(Texture2D texture, Vector2 position, int frameWidth, int frameHeight, int frameCount, int frametime, Color color, float scale, bool looping)

{

// Keep a local copy of the values passed in

this.color = color;

this.FrameWidth = frameWidth;

this.FrameHeight = frameHeight;

this.frameCount = frameCount;

this.frameTime = frametime;

this.scale = scale;

Looping = looping;

Position = position;

spriteStrip = texture;

// Set the time to zero

elapsedTime = 0;

currentFrame = 0;

// Set the Animation to active by default

Active = true;

}

When we initialize a class object, we generally assign the object's variables to copies of the values that are coming in from the parameters. This will come in very handy as we use this Animation class more and more – you can call Initialize() once for every object you want to use animation with different graphics, timings, and sizes, and each Animation object can then run on its own using the data you've passed in. You can have an animation for every object in your game. Like the Update() methods in the Game1 class, this method operates on GameTime – we'll use this method to do the heavy lifting to decide whether or not enough time has passed in the animation to switch it to the next frame, and do the calculation to turn the frame count into the actual pixels we want to draw on the screen. Replace the Update() method in Animation.cs you just filled in above with this version:

public void Update(GameTime gameTime)

{

// Do not update the game if we are not active

if (Active == false) return;

// Update the elapsed time

elapsedTime += (int)gameTime.ElapsedGameTime.TotalMilliseconds;

// If the elapsed time is larger than the frame time

// we need to switch frames

if (elapsedTime > frameTime)

{

// Move to the next frame

currentFrame++;

// If the currentFrame is equal to frameCount reset currentFrame to zero

if (currentFrame == frameCount)

{

currentFrame = 0;

// If we are not looping deactivate the animation

if (Looping == false)

Active = false;

}

// Reset the elapsed time to zero

elapsedTime = 0;

}

// Grab the correct frame in the image strip by multiplying the currentFrame index by the

Frame width

sourceRect = new Rectangle(currentFrame * FrameWidth, 0, FrameWidth, FrameHeight);  

// Grab the correct frame in the image strip by multiplying the currentFrame index by the frame width

destinationRect = new Rectangle((int)Position.X - (int)(FrameWidth * scale) / 2,

(int)Position.Y - (int)(FrameHeight * scale) / 2,

(int)(FrameWidth * scale),

(int)(FrameHeight * scale));

}

All of the information about which pixels of the sprite sheet need to be drawn is stored in the sourceRect and destinationRect objects. This is what the Draw() method will consume to draw the right frame to the screen. Let's complete the Draw() method and our work in this class will be done. Replace the Draw() method you just filled in above with this version:

// Draw the Animation Strip

public void Draw(SpriteBatch spriteBatch)

{

// Only draw the animation when we are active

if (Active)

{

spriteBatch.Draw(spriteStrip, destinationRect, sourceRect, color);

}

}

Now, any object we want to draw on the screen can be animated using this class. Right now, the game is using a simple Texture2D to represent the player graphically on screen, but we can now leverage this class to animate the player graphic on the screen by cycling through each frame of the sprite sheet using the Animation class.

Update the Player class to use Animation

Now let's use this Animation class with the Player object to give our player graphic a bit of motion. So switch to the Player class by double-clicking the Player.cs file in the Solution Explorer in Visual Studio. Let's start by replacing all the correct namespace for the Animation class in the Player.cs file by adding the following line of code under the last using statement:

using Win8ShooterGame;

Near the top of the Player.cs file, just after the first { mark after the Player class begins, comment out the public Texture2D PlayerTexture; and add the following line underneath:

//public Texture2D PlayerTexture;

public Animation PlayerAnimation;

Now that we've removed the old Texture2D, there are a number of methods that won't work if we tried to build and run right now. We need to go change them, starting with the Initialize() method. Scan down the Player.cs file and find the Initialize() method. Replace it with the following:

public void Initialize(Animation animation, Vector2 position)

{

PlayerAnimation = animation;

// Set the starting position of the player around the middle of the screen and to the back

Position = position;

// Set the player to be active

Active = true;

// Set the player health

Health = 100;

}

We also have two properties that are relying on the old texture data. We need to change them. Find the Width and Height properties in the Player class, and replace them with the following:

public int Width

{

get { return PlayerAnimation.FrameWidth; }

}

// Get the height of the player ship

public int Height

{

get { return PlayerAnimation.FrameHeight; }

}

Find the Draw() method and replace it with the following:

public void Draw(SpriteBatch spriteBatch)

{

PlayerAnimation.Draw(spriteBatch);

}

Finally, find the Update() method in the Player class and replace it with the following:

// Update the player animation

public void Update(GameTime gameTime)

{

PlayerAnimation.Position = Position;

PlayerAnimation.Update(gameTime);

}

Update the Game class to use Animation

The only step left is to tell the game to create the Animation and Initialize it with a sprite strip graphical file. The appropriate place to do this is in the LoadContent() method, where we were previously loading the static texture. Find the LoadContent() method in the Game.cs file.

Find the line marked player.Initialize(Content.Load<Texture2D>("player"), playerPosition) and replace it with the following:

// Load the player resources

Animation playerAnimation = new Animation();

Texture2D playerTexture = Content.Load<Texture2D>("Graphics\\shipAnimation");

playerAnimation.Initialize(playerTexture, Vector2.Zero, 115, 69, 8, 30, Color.White, 1f, true);

Vector2 playerPosition = new Vector2(GraphicsDevice.Viewport.TitleSafeArea.X,

GraphicsDevice.Viewport.TitleSafeArea.Y

+ GraphicsDevice.Viewport.TitleSafeArea.Height / 2);

player.Initialize(playerAnimation, playerPosition);

And finally, we need to pass the timing from the game loop's Update() method into the Player class, so its Update() method can pass that onto the Animation class. To do this, we'll put a line in the UpdatePlayer(). Find the UpdatePlayer() method. At the top of the method, add the following line:

player.Update(gameTime);

You should still be able to move the ship around just as in the previous step, but now, you should see some fluttering effects from the sails and steam from the back of the ship.

Creating and Drawing a Parallaxing Background

Our next step is to perform a bit of visual trickery to give the impression that we are not simply floating in blue space, but rather racing through clouds. We could just draw a single cloud background and move it from right to left, but we can do better. We will draw a parallax background. Parallax is a term used for drawing several layers of images that move at different speeds, giving the illusion of depth

Step 1 – Create Parallax Background class

Create a class for this new type of parallaxing background object, write all the necessary functionality inside it, and then link it up inside our Game1 class. Add a new class to your project by pressing SHIFT + ALT + C, and typing in the name ParallaxingBackground.cs. Press ENTER.

Inside our new code file, the first thing to do is replace a few lines at the very top. Delete all the using statements at the top, and replace them with the following lines:

// ParallaxingBackground.cs

using System;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.Graphics;

As we did in the Animation class, we'll set up all the data we'll need and create in our standard Initialize(), Update(), and Draw() methods to fill in later. Place your cursor just after the { mark inside the ParallaxingBackground class. Add a new line and add the following lines of code:

// The image representing the parallaxing background

Texture2D texture;

// An array of positions of the parallaxing background

Vector2[] positions;

// The speed which the background is moving

int speed;

public void Initialize()

{

}

public void Update()

{

}

public void Draw()

{

}

Step 2 – Update Parallax Background class to Create Scrolling Background

As you can see, it is not a whole lot of data. It has one Texture2D, and an array of Vector2 objects, as shown by the [] marks. An array is a way of storing multiple copies of the same type of object and operating on them quickly. You will see more of these as we go. Finally, we use an int to determine the speed of the background. Like we showed in the diagram above, we'll have two parallaxing layers on top of a static background – so in the end, we'll make two of these ParallaxingBackground objects inside the Game1 class and then a basic Texture2D for the static part. The next thing to do is start filling out the methods of this class. Let's start with Initialize(). We'll write some code that takes in a path to a graphical file and some size and speed parameters to fill out the class data. Replace the Initialize() method with the following lines of code:

public void Initialize(ContentManager content, String texturePath, int screenWidth, int screenHeight, int speed)

{

bgHeight = screenHeight;

bgWidth = screenWidth;

// Load the background texture we will be using

texture = content.Load<Texture2D>(texturePath);

// Set the speed of the background

this.speed = speed;

// If we divide the screen with the texture width then we can determine the number of tiles need.

// We add 1 to it so that we won't have a gap in the tiling

positions = new Vector2[screenWidth / texture.Width + 1];

// Set the initial positions of the parallaxing background

for (int i = 0; i < positions.Length; i++)

{

    // We need the tiles to be side by side to create a tiling effect

positions[i] = new Vector2(i * texture.Width, 0);

}

}

First, we're calling Load() to initialize the requested graphic from disk , we've normally done this inside Game1.LoadContent(). We're simply passing in the ContentManager that does the loading instead. Next, we're filling in the array and giving it a length of new Vector2[screenWidth / texture.Width + 1]. In this case, it is dividing the whole screen size by the size of the texture we are using for the background, and then adding 1, so we will always have enough tiles of background plus one more sitting off the edge of the screen so it'll appear to smoothly scroll in. We instantiated the array, but we need to set the values of the Vector2 objects inside the array. The for loop is how we create the objects and set each to be a Vector2 with an X value of i * texture.Width, and a Y value of 0. Inside the Update() method, we're going to move our background by changing its Position vector – similar to how we move the player's ship inside the Player class. Inside the Update() method enter the following lines of code:

public void Update(GameTime gametime)

{

    // Update the positions of the background

for (int i = 0; i < positions.Length; i++)

{

    // Update the position of the screen by adding the speed

positions[i].X += speed;

// If the speed has the background moving to the left

if (speed <= 0)

{

        // Check the texture is out of view then put that texture at the end of the screen

if (positions[i].X <= -texture.Width)

{

positions[i].X = texture.Width * (positions.Length - 1);

}

}

// If the speed has the background moving to the right

else

{

     // Check if the texture is out of view then position it to the start of the screen

if (positions[i].X >= texture.Width * (positions.Length - 1))

{

positions[i].X = -texture.Width;

}

}

}

}

We're moving each tile of the background along its x-axis – that's horizontal movement. If the speed is positive, we increase the position in the positive x-axis, which moves the tile to the right. If the speed is negative, we adjust the position in the negative x-axis, moving the tile to the left. If a tile has scrolled completely past the end of the screen, we reset it to the beginning. If you think about what we're doing graphically, it's just a visual trick done off-screen. Because we always have one more tile of background that's outside the screen, we just keep swapping it around; when the tile goes from right to left completely and disappears off screen, we reset it back to outside the screen on the right, so it will slide back into view all over again. Since there's already a tile in view, the player never notices the change. This loop will go on forever and give a feeling of smooth animation with no gaps. We're done updating, now we need to Draw() the background. We will create a rectangle that will be the base for the background image that we will draw update with the new position as it moved. Then we will draw texture within the rectangle in the Draw method. To accomplish this replace the Draw() method with the following code:

public void Draw(SpriteBatch spriteBatch)

{

for (int i = 0; i < positions.Length; i++)

{

Rectangle rectBg = new Rectangle((int)positions[i].X, (int)positions[i].Y, bgWidth, bgHeight);

spriteBatch.Draw(texture, rectBg, Color.White);

}

}

Step 3 – Update Game.cs class to use Parallax Background class/object

We now need to create a couple of these background objects in our Game1 class, and integrate them into the Game1 class methods of Initialize(), LoadContent(), Update(), and Draw() to get them into the game. Switch to the Game1 class by double-clicking the Game1.cs file in the Solution Explorer in Visual Studio. Look for the first { mark under the start of the Game1 class, and go just below the float playerMoveSpeed you added in the input step. Add a new line and then add the following:

// Image used to display the static background

Texture2D mainBackground;

Rectangle rectBackground;

float scale = 1f;

There's our two parallaxing layers and the static third background layer. Now, let's initialize them. Look down the code, find the Initialize() method. Inside that method, below the player = new Player(); add these lines:

//Background

bgLayer1 = new ParallaxingBackground();

bgLayer2 = new ParallaxingBackground();

So far, so good. Now, we'll load the appropriate textures in from disk in the LoadContent() method. Look down the code, find the method called protected override void LoadContent(). Inside that method, below the player.Initialize call, add these lines of code to method:

// Load the parallaxing background

bgLayer1.Initialize(Content, "Graphics/bgLayer1", GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, -1);

bgLayer2.Initialize(Content, "Graphics/bgLayer2", GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, -2);

mainBackground = Content.Load<Texture2D>("Graphics/mainbackground");

Just two more to go – we need to add code to Update and Draw. Look for the Update() method inside the Game1 class, and after the UpdatePlayer call, add the following lines:

// Update the parallaxing background

bgLayer1.Update(gameTime);

bgLayer2.Update(gameTime);

And finally, we'll draw the static background, then the two parallaxing backgrounds on top of it. Careful here! The order in which you run these methods is very important. You want to draw the background first, then draw the player afterward. If you do it backwards, the background will draw right on top of the player and hide them. Look for the Draw() method. Inside the method, before you call player.Draw(), add these lines:

//Draw the Main Background Texture

_spriteBatch.Draw(mainBackground, rectBackground, Color.White);

// Draw the moving background

bgLayer1.Draw(_spriteBatch);

bgLayer2.Draw(_spriteBatch);

In conclusion, this walkthrough demonstrated how to create an animation class that can be used to animate textures by cycling through the frame sprite sheets. We used this class to animate our player texture and make our ship behave realistically. Afterwards, we went through the steps to create a base background and create the illusion of the sky moving within the game by creating a parallaxing background.

In Part 6 of this series, we will add logic to create enemies and animate them through the game, in order to present a challenge for the player of the game.

The MonoGame team announced the immediate availability of MonoGame 3.0 Stable version on Jan. 21^st. The MonoGame team had this to say about their latest release: A lot of work has gone into preparing this major release, with considerable refactoring of the code base to support 3D and enhanced XNA 4.x compatibility. To install the latest release go to http://www.monogame.net/downloads and select your operating system. If you are on Windows, there is a Windows installer which will install the appropriate assemblies and project templates for Visual Studio 2010 and 2012. So what are the cool new things included in this release? Glad you asked! Please note the listing below of new features added with this latest release:

Needless to say the MonoGame team rocks!

Alright, now on with the tutorial and our discussion of adding and tracking user inputs using Keyboard, GamePad, Mouse, and Touch.

Overview

Now that we have added our content pipeline and successfully have our player graphic drawing (the golden airship) being rendered on the screen, we can add a critical component that every game needs: Ability to move the player around based on various types of user input. Therefore, this tutorial will show how you can adding input logic enabling the ship to move around the screen, and hopefully save you time, pain, and research of how this should be handled with MonoGame in Windows 8.

Updating the Game Loop to Process User Inputs

Open up the core game file named Game1.cs within your Win8ShooterGame project and select the Update() method. Like Draw() method, the Update() method is called automatically many times per second (the target rate is approximately thirty times or more per second). By tracking delta-time taken between calls- of the Update() method, incremental changes can be made to the game such as the player's position. Give this is a first person shooter game, the core of the game is the ability for the player to move around the screen. Since Windows 8 devices have a wide range of inputs available, let's add code to take and respond to user input from the keyboard, a Gamepad, the Mouse, and/or a Touch screen. We can write and track input for all four by adding the appropriate Device State object and update them all in the same function in order for all to be processed when needed.

Step 1: Initialization of Game Loop to Process Player inputs

First let's add the correct XNA libraries to the Win8ShooterGame. Go to the top of Game1.cs file, where you see the using statements. At the end of the list of the using statements on a new line, add the following lines of code:

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Input.Touch;

Now in order to process the inputs, we need to add objects specific the input type and track the State of each input type. So within the Game1.cs go to the Player player declaration line of code. Add a new line directly below this statement and then add the following lines of code:

// Keyboard states used to determine key presses

KeyboardState currentKeyboardState;

KeyboardState previousKeyboardState;

// Gamepad states used to determine button presses

GamePadState currentGamePadState;

GamePadState previousGamePadState;

//Mouse states used to track Mouse button press

MouseState currentMouseState;

MouseState previousMouseState;

// A movement speed for the player

float playerMoveSpeed;

Now let's initialize these object when the Game starts by updating the Initialize method. Select the Initialize() method from within the Game1.cs file. See Figure 1 below.

 Figure 1 Locating the Initialize() Method in Game1.cs

Within the Initialize() Method, find the code which we create a new player ( player = new Player ();). Underneath this call to the player class constructor, let's add a constant for the speed in which the player object should move. Add the following lines of code:

// Set a constant player move speed

playerMoveSpeed = 8.0f;

Now let's enable Touch for the Game by adding initializing the types of Gestures that should be enabled for our Shooter game. For our Shooter Game we will give users the ability to freely drag the ship using touch. We will discuss the usage of Touch in Windows 8 using MonoGame in more detail when we add the code to handle user Touch input. But now let's initialize the Gesture we desire (FreeDrag) to be used by the game by setting TouchPanel.EnabledGestures value which is an enumeration of for various gestures denoted by the GestureType enum. Let's accomplish this by adding the following line of code:

//Enable the FreeDrag gesture.

TouchPanel.EnabledGestures = GestureType.FreeDrag;

Step 2 – Create an UpdatePlayer method to Handle Updates from User Input (Keyboard/GamePad)

We could now add the actual input code directly to Update() method, but we will encapsulate it into our own method called UpdatePlayer(), and do all our work there, then just call it from Update(). That will keep the Update() method from getting messy. Create a brand new method inside Game1.cs, directly below the Update() method, called UpdatePlayer() by adding the following code:

private void UpdatePlayer(GameTime gameTime)

{

}

Now inside the method, add controls for processing inputs for moving up, down, left, and right by add the following lines inside the UpdatePlayer() method:

// Get Thumbstick Controls

player.Position.X += currentGamePadState.ThumbSticks.Left.X * playerMoveSpeed;

player.Position.Y -= currentGamePadState.ThumbSticks.Left.Y * playerMoveSpeed;

 // Use the Keyboard / Dpad

if (currentKeyboardState.IsKeyDown(Keys.Left) || currentGamePadState.DPad.Left == ButtonState.Pressed)

{

player.Position.X -= playerMoveSpeed;

}

if (currentKeyboardState.IsKeyDown(Keys.Right) || currentGamePadState.DPad.Right == ButtonState.Pressed)

{

player.Position.X += playerMoveSpeed;

}

if (currentKeyboardState.IsKeyDown(Keys.Up) || currentGamePadState.DPad.Up == ButtonState.Pressed)

{

player.Position.Y -= playerMoveSpeed;

}

if (currentKeyboardState.IsKeyDown(Keys.Down) || currentGamePadState.DPad.Down == ButtonState.Pressed)

{

player.Position.Y += playerMoveSpeed;

}

// Make sure that the player does not go out of bounds

player.Position.X = MathHelper.Clamp(player.Position.X, 0, GraphicsDevice.Viewport.Width - player.Width);

player.Position.Y = MathHelper.Clamp(player.Position.Y, 0, GraphicsDevice.Viewport.Height - player.Height);

Now that we have our UpdatePlayer() method, we will call the method we wrote from the Game's Update() method so that every time Update() is called by the game loop, it will call our UpdatePlayer() method. Anything we want to update every frame should be done the same way.

Look for the Update() method inside the Game1 class, and replace the line marked "// TODO: Add your update logic here" with the following code:

// Save the previous state of the keyboard and game pad so we can determine single key/button presses

previousGamePadState = currentGamePadState;

previousKeyboardState = currentKeyboardState;

// Read the current state of the keyboard and gamepad and store it

currentKeyboardState = Keyboard.GetState();

currentGamePadState = GamePad.GetState(PlayerIndex.One);

//Update the player

UpdatePlayer(gameTime);

You have written all the input code you will need to get your ship moving using the Keyboard and GamePad. Let's test the effort by running the game either on the Local Device or in the Windows Simulator. Again if you are successful, you'll see the game pop up on your chosen platform. Now move the ship (player) around the screen by pressing the arrow keys on your keyboard.

Figure 2 Ship/Player Moved on Screen via User Input (Keyboard)

Step 3 – Create an UpdatePlayer method to Handle User Input from Mouse and Touch

Now that we've set up our game to accept user input to move the player from the keyboard and/or gamepad, now let add the code to enable use of the Mouse and/or Touch to control our ship aka player. Now our task is to start enabling the mouse and touchscreen for our game, and well that's when it gets very interesting. If you read any documentation about Windows 8, you will find that Windows 8 WinRT APIs supports user input across input modes and devices (touch, mouse, pen) through three types of interaction events: pointer, gesture, and manipulation. Pointer events provide a unified to access mouse, touch, and pen data. Gestures can be anything from simple interactions like tapping to more complicated manipulations like zooming, panning, and rotating. Touch, mouse, and pen/stylus interactions are received, processed, and managed as Pointer object input in Windows Store apps. In addition to the aforementioned objects and associated event structure, WinRT exposes a GestureRecognizer object for more control over specific gestures, such as Pinch, Slide, etc.

So with this information in hand, I implemented the Pointer event handlers against the XAML GamePage hosting the XNA Game. Unfortunately, the pointer event was not being raised when I clicked the screen. So I set about debugging the pointer events with the XAML GamePage and the XAML MetroGamePlatform, as well as, debugging through all the initialization events and the studying order in which each was called. Despite all of the effort, there was no way that I could get any of the Pointer or the Gesture events to successfully fire upon Mouse press. Luckily in researching the Touch objects on the MonoGame documentation hosted on http://monogame.codeplex.com , I stumbled upon a thread about the implementation of the MonoGame touch and gesture events. In order to provide a consistent experience with XNA and behavior similar to the XNA implementation on Windows Phone 7, the TouchPanel and MouseState objects should be used. Therefore, instead of leveraging the Pointer and Gesture events, we will enable mouse and touch with the aforementioned objects.

So let's add the code for accepting user input for Touch. We have already added the type of Gesture that will be supported by this code when we added the Gesture Type: FreeDrag. Therefore, let's go back to the UpdatePlayer() method and before the GamePad/Thumbstick controls code and its related comment and on a line right above; Add the following code:

// Windows 8 Touch Gestures for MonoGame

while (TouchPanel.IsGestureAvailable)

{

GestureSample gesture = TouchPanel.ReadGesture();

if (gesture.GestureType == GestureType.FreeDrag)

{

player.Position += gesture.Delta;

    }

}

Now let's add the code for responding user input for Mouse. Unlike using the TouchPanel, with a GestureSample object which calculates the delta of the touch/pointer position and the player (ship) position, we will have to manually calculate delta. To accurately calculate the mouse position, we create a Vector2 with the X and Y coordinates of the current MouseState by using the currentMouseState variable as noted below:

//Get Mouse State then Capture the Button type and Respond Button Press

Vector2 mousePosition = new Vector2(currentMouseState.X, currentMouseState.Y);

Now let's check if the Button pressed on the Mouse is the Left button. If it is indeed the Left Button that has been pressed, our next step will be to calculate the delta my subtracting the Mouse position from the player object current position. Once have the delta, we then will call the Normalize method on this. I found the use of this method beneficial as it creates a unit vector with one unit in length pointing in the same direction as the original vector. Finally, we would need to multiply the delta by the player speed and add that to the player current position. The result is the player (ship) moving where the mouse is clicked or the player following the direction of mouse movement when holding down the left button and moving around the screen which is similar to touching and dragging your finger around the screen. So in order to complete the tasks mentioned above, add the following code below the creation of the mousePosition vector.

if (currentMouseState.LeftButton == ButtonState.Pressed)

{

    Vector2 posDelta = mousePosition - player.Position;

posDelta.Normalize();

posDelta = posDelta * playerMoveSpeed;

player.Position = player.Position + posDelta;

}

You're all done and now have written all the input code you will need to get your ship moving using the mouse, as well as, using gestures and touch. Let's test the effort my running the game either on the Local Device or in the Windows Simulator. Again if you are successful, you'll see the game pop up on your chosen platform. Now move the ship (player) around the screen by clicking and holding your mouse and/or via touch if you have access to a touchscreen.

Figure 3 Ship/Player Moved on Screen via User Input (Mouse/Touch)

In conclusion, this walkthrough demonstrated how to respond to user input from the keyboard, gamepad, mouse and touch by adding the appropriate input logic. We went through the step to create and leverage the keyboard and gamepad state, and update the position of the player in response to keyboard/gamepad input. We learned about the handling of of the gesture and mouse screen in MonoGame is different than the typical Windows RT unified and streamlined way to get mouse, touch, and pen data with gesture and pointer events. We now have a ship that we can move around the screen, but without any animation, our game does not have an engaging experience. In Part 5 of this series, we will add logic to animate the ship by building a simple animation system within the game.

Overview

MonoGame currently does not have a Content Pipeline as a part of the framework therefore we will need another way to create the XNB files from our graphic and sounds assets. That is where the Windows Phone SDK comes in with Visual Studio 2012 (WP 8.0 SDK) and/or Visual Studio 2010 (WP 7.1 SDK) comes in. You can use the XNA Windows Phone Game project under Visual Studio 2012 or Visual Studio 2010 to compile your graphics assets and then add them to your Visual Studio 2012 MonoGame project. Please note: The graphics shown in this blog post may either depict usage of VS 2012 OR VS 2010 for the Content Pipeline but the steps for completion are the same no matter which product (VS 2012 or VS 2010) is used.

Creating a Content Pipeline for MonoGame

To create a Content Pipeline for MonoGame we must leverage the XNA Game Studio inside of Visual Studio 2012 or Visual Studio 2010 which is installed with Windows Phone 8 SDK (VS 2012) or Windows Phone 7.1 (VS 2010). So the first step in creating a Content Pipeline for your game is to start Visual Studio (2010/2012), and select XNA Game Studio from the Templates.

Step 1 – Opening and Registering Visual Studio 2012/2010 Express (First Time Users)

However, if this is your first time using Visual Studio 2012 or 2010 Express for Windows Phone, you will get a dialog box prompting for you to get a Registration Key. Click the Obtain a registration key online button.

Figure 1 Visual Studio 2010 Express registration

This will open up a Sign in screen, Log in with your email address and password associated with your Windows Live ID (Microsoft Account) or associate your email address with Window Live by registering your email address as a Windows Live ID and login. Fill out information require (if any) and then click the Submit button. If you are successful, a Thank You for registering message should come up displaying your registration key. See Fig. 2 below.

Figure 2 Visual Studio Registration Confirmation Dialog Box

Copy the registration key displayed, and paste it into the registration dialog shown previously in Figure 1. The Register Now button should now become available, therefore, Click the Register Now button.

Step 2 – Creating the XNA Game Project

Once Visual Studio starts, select New Project. Select Windows Phone Game, Windows Game or XBOX Game as appropriate to the version of Visual Studio you are using. Name the project ShooterContent and click OK. See Fig 1a and Fig 1b.

Figure 1a Visual Studio 2012 XNA Game 4.0 Project

Figure 1b Visual Studio 2010 XNA Game 4.0 Project

Now obtain the graphics for the Shooter game. I have provided these graphics for you. Click on the link: http://sdrv.ms/RBzIAh and Click on the Shooter Graphics and Sound files folder. Download all of the files contained within that folder and subfolders to an accessible location on your computer.

Step 3 – Creating a Content Manager for the Graphic, Font, and Sound Files using XNA Content Pipeline

Now that your XNA Windows Game project (ShooterContent) has been created, we can create a content manager. In the Solution Explorer, right click on the ShooterContentContent (Content) project and add two (2) new folders. Name the folders Graphics and Sound respectively. Add all the graphic files (.png files) and font files (.spritefont) from the location in which you downloaded the files provided above into the Graphics folder. Add the sound files (.wav) from the location in which you downloaded the files provided above the Sound folder. See Figure 1 below.

Figure 1 Visual Studio 2010 Express - Adding Content files to the Content Pipeline

Once all the files are added into your XNA Game solution and your XNA Game Studio project Solution Explorer resembles the graphic shown in Figure 1 above. Compile/Build the Entire ShooterContent Solution. Once you have successfully compiled without error, you can close the ShooterContent XNA Game Studio project.

Step 4 – Creating a Content Manager for the Graphic, Font, and Sound Files using XNA Content Pipeline

Now Reopen your MonoGame Project . If you have followed along with Part 1 and Part 2 of this MonoGame blog series, in the Solution Explorer you will see a Graphics folder with an .xnb file once the project has opened. For clarity and to ensure there no conflicts with our next steps. Delete the Graphics folder and all its contents from your project. Clean and rebuild the solution.

Inside the Solution Explorer, go to Win8ShooterGame project root and add a folder named Content by right-clicking and choosing Add, New Folder. Underneath this new folder, add two new folders named Graphics and Sound by right-click on Content Folder and choosing Add, New Folder. See graphic in Figure 1 shown below.

Figure 1 Adding Content Folders to the Project

Now Right click on Graphics Folder and select Add, Existing Item. Navigate to C:\Users\[you]\Documents\Visual Studio 2012\Projects\ShooterContent\ShooterContent\ShooterContent\bin\x86\Debug\Content\Graphics or C:\Users\\Documents\Visual Studio 2010\Projects\[you]\ShooterContent\ShooterContent\ShooterContent\bin\x86\Debug\Content\Graphics

Select all the files located in this folder and Click Add.

Select the Sound Folder and select Add, Existing Item. Navigate to C:\Users\[you]\Documents\Visual Studio 2012\Projects\ShooterContent\ShooterContent\ShooterContent\bin\x86\Debug\Content\Sound or C:\Users\\Documents\Visual Studio 2010\Projects\[you]\ShooterContent\ShooterContent\ShooterContent\bin\x86\Debug\Content\Sound

Select all the files located in this folder and Click Add.

Figure 2 Adding Graphics files to MonoGame project folders

Once files have been added within your MonoGame project, select add the files in the Graphics folder. With the files selected, right-click and select Properties.

 Figure 3 Select the Properties option for files

Under properties, set Build Action to property to Content and Copy to Output Directory property to Copy Always. Repeat these same steps with the files in the Sound folder.

Figure 4 Change Properties options of the files 

You've written enough code for now - let's see it in action! Build and run your game by either via Local Device or and the Windows Simulator. If successful, you will see the Cornflower Blue background with the Ship (player) shown on the screen.

Figure 5 Ship/Player Drawn on the Screen

In this walkthrough, we went through the step to create and leverage the Content Pipeline for graphics and sound. Now have created your Content pipeline and added the needed graphic and sound files, these files can be leveraged for the Shooter game. The Shooter player graphic is loaded and displayed on the screen from the Content Pipeline generated graphic files. In Part 4 of this series, we will add input logic and code to respond to various types of user input and control the player (ship) within the game. The input logic should respond to the user input in using mouse, keyboard and gestures.

Want to Have a Very Appy (yes Appy) Holiday? Looking for a way to make some Extra Money ($$) over the holidays? You happen to be a student?

Well do I have a Holiday Deal for you…Take the Windows 8 Student Holiday App Challenge and win $100 for each published Windows 8 app!

What is the Windows 8 Student Holiday App Challenge?

A challenge for students to create and publish Windows 8 apps by Jan. 20th and win a $100 gift card for EACH published app up to 5 applications.

Ready to get Started, Sure You Are!

Get Started by going to https://aka.ms/w8holidaychallenge to Download all the software and get the Support you Need and get more information about the contest.

Need Assistance getting started in building your app; Check out some Hands-On Labs, Sample Code, and Interactive Videos on

Generation App: http://bit.ly/RhnDfx or the Microsoft Student Windows 8 page: http://bit.ly/RIro4E

Got Technical Questions? Get your technical questions answered and talk to other student developer by going https://aka.ms/w8holidaychallenge

Happy Holidays and Happy Coding!

The Shooter game from the XNA Game tutorial is a particular type of game with a set of well-defined limits around user interaction. Given these well-defined parameters we can leverage touch aspects of Windows 8 as well as other forms of user interaction for the user in playing the Shooter Game. In leveraging the XNA Framework, we find that the framework Game class implements a basic design using the game loop concept. With this concept, XNA provides not only a base window to display the game, but also provides overloadable methods that a game implements to facilitate communication between your game and the operating system. We will discuss more details around XNA game development and resources throughout this walkthrough. In Part 2 of this series, we will build the code and class to Draw a player character i.e. Shooter on the screen and add the code needed to receive input and move the player around. For an overview of MonoGame and installation information, please see Part 1 of this Blog Series Part 1: Overview, Installation, MonoGame 3.0 Project Creation.

Creating the Shooter

Step 1 – Create the Player Class

Start Visual Studio 2012, and open the Win8ShooterGame solution that was created in Part 1 of this series. Currently this solution contains a blank MonoGame/XNA project that when run displays the default XNA Cornflower blue screen, as shown below.

Select the Win8ShooterGame project. Add a new class to your project by pressing SHIFT + ALT + C or right click on the Win8ShooterGame project and click Add New Item and selecting a Class. Name the class by typing in Player.cs. Press ENTER. A brand new code file will be created and a code window will open up. This file will contain all the code we'll write to define the player class. This includes all the data and functions that describe what the shooter/player will do within the constructs of the Shooter game. We'll start with basic values such as position, and add a few functions we can call continuously to draw the player on the screen. Additionally, later in this walkthrough we will add functions later move the player around later.

Once the Player.cs file is created, the default class created will show the following code:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Win8ShooterGame

{

   class Player

   {

   }

}

Since we need access to the XNA framework and associated functionality, we need to add the using statements to the class for the XNA framework. Therefore all the following code shown below to the end of the list of using statements in the Player class file. You have the option to remove all of the using statements placed in the class object by default Except the using System, as we will not being using any of those class objects for the Player class. Also let's change the namespace to better represent the player class object by changing the namespace from Win8ShooterGame to Shooter.

using System;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

namespace Shooter

{

   class Player

   {

   }

}

Now within the class Player definition, let's add the stub for the methods that will be used by the game to setup, update, and draw the Shooter player within the game. Add the following code shown below to your Player class.

using System;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

namespace Shooter

{

    class Player

    {

       public void Initialize()

       {

       }

       public void Update()

       {

       }

       public void Draw()

       {

       }

    }

}

Now let's add some variables to can store player data and information needed to ensure we can create and update the Shooter player accurately. Look for the first { mark under class Player, and enter the following lines:

// Animation representing the player

public Texture2D PlayerTexture;

// Position of the Player relative to the upper left side of the screen

public Vector2 Position;

// State of the player

public bool Active;

// Amount of hit points that player has

public int Health;

// Get the width of the player ship

public int Width

{

     get { return PlayerTexture.Width; }

}

// Get the height of the player ship

public int Height

{

     get { return PlayerTexture.Height; }

}

Now let's write the code to setup the Shooter player's starting position, set the graphic (texture), set the player status, and finally set the Health of the player. To do this, we add code to the Initialize method we created in the Player class object. Change code of the Initialize method to add the code showing below:

public void Initialize(Texture2D texture, Vector2 position)

{

    PlayerTexture = texture;

    // Set the starting position of the player around the middle of the screen and to the back

    Position = position;

    // Set the player to be active

    Active = true;

   // Set the player health

   Health = 100;

}

Now that we have initialized the player by setting base values associated with the player object, we can now use these to Draw the player on the screen using the position and the graphic (Texture2D). To draw the graphic we must draw the sprite (asset) by queuing Texture for rendering. We'll do this by passing our graphic (texture) to SpriteBatch object within the Draw method. Change the Draw() method inside the Player class by adding the code below and changing the method by adding the parameter of a SpriteBatch. Please see the following code:

public void Draw(SpriteBatch spriteBatch)

{

    spriteBatch.Draw(PlayerTexture, Position, null, Color.White, 0f, Vector2.Zero, 1f,

       SpriteEffects.None, 0f);

}

We have now defined what a "Player" at a very basic level by creating a class that has all the data and methods needed to create a Shooter player. The next step will be to create a Player object in the context of the Game loop in order to utilize the player object as a Shooter in the game.

Step 2 – Instantiate the Player object in Main Game class

Switch over to Game1.cs by double-clicking "Game1.cs" in the Solution Explorer. Game1.cs is a very important code file - it is already partially filled out, as you will see. This code is our game loop. We're going to be making some additions to this file to make the Player class we've created part of the game loop. When we do this, it will then start to draw on the screen, every frame. Start at the top of the code, and underneath the using Microsoft.Xna.Framework.Graphics, add the following namespace:

using Shooter;

Continue down and find the string marked public class Game1 : Game. A few lines down, below SpriteBatch _spriteBatch, add these lines: 

// Represents the player

Player player;

Look down the code, find the method called protected override void Initialize(). Inside that method, underneath the TODO comment, add these lines: 

// Initialize the player class

player = new Player();

Next, we have to load the player graphic and set the player's initial position before we can draw them on the screen. This is where we'll call the Initialize method of our Player class. Since this involves loading a graphic from disk, we will do this inside the game loop's LoadContent() method. Look down the code, find the method called protected override void LoadContent(). Inside that method, below the SpriteBatch assignment operator and the TODO comment, add these lines: 

// Load the player resources

Vector2 playerPosition = new Vector2(GraphicsDevice.Viewport.TitleSafeArea.X, GraphicsDevice.Viewport.TitleSafeArea.Y + GraphicsDevice.Viewport.TitleSafeArea.Height / 2);

player.Initialize(Content.Load<Texture2D>("Graphics\\player"), playerPosition);

We are ready to draw our player. Any time you draw something, you'll draw it via the game loop's Draw() method. Look down the code, find the method called protected override void Draw(GameTime gameTime). Inside that method, below GraphicsDevice.Clear(Color.CornflowerBlue) and the TODO comment; add these lines: 

// Start drawing

_spriteBatch.Begin();

// Draw the Player

player.Draw(_spriteBatch);

// Stop drawing

_spriteBatch.End();

We have now completed the code to draw/render the player object. Please review the Begin() and End() function calls, and note that any additional drawing and/or rending of objects will be added and completed between the Begin() and End() functions.

Let's draw the player on the screen. Add a folder to the Win8ShooterGame project called Content, then add a folder underneath the Content folder called Graphics. Download the precompiled shooter graphic, player.xnb, from the following link: http://sdrv.ms/Rmc11V to your computer. Right click the Graphics folder within the project and select the menu option to Add an Existing item. Add the player.xnb file from the location you saved the file on your computer.  Now we need to set the properties for this graphic.  Right click the newly added file, player.xnb.  Under the Properties option, set Build Action to property to Content and Copy to Output Directory property to Copy Always.

Now build and run your game by either via selecting Local Device or and the Windows Simulator via Build option. If successful, you will see the Cornflower Blue background with the Ship (player) shown on the screen.

Figure 1 Ship/Player Drawn on the Screen

You now have created your Shooter player and displayed it on the screen. In this walkthrough, I provided a compiled player.xnb graphic in order to display the player on the screen. In Part 3 of this series, we remove the precompiled player graphic and walkthrough how add graphics and sound for the Shooter game by building a Content Pipeline using Visual Studio 2012 / Visual Studio 2010 using the XNA SDK for XBOX or Windows Phone. We then will compile the Content Pipeline and show how to add the graphics resources created from the XNA Content Pipeline to the MonoGame Shooter project.

Casual game developers have been using XNA since 2004 for ease of create games for Windows, XBOX and most recently Windows Phone. XNA is a .NET framework for game development providing a content pipeline and load functionality for game asset, animation, math, sound and user input tracking via gamepad, mouse, keyboard and touch with game logic organized in a straightforward game loop architecture.

Game development is not trivial undertaking and XNA was a great framework to start down the path for a great number of novice game developers and/or students and developers who wanted to learn how to create quality game applications. XNA along with Visual Studio made it as easy as File –> New –> XNA Game Studio Project and you were off and running.

MonoGame is an open source cross platform implementation of the XNA namespace and class model. The goal of MonoGame is to provide XNA developers with a framework to build applications that will run on Xbox 360, Windows, Windows 8, and Windows Phone while providing the ability to port the game using the same C #codebase to run natively on the iOS, Android, Mac OS X, and Linux platform with minimal effort. With these goals in mind, the MonoGame motto therefore is to "Write Once, Play Everywhere". The technologies that make the MonoGame API cross-platform power possible are:

• OpenTK - a low-level C# library that wraps OpenGL, OpenCL and OpenAL for 3D graphics.
• SharpDX - an open-source implementation of the full DirectX API for .NET which allows for development of high performance games, 2D and 3D graphics rendering, and real-time sound
• Lidgren.Network - a networking library for .NET framework which uses an UDP socket to provide an API for connecting a client to a server, as well as, reading and sending messages

   

The game you will be making in this walkthrough is using the MSDN Shooter tutorial. Shooter is a particular type of game with a set of well-defined limits around what it does when the user interacts with it. This tutorial is a good starting point for learning game development with XNA and publishing a game running on Windows 8 platform using XNA leveraging MonoGame. In addition to leveraging this technology for Windows 8, you can use the MonoGame technology for native cross-platform development with other mobile platforms.

Setting Up Your Development Environment

Before you can write games for Windows 8 using MonoGame, you mush setup your enviroment and your IDE to do so. I have outlined the steps below for getting your environment created. Please follow and perform the following steps in the order stated to successfully prepare your computer for XNA Development with MonoGame:

1. Install Microsoft Windows 8.
2. Install Games for Windows
   1. http://www.xbox.com/en-US/LIVE/PC/DownloadClient
3. Install Windows Phone 8 SDK or Visual Studio 2010 Express for Windows Phone

   Why do I need Visual Studio 2010? There is a feature of XNA called the Content Pipeline, a pre-compiler step in the preparation of graphic and audio assets for use at runtime in XNA. This feature is not implemented in MonoGame. You can leverage VS 2010 or VS 2012 with the Windows Phone SDK installed to leverege the XNA Framework template to compile the graphics into the .xnb files to include in your Windows 8 project.

   1. Windows Phone 8 SDK: http://go.microsoft.com/fwlink/?LinkId=265772
   2. Visual Studio 2010 Express for Windows Phone: http://go.microsoft.com/fwlink/?LinkId=258412
4. Install Visual Studio 2012 for Windows 8
   1. Visual Studio 2012 Express: http://bit.ly/QvLWLX

      OR

   2. Visual Studio 2012 Pro/Premium/Ultimate: Use DreamSpark, MSDN or your licensed copy
5. Install MonoGame 3.0 binaries, templates, and dependencies with Windows Installer:

   Leverage the new MonoGame 3.0 Windows Installer to install the MonoGame and SharpDX libraries needed to create an XNA 4.0 project for Windows 8. This will also install two MonoGame templates for use within Visual Studio to start an XNA/MonoGame project.

   1. http://monogame.codeplex.com/downloads/get/511666
6. Optional: Install GitHub

   If you want to review the MonoGame Source Code or contribute code to the MonoGame project.

   1. Create a Git Account: https://github.com/
   2. Install the GitHub Windows Client: http://windows.github.com/

Create a MonoGame project

Windows 8 is designed to run on a variety of devices, including tablets and other devices that, through the aid of on-board sensors, know whether they are in landscape mode or portrait mode. XNA Game Studio 4.0 Refresh is a programming environment that allows you to use Visual Studio to create games for Windows Phone, Xbox 360, and Windows. XNA Game Studio includes the XNA Framework, a set of managed libraries designed for game development based on the Microsoft .NET Framework. In order to leverage the power of XNA for Windows 8 since it is not supported natively, we will leverage the MonoGame framework.

Step 1 - Create a MonoGame project and set references

Open Visual Studio 2012 and select New Project. Under Templates, select Visual C#, you should see the MonoGame project templates listed. Select the MonoGame Game (XAML). Name the project Win8ShooterGame and ensure that the option to Create directory for solution is checked/selected.

Figure 1 - Visual Studio with MonoGame Templates

Step 2 - Set a MonoGame references (Optional)

**Follow these Steps ONLY if you Installed MonoGame Directly from GitHub or have problems with Template pointing to correct MonoGame references. If you installed via the MonoGame Installer, please skip to Step 3. **

• Now we need to ensure that the Solution has the correct references to the MonoGame Framework and its dependencies. Right click on your solution in the Visual Studio Solution Explorer and select Add, Existing Project.

  Figure 2 - Add Existing project to Solution

   

  Browse to in Explorer to C:\Users\[you]\Documents\GitHub\MonoGame. Select the folder named MonoGame.Framework. In this folder, you will find the MonoGame Windows 8 CSPROJ project file in this directory: C:\Users\[you]\Documents\GitHub\MonoGame\MonoGame.Framework\MonoGame.Framework.Windows8.csproj. Select this project and click Open.

Figure 3 Add MonoGame Framework for Windows 8 project to Solution

Once the project has been added to the Visual Studio solution, right click on the MonoGame.Framework.Windows8 project, and select Clean. Then right click on the project again, and select Build. You may see a few warnings once you build the project, but that is okay.

Now select the Win8ShooterGame solution, select References, right click and select Add Reference. In the Reference Manager, we need to add the reference to the MonoGame.Framework into the Windows 8 project by selecting Solution and then Projects. Select the checkbox beside the MonoGame.Framework project. Click OK (Figure 4). Then again go back into Reference Manager and add the MonoGame Framework Dependencies by selecting Browse. Browse to location: C:\Users\[user]\Documents\GitHub\MonoGame\ThirdParty\Libs\SharpDX\Windows 8 Metro and select all of the .dll files within the folder.

 Figure 4 Add MonoGame Framework and SharpDX reference

Finally, select the Win8ShooterGame and right click. Select Project Dependencies and select the checkbox next to MonoGame.Framework.Windows8. Click Okay and Rebuild the Entire Solution. You may get warnings, but if you have followed the steps correctly, there should be no errors.

Figure 5 Add MonoGame Framework Project Dependency

 Step 3 - Test MonoGame Environment

Now, let's test to see if your MonoGame environment is set up correctly by running the application either via Local Device or and via the Windows Simulator. If your setup was successful, you will see the Cornflower Blue background commonly created by default with the XNA Framework projects.

 You are now ready to start building your Windows 8 game. In Part 2 of this series, we will add the first asset to be used in your Windows 8 Game, a player object. The player which will be represented as a spaceship will be the primary source of control for the first player shooter game. In Part 2, we will create and build a player class object to represent the actions and properties associated with the spaceship for the game.

Well here it is, the Windows Store is open for Developers and we’re all anxious to see all the cool apps you develop and place into the store!  What’s even more exciting is that all eligible MSDN subscribers receive a free, one-year Windows Store developer account as part of their MSDN benefits. (Eligible subscriptions include Visual Studio Professional, Test Professional, Premium, Ultimate, and BizSpark.) We have a program for students—DreamSpark—that similarly waives the subscription fee. And we have an offer for businesses in our BizSpark program, as well.

So by now, I know you’re excited and ready to get started…let me help you in the right direction.  Once you get the Windows 8 OS and the Visual Studio 2012 tools from MSDN and/or DreamSpark (*premium for OS), to get started and on your way to having an Windows 8 developed in 30 Days try Generation App:

YOUR IDEA.  YOUR APP. 30 DAYS.

Generation App can help you develop an app in 30 days.  Leverage the 30 to launch program, to spur your app development or as a precursor to the Microsoft Developer Camps and appLabs.  With technical and design support offered, it’s the best way to get on your way to completing your OWN app and getting it into the Windows Store. 

• Generation App -> 30 Days to a Windows 8 app: http://bit.ly/RhnDfx

• Generation App -> 30 Days to a Windows Phone app: http://bit.ly/OqhP6V

• Generation App -> Home Page: http://bit.ly/Rho21y

Happy Coding!