Channel 9 - Entries tagged with XNA Framework

From XNA game to Windows 8

Anthony de Bruyn — Mon, 17 Sep 2012 16:31:04 GMT

A walkthrough getting an XNA game to run on Windows 8 – no long theory but concrete examples. Get insights on:

How to implement the settings charm
How to implement the sharing charm
How to deal with file reading and writing, threads, and any other topics which vary between platforms
How to prepare art assets for Windows
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.

From retro game programming to modern day Windows Phone 7 development

John O'Donnell — Wed, 25 Jul 2012 22:33:52 GMT

There are literally only a small handful of people in the world who can create a game from scratch for the 6502 based Atari 7800 game platform. Robert Decrescenzo is one such person and has created quite a few games for the 7800 all hand coded in 6502 assembler and many of which would put commercial releases to shame that were released at the height of the 7800 consoles popularity. If your interested in learning more about these old consoles check out the forums at http://www.atariage.com

With these skills as a background and some C# coding as well robert has turned his hand to game development on the Windows Phone 7 platform using C# and XNA and delivered a fun game to our app store at - http://www.windowsphone.com/en-US/apps/a96a0815-e39c-46b1-acc1-f76d91ffb72b

As well as using his existing development expertise Robert also took advantage of our XNA training content to get up to speed - http://create.msdn.com/en-us/education/gamedevelopment

It is not often you meet anyone who has the skills and expertise to create and self publish a new game product in 6502 assembler for a game platform launched in 1984 and can then turn those skills over to a modern platform like Windows Phone 7

Thanks for watching!

John O'Donnell, Technical Evangelist
Microsoft Corporation
http://blogs.msdn.com/jodonnell
http://blogs.msdn.com/usisvde
http://www.twitter.com/jodonnel

ScriptTD: Tower Defense Made Easy

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

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

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

Extending the Code

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

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

Weapons
The GUI
The Game Screens (Menus)

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

Straight from the Labs

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

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

Getting Started

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

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

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

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

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

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

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

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

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

1, 2, 3, Fire!

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

public bool CanFire()
{
    return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

I’m Taking Damage!

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

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

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

Draw their Fire!

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

if (_target == null)
    return;

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

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

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

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

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

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

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

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

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

Weapons in the Armory

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

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

Add the following line anywhere inside that method:

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

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

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

From the root directory for the project, navigate to:

Coding4Fun.ScriptTD.Content\Data\Towers

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

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

Conclusion

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

About The Author

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

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

Bytes by MSDN: Andre Vrignaud and Rob Cameron discuss XNA & Mobile Development

Bytes by MSDN — Mon, 30 Aug 2010 13:48:00 GMT

Listen in as Rob Cameron chats with Andre Vrignaud, Senior Technical Evangelist at Microsoft, about the exciting announcements around the commonalities between XNA and mobile development.

Click here to download the Windows Phone 7 Toolkit

About Andre

Ozymandias is the Xbox Live gamertag of Andre Vrignaud, as well as his platform to speak to gamers and the game industry directly. Andre has worked at Microsoft since 2002, helping manage the overall gaming platform strategy for Xbox, Xbox Live, and Windows. Recently he's started thinking more about mobile gaming as well. This means his job is to look out ahead one to five years and try to project where Microsoft, our competition, and the game industry in general will be. He takes that thinking, the work many other folks do internally, and coalesces it into a roadmap that he takes out to Microsoft game developers and publishers. Of equal importance, he also helps take feedback Microsoft hears from those partners and makes sure the right teams internally have it so they can react appropriately.

Andre has been working in the game industry for over 20 years. He started out as a tester (back in the days when you could start as a tester) at Strategic Simulations, Inc. (SSI), where he worked on a variety of AD&D games as well as one of the first MMOs to ever be released – Dark Sun Online. After SSI he joined the Total Entertainment Network (TEN) where he helped build one of the first online gaming networks. In fact, TEN is one of the major reasons he joined Microsoft as Xbox Live is, in many ways, a modern version of what they tried to do with TEN (except that now we have a much larger audience, huge broadband penetration, and Daddy Warbucks backing us up.) TEN died a horrible start-up death due to being too early and eventually became Pogo (which was then was acquired by EA to be their casual games arm). After TEN he worked at Intel where he managed their PC games strategy, coincidentally was involved with some of the early Xbox/Intel negotiations, and finally had the opportunity to join the Xbox team back in 2002.

About Rob

Employed by Microsoft since 2001, Rob Cameron is an Industry Architect Evangelist with Microsoft Corporation based out of Atlanta, Georgia. As part of Microsoft's Communication Sector Developer & Platform Evangelism team, Rob focuses on development tools and technologies focused on mobile devices, gaming, and embedded devices for telecommunications, cable, and media & entertainment companies. Rob co-authored several titles including Building ASP.NET Server Controls, Pro ASP.NET 3.5 Server Controls and AJAX Components, Silverlight 2 Recipes, and most recently Silverlight 3 Recipes. He has a master's degree in information technology management and a bachelor's degree in computer science. Visit Rob's blog at http://blogs.msdn.com/RobCamer.

Stuff Andre and Rob recommend you check out

MSDN Radio: Game Building for Windows Phone 7 using XNA/Game Studio with Dan Waters

MSDN Online Media — Thu, 26 Aug 2010 22:21:00 GMT

Are you a game developer or want to be a game developer but don't know how to get started? You're in luck! If you're a Microsoft .NET developer interested in developing games for the Windows Phone 7 platform tune in to this show. Dan Waters, an Academic Evangelist from Microsoft joins us to talk about how to get started, what tools to install, how to deploy your first game, and how to sell your games in the market place.

MSDN Radio is a weekly Developer talk-show that helps answer your questions about the latest Microsoft solutions and technologies. We dive into the challenges of deciphering today’s technology stack. Visit www.MSDNRadio.com to register for upcoming shows or watch shows on-demand.

Hosts and Guest: Mike Benkovich, Senior Developer Evangelist; Mithun Dhar, Developer Evangelist; and Dan Walters, Academic Developer Evangelist, Microsoft Corporation

For over three years, Dan's job has been to ignite the passion and creativity in technical students by demonstrating all the great things technology careers have to offer. Dan started a web design company at 15 and spent his pre-Microsoft career as a software developer working in many industries including retail, healthcare, manufacturing and distribution.

In his spare time Dan really enjoys being a dad, twice now! He also loves to snowboard, write music, cook, and travel. Follow him on Twitter @danwaters

Windows Phone 7 Jump Start (Session 12 of 19): Working with Media

MSDN Online Media — Tue, 17 Aug 2010 22:20:00 GMT

This session covers using media in your Windows Phone 7 applications and games. Topics include media in XNA overview, displaying pictures, and playing music.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

For copies of the student files and links to demo code, you can go to the Windows Phone 7 Born To Learn Forum (http://borntolearn.mslearn.net/wp7/m/default.aspx).

Updated! Session 1: Introduction
Session 2: Building a Silverlight Application, Part 1
Session 3: Building a Silverlight Application, Part 2
Updated! Session 4: The Application Bar
Session 5: Building XNA Games for the Windows Phone 7 Platform, Part 1
Session 6: Building XNA Games for the Windows Phone 7 Platform, Part 2
Updated! Session 7: Isolation Storage
Updated! Session 8: The Application Lifecycle
Updated! Session 9: Launchers and Choosers
Updated! Session 10: Push Notifications
Session 11: Marketing your Windows Phone Applications
Session 12: Working with Media

New Sessions:
Session 13: Panorama and Pivots
Session 14: XNA Deep Dive, Part 1
Session 15: XNA Deep Dive, Part 2
Session 16: Location and Bing Maps
Session 17: Optimizing for Performance
Session 18: Designing Apps Using Expression Blend & Metro
Session 19: Ask the Experts podcast

Windows Phone 7 Jump Start (Session 11 of 19): Marketing Your Windows Phone Application

MSDN Online Media — Tue, 17 Aug 2010 22:20:00 GMT

This session targets developers interested in marketing their games and applications. Rob and Andy cover the Windows Phone 7 marketplace, registering as a developer, how you get paid for your applications, packaging your applications for the market and publishing them to the marketplace. They finish up with how to use the Windows Phone for development.

Updated! Windows Phone 7 Jump Start (Session 10 of 19): Push Notifications

MSDN Online Media — Tue, 17 Aug 2010 22:20:00 GMT

This session covers server-initiated communications, enabling background scenarios, preserving battery life and the user experience, as well as learning how to prevent polling for updates. Beginning with Start Tiles 101, you’ll work through types of notification, notification data flow, cloud service notifications, response messages and more.

Updated! Windows Phone 7 Jump Start (Session 9 of 19): Launchers and Choosers

MSDN Online Media — Tue, 17 Aug 2010 22:20:00 GMT

This session goes through the Windows Phone execution model in terms of Launchers and Choosers. Learn how to effectively managing tombstoning with Launchers and Choosers. We cover types of Launchers and Choosers as well as programming them.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Watch these entertaining sessions and complete the labs found on Channel 9 (http://channel9.msdn.com/learn/courses/WP7TrainingKit/) to gain development skills using both Microsoft XNA and Microsoft Silverlight.

For copies of the student files and links to demo code, you can go to the Windows Phone 7 Born To Learn Forum (http://borntolearn.mslearn.net/wp7/m/default.aspx).

Updated! Session 1: Introduction
Session 2: Building a Silverlight Application, Part 1
Session 3: Building a Silverlight Application, Part 2
Updated! Session 4: The Application Bar
Session 5: Building XNA Games for the Windows Phone 7 Platform, Part 1
Session 6: Building XNA Games for the Windows Phone 7 Platform, Part 2
Updated! Session 7: Isolation Storage
Updated! Session 8: The Application Lifecycle
Updated! Session 9: Launchers and Choosers
Updated! Session 10: Push Notifications
Session 11: Marketing your Windows Phone Applications
Session 12: Working with Media

New Sessions:
Session 13: Panorama and Pivots
Session 14: XNA Deep Dive, Part 1
Session 15: XNA Deep Dive, Part 2
Session 16: Location and Bing Maps
Session 17: Optimizing for Performance
Session 18: Designing Apps Using Expression Blend & Metro
Session 19: Ask the Experts podcast

Updated! Windows Phone 7 Jump Start (Session 8 of 19): The Application Lifecycle

MSDN Online Media — Tue, 17 Aug 2010 22:19:00 GMT

This important session covers what you as a developer need to include in your application development process in order to get your application through the marketplace certification process. It covers how applications work in the Windows Phone environment, the application lifecycle, lifecycle events and using Local Storage state object. The goal is to help developers ensure that users have a good experience with the application.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Updated! Windows Phone 7 Jump Start (Session 7 of 19): Isolated Storage

MSDN Online Media — Tue, 17 Aug 2010 22:19:00 GMT

This session covers how to get your phone application to persist data so that you can avoid inappropriate tombstoning. It covers topics such as loading and storing data, application settings and saving data in settings, serialization and threads all supported again with demos and scripts.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Windows Phone 7 Jump Start (Session 6 of 19): Building XNA Games for the Windows Phone 7 Platform, Part 2

MSDN Online Media — Tue, 17 Aug 2010 22:18:00 GMT

This session on building XNA for games covers managing voices and XNA sounds in Silverlight. Rob and Andy then move on to Touch Input in XNA by covering the topics of getting inputs, iterating through inputs, and creating flicks.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Windows Phone 7 Jump Start (Session 5 of 19): Building XNA Games for the Windows Phone 7 Platform, Part 1

MSDN Online Media — Tue, 17 Aug 2010 22:18:00 GMT

This session goes deeper into XNA game programming for the phone. Topics include display orientation, monitoring performance, using the Accelerometer, using touchscreen, advanced XNA sound playback, and controlling media playback with XNA.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Updated! Windows Phone 7 Jump Start (Session 4 of 19): The Application Bar

MSDN Online Media — Tue, 17 Aug 2010 22:18:00 GMT

This session covers how to instantiate the application bar, the Application Chrome, System Tray and the Application Bar in XAML. It concludes with a demo using Microsoft Expression Blend for enabling the application bar and including application icons and menu items.

Windows Phone 7 Jump Start (Session 3 of 19): Building a Silverlight Application, Part 2

MSDN Online Media — Tue, 17 Aug 2010 22:18:00 GMT

This video extends session two and begins with an introduction into Databinding with a dive into the Listbinding template. Rob and Andy follow by covering Page Navigation, handling the hardware Back key, and finally creating orientation-aware pages.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Watch these entertaining sessions and complete the labs found on Channel 9 (http://channel9.msdn.com/learn/courses/WP7TrainingKit/) to gain development skills using both Microsoft XNA and Microsoft Silverlight.

For copies of the student files and links to demo code, you can go to the Windows Phone 7 Born To Learn Forum (http://borntolearn.mslearn.net/wp7/m/default.aspx).

Direct link to the source code for this video can be found at : http://borntolearn.mslearn.net/wp7/m/classresources/56356.aspx

Updated! Session 1: Introduction
Session 2: Building a Silverlight Application, Part 1
Session 3: Building a Silverlight Application, Part 2
Updated! Session 4: The Application Bar
Session 5: Building XNA Games for the Windows Phone 7 Platform, Part 1
Session 6: Building XNA Games for the Windows Phone 7 Platform, Part 2
Updated! Session 7: Isolation Storage
Updated! Session 8: The Application Lifecycle
Updated! Session 9: Launchers and Choosers
Updated! Session 10: Push Notifications
Session 11: Marketing your Windows Phone Applications
Session 12: Working with Media

New Sessions:
Session 13: Panorama and Pivots
Session 14: XNA Deep Dive, Part 1
Session 15: XNA Deep Dive, Part 2
Session 16: Location and Bing Maps
Session 17: Optimizing for Performance
Session 18: Designing Apps Using Expression Blend & Metro
Session 19: Ask the Experts podcast

Windows Phone 7 Jump Start (Session 2 of 19): Building a Silverlight Application, Part 1

MSDN Online Media — Tue, 17 Aug 2010 22:17:00 GMT

This session is where the coding begins. Andy and Rob walk through building your first application with Microsoft Silverlight. It includes responding to event controls, Windows themes and styles, and customizing text input.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught my Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Watch these entertaining sessions and complete the labs found on Channel 9 (http://channel9.msdn.com/learn/courses/WP7TrainingKit/) to gain development skills using both Microsoft XNA and Microsoft Silverlight.

For copies of the student files and links to demo code, you can go to the Windows Phone 7 Born To Learn Forum (http://borntolearn.mslearn.net/wp7/m/default.aspx).

Updated! Session 1: Introduction
Session 2: Building a Silverlight Application, Part 1
Session 3: Building a Silverlight Application, Part 2
Updated! Session 4: The Application Bar
Session 5: Building XNA Games for the Windows Phone 7 Platform, Part 1
Session 6: Building XNA Games for the Windows Phone 7 Platform, Part 2
Updated! Session 7: Isolation Storage
Updated! Session 8: The Application Lifecycle
Updated! Session 9: Launchers and Choosers
Updated! Session 10: Push Notifications
Session 11: Marketing your Windows Phone Applications
Session 12: Working with Media

New Sessions:
Session 13: Panorama and Pivots
Session 14: XNA Deep Dive, Part 1
Session 15: XNA Deep Dive, Part 2
Session 16: Location and Bing Maps
Session 17: Optimizing for Performance
Session 18: Designing Apps Using Expression Blend & Metro
Session 19: Ask the Experts podcast

Updated! Windows Phone 7 Jump Start (Session 1 of 19): Introduction

MSDN Online Media — Tue, 17 Aug 2010 22:17:00 GMT

This introductory session covers the Windows Phone 7 Overview, the Developer and the Windows Phone 7 Marketplace, options, how to become a developer, setting up your system, and an intro to creating Windows Phone applications.

The Windows Phone 7 Jump Start video training is for all developers interested in developing applications or games for the new Windows Phone 7 Platform. The ~14 ½ hour course is based on the Microsoft Windows Phone 7 Developer Training Kit and taught by Microsoft MVP's and Microsoft Press Authors, Andy Wigley and Rob S. Miles. The Designing for Windows Phone 7 session is taught by Microsoft Design experts, Jon Harris and Bryan Agnetta. The training is wrapped up with an audio podcast with a panel of Microsoft experts answering the questions posed throughout the training.

Watch these entertaining sessions and complete the labs found on Channel 9 (http://channel9.msdn.com/learn/courses/WP7TrainingKit/) to gain development skills using both Microsoft XNA and Microsoft Silverlight.

For copies of the student files and links to demo code, you can go to the Windows Phone 7 Born To Learn Forum (http://borntolearn.mslearn.net/wp7/m/default.aspx).

Updated! Session 1: Introduction
Session 2: Building a Silverlight Application, Part 1
Session 3: Building a Silverlight Application, Part 2
Updated! Session 4: The Application Bar
Session 5: Building XNA Games for the Windows Phone 7 Platform, Part 1
Session 6: Building XNA Games for the Windows Phone 7 Platform, Part 2
Updated! Session 7: Isolation Storage
Updated! Session 8: The Application Lifecycle
Updated! Session 9: Launchers and Choosers
Updated! Session 10: Push Notifications
Session 11: Marketing your Windows Phone Applications
Session 12: Working with Media

New Sessions:
Session 13: Panorama and Pivots
Session 14: XNA Deep Dive, Part 1
Session 15: XNA Deep Dive, Part 2
Session 16: Location and Bing Maps
Session 17: Optimizing for Performance
Session 18: Designing Apps Using Expression Blend & Metro
Session 19: Ask the Experts podcast

MSDN Radio: XNA and Windows Phone 7 Series with Michael Klucher

MSDN Online Media — Tue, 20 Apr 2010 16:12:00 GMT

With the recent announcements about the developer environment for Windows Phone we have the opportunity to talk with the product team about how Microsoft XNA fits into the picture. Michael Klucher has been a champion of the XNA framework and how it can be used to build creative solutions.

MSDN Radio is a weekly Developer talk-show that helps answer your questions about the latest Microsoft news, solutions, and technologies. We dive into the challenges of deciphering today’s technology stack. To register for upcoming show go to www.MSDNRadio.com.

Host and Guest: Mike Benkovich, Senior Developer Evangelist, and Michael Klucher, Lead Program Manager, Microsoft Corporation

Mike Benkovich delivers technical presentations around the U.S. as a developer tools evangelist on the MSDN team at Microsoft. He has worked in a variety of professional roles, including architect, project manager, developer, and technical writer.

Michael Klucher works as a Lead Program Manager for the XNA Development Platform team. Working on XNA Game Studio since its initial inception, Michael has been involved with the design of many feature areas such as the XNA Framework Content Pipeline, XNA Game Studio Connect on the Xbox 360, and most recently the work to bring XNA Game Studio to the Zune platform.