Initial Thoughts on the MS/Unity Partnership

I posted the following in response to a post by Mary Jo Foley, but figured I’d also put it here (especially since I got “Your comment contains words or phrases associated with spam and will not appear on the site until it has been checked by a moderator.” (is XNA now spam?) when I submitted it and don’t know when it’ll appear):


"But when chided for not announcing details of plans for supporting indie gamers on Xbox One this week, Guggenheimer deflected that criticsm."

We’re not looking for details, just a concrete answer. The E3 presentations showed Sony giving a lot of love to indies, while MS gave virtually none. With MS abandoning XNA this was tough to swallow. Then yesterday there was –

A lot of us took this to mean that there would be some announcement that gave indies some love. When the @unity3d Twitter account tweeted "Anybody following #bldwin? Something interesting coming up soon.. #unity3d" a lot of thought there might finally be a resolution to the indie issue on Xbox. Unity3D is primarily an indie (both small and large) tool for game development. Imagine our surprise then when we see this (from here –

"Developers who build games published by Microsoft Studios now have access to Unity tools for Xbox 360 and Xbox One free of charge and can create interactive 3D and 2D experiences."

It’s not as if regular indies have a shot at getting Microsoft Studios to act as their publisher. But when we think we’ve been completely abandonded at the end of that page is:

"As we look ahead, we look forward to sharing more information on our plans to help empower everyone from the independent game developer looking to make publishing to the console easy to the app developer who wants to bring new experiences to the television."

The problem with this is that between the whole "no self-publishing on Xbox One" and the previous quote limiting the Unity tools to devs that have an association with Microsoft Studios, we’re still left wondering what MS is doing? Does "independent" mean "John Smith in his basement creating games in his free and is currently using XBLIG to publish on Xbox 360" or does it mean studios like Double Fine that can do a Kickstarter and raise millions of dollars on their name and background alone? If the former, why can MS just come out and say it and give us a break? I personally am fine with waiting if I know at the end I’ll be able to continue doing Xbox development without having to take a 2nd mortgage on my house to fund it. Just give us a concrete answer; don’t keep stringing us along.

The quick mention of a contest during the Keynote led some of us to believe that MS and Unity might be planning a new version of the DreamBuildPlay contest, just using Unity3D instead of XNA. That would have been awesome. Alas, it’s Windows and WP8, no Xbox –

I get the feeling MS is just flailing about, trying to do good, but only half-way succeeding. They had an awesome thing going with XBLIG. While there is a lot of junk that made it’s way on the service, there are also a lot of great games, some of which have generated huge amounts of money for both MS and the devs, letting some devs move into full-time game development for a living. This is probably the dream of a lot of indies and we were hoping MS would continue to give us a chance to realize that dream. Right now, though it’s like we’re dogs sitting under the table, hoping for some crumbs to drop and MS is teasing us by holding a big chunk of prime rib out and then yanking it back.

I’ve been supporting MS and helping the community ever since the XNA beta and would love to do so for years to come, but it’s hard to plan which way to go without definitive answers. That’s all we’re looking for.

Thoughts on indies

So the whole “Indies won’t be able to self-publish on the Xbox One” thing has gotten me thinking about exactly what is an indie. This has been done to death on tons of other sites by people much wiser in the game development industry than myself, but one more opinion isn’t going to hurt, is it? And I need to start posting more here anyway, so let’s give it a shot.

Let’s start with Wikipedia’s definition:

“…developers that are not owned by a publisher. Independent developers retain operational control over their companies, pipelines, and organizations and often may work with proprietary engines or other proprietary software. These teams may range in size from single individuals to major companies with hundreds of employees.

Independent developers may choose to work with one or more game publishers or to self-publish their titles.”

The only problem is have with this definition is the working with publishers part. Once a publisher is involved you normally have to give up control of the game in some way. The publisher may require you to make changes to the game that you don’t want to make and, since they’re the one with the money, you usually have to do what they say. That’s when you’re no longer an indie in my opinion. When someone else can tell you have to make your game, you’re not independent.


Indies and money

I’ve seen posts by people in forums, Twitter, etc. that if you’re trying to make  money as a game developer you’re not a true indie. This has to be the stupidest notion I’ve ever heard of. I guess this is the same kind of thinking about starving artists are the only real artists and every successful artist must be a sell-out. Any sane, rational, semi-intelligent person with the slightest bit of common sense knows this is nonsense. The two things are not mutually exclusive. The rise of many of the more successful game developers who are still doing their own thing and not relying on publishers proves that you can be indie and still make money.


Indies and platforms

So the other day news went around about how some < insert expletive here > loser took it upon himself to make a PC version of Ska Studio’s game The Dishwasher: Vampire Smile simply because no PC version existed. He claimed it wasn’t piracy, but a “restoration of justice”. Given the quality of his written word in quotes I’ve seen, the guy either is not an English-as-a-first-language person is not all there mentally. Maybe it’s a bit of both.

In any case, this brings up the craziness surrounding those devs that are targeting platforms other than PC. A lot of small studios are cranking out mobile games because it’s cheap and easy. Making money from mobile is still a tricky business though because of the glut of games on various mobile platforms. PC game dev is still relatively simple is you’re making low-end, simple games because the majority of game PCs can handle them so you’re not limiting your target audience. I’ve not seen people question the indie-ness of devs targeting these platforms or even other less-popular ones such as the Ouya (I still think of the Kool-Aid Man when I hear this “Oh, yeah!” Smile. In the case of Ska Studios, they recently announced that they would, in fact, be porting D:VS to PC. All of the sudden, the cries of the un-washed masses were resounding with “You’re just doing it for the money!” and other insanity. What’s wrong with people?!? Why did it become about money in this case? Was it because people assumed that Ska was afraid of losing money from people who downloaded the illegal port rather than their port? Was it because Ska was targeting more than one platform with their games? Was it because a lot of people on the internet are insane? (I’m voting that one)


The future of indies

Despite all the craziness around the PS4 and X1 reveals regarding indies being able to target them, I think indies are going to be the go-to point for the unique, original games as publishers get even more leery about backing new IP. I was happy to see that there would be at least one new IP on the X1 and hope other studios are able to bring something to the console other than < IP > < some number greater than 1 >. If MS does the smart thing and brings out a new version of XNA Game Studio (read: something that doesn’t require C++) and allows indies to get games onto it, and continues the Dream-Build-Play contest to bring those talented indies into the limelight, I think it’ll be a great time to be an indie. I’m still hoping to join the ranks of James Silva, James Petruzzi, and other great indie game devs named James. Smile

Xbox One, XNA, the Future of Indie Game Development, and Bad “Journalism”

So Microsoft’s new console, ridiculously name the Xbox One, was unveiled last week to a less than overwhelmed audience. While there was plenty of applause during portions of the reveal, the aftermath of the presentation left the majority of gamer community like this:

The reveal seemed to be about several things:

  • the Xbox One is your one stop entertainment device
  • it’ll play sports games, racing games, and the next Call of Duty
  • it’s all about the cloud
  • Kinect is your friend (or it better become your friend since it’s always going to be there even if you don’t want it around)

The first bullet point seemed to be a huge turnoff to almost everyone, despite the fact that it’s something you can completely ignore if you don’t care about it. It was almost another facepalm moment reading and listening to everyone putting so much emphasis on a feature that they’ll probably never use. I might be able to understand if it were something that would be an impediment to using the console, but that doesn’t seem to be the case.

Having a Kinect bundled with every console was also mostly met with negativity. Partly I think this is because it’s going to increase the cost of the console and partly the fact that it was stated that it always has to be one (mainly to allow you to just say “Xbox on” to start the console it appears). I understand Microsoft trying to make the device more attractive to both gamers and developers, but with the recent backlash about Kinect snooping on people and gather all kinds of data that has the possibility of being obtained by other people (why this is a big deal I’ve yet to figure out since the data it gathers doesn’t appear to be of the kind that could be used against a person or be embarrassing, unless you’re the type of person to be doing stuff in front of it that you wouldn’t do in public) I think MS is making a mistake here. The crop of Kinect-enabled games this generation was mostly ignored. The only one I really got into more than a little bit was UFC Trainer and that lasted maybe two months.

Of these, only the 2nd bullet point would be something gamers care about and the two genres are not among the biggest and it seems CoD is not the big draw it used to be. In addition, the fact that it’s not backward compatible was a huge turnoff to many. Why this is the case, I’m not sure. I’d be willing to bet the majority of gamers won’t be playing Xbox 360 games for very long after they get the new console.

Additional confusion came about after a couple of statements were made that weren’t completely clear – the XBLA and XBLIG channels would be going away; all games would be lumped together (hopefully with better discoverability tools!) and indies would not be able to self-publish on the new console. This led many to believe that it’s not going to be possible for indies to get their games on the console at all, since there’s about .000000001% possibility for the average indie developer to get a publisher interested enough in their game to pick it up and publish it.

Granted, this seems to have been cleared up a bit since Don Matrick was quoted on Kotaku and other sites saying

“We’re going to have an independent creator program. We’re going to sponsor it. We’re going to give people tools. That is something we think—I think—is important. That’s how I started in the industry. There’s no way we’re going to build a box that doesn’t support that.”

Of course, many people are now saying that the left hand of Microsoft doesn’t know what the right is doing and that people within the company are contradicting themselves. Some days you just can’t win I guess.

It appears that indies are going to be ok on the Xbox One (I’m going to start shortening it to X1 I think since I think those who are using the derogatory "Xbone” are showing themselves as haters or jumping on the anti-MS bandwagon. To those people, this.) Still, I’m not committing myself to the X1 until after E3 and Build. I really hope MS does the smart thing and brings back XNA Game Studio in some form. XBLIG has made them a good bit of money and brought indie game development to the level where people can make a decent living off of it.

World Screen Screenshot

Well, it’s getting there:


New Dungeon Editor Screenshot

Some progress:

  • Added 2nd layer for regular and secret doors
  • Triggers (X in screenshot) and traps (square in screenshot) now rendering
  • Load and save working, using sharpSerializer since normalize XmlSerializer doesn’t like arrays, among other things.



Dungeon Editor, 1st Iteration

Behold my awesome graphical skills! :) It’s got a long way to go, but it’ll do for now:



Thoughts on Stat Types and Skills

So I’m thinking of going with just a few types of stats for the dungeon crawler I’m prototyping:

Strength – how much a character can carry and modifies the damage done with melee weapons
Dexterity – helps determine if a character hits during combat and how well he performs skills like lockpicking
Agility – how well a character moves and dodges during combat and performs skills like climbing
Constitution – helps determine a character ability to soak up damage, whether in combat or due to things like poison. Fairly standard.
Intelligence – overall stat for character’s mental abilities, includes will power in resisting magical spells like illusions, ability to learn spells, etc. I can’t think of a better term for this.

I don’t want to overdo this, but I want some flexibility and “realism” (quoted because I mean realistic in the game world, not necessarily in this one :D). Some RPG systems lump agility and dexterity together into one stat, which I think doesn’t fit. A character could be a great lockpicker but horrible at dodging blows in combat or a great swordsman but doesn’t climb very well, so one stat for both is kind of silly.

For skills, the usual dungeon crawler types of actions will need to be done by a character, besides combat. Lockpicking, the ability to find things that don’t want to be easily found (traps, secret door, etc.), climbing (maybe, for getting out of pits if I implement them), sneaking up on other entities. I’m not sure how deep I want to go here. Implementing skills means dealing with allowing a character to become better at them, and I’ve never really liked many skill progression systems. “Realistically”, a character would get better at things the more they do them, as in games like Dungeon Siege. That’s a good bit of work to handle. Less realistic is allowing a character to “train” at skills by spending skill points. Easier to implement, but just feels wrong.

New game idea LFF (Looking For Feedback)

So I’m a glutton for punishment. I’ve got a couple of games already started and decided to think about starting a new one. :\

Being an RPG/dungeon crawler fan, I wondered what a game that is completely about dungeon crawling could look like. I also thought about how cool it would be if the game could dynamically be expanded through user contributions.

The basic idea is a world map that shows, from the start, all the dungeons that are known to exist in the world. It shows dungeons you’ve completed and not completed differently. It could also show new dungeons that have been “discovered” (uploaded by community) since you last played. The “goal” of the game would be to complete every dungeon in the world.

Leaderboards would show stats such as most loot collected, most monsters killed, most experienced characters as well as non-in-game stats such as highest-rated dungeon (did I fail to mention that the community could vote of contributed dungeons? :D), most crawled through dungeon, highest rated designer, etc.

One idea I’m kicking around is that a player can only have one character at a time. If a character dies, you start over. Stats will carry over, loot and such, but stats would also be displayed as an average – total loot/exp/etc. / number of characters.

Ideally, contributions uploaded by the community would be scanned and ranked based on content – total treasure, total monster exp, etc. in order to allow only characters in a certain range to go through them. Designers could just load down a dungeon will all treasure and no monsters. The loot-to-monster ratio would have to be within a certain percentage.

I need to figure out the specific RPG elements – character stats, classes, equipment, etc. as well as monster and dungeon designing tools, but that’s just a matter of time to ensure the tools are robust enough to enable designers to create good, fun content.. Figuring out if this would even work and be fun is something that I need to get some opinions on. I know it would be fun for me as both a player and a designer. I imagine the achievement/leaderboard junkies would play to get to the top of the boards.

I could see this expanding into areas like allowing players to trade and buy and sell loot, grouping and guilds (this would be single-player only at first), etc. Things like this would be wayyyyy down the road. :)

I’m hoping I get some good feedback and see where this thing goes.

Once more into the breach!

So I got that email I was hoping I’d get this morning. I’m once more an XNA MVP. Seven years now. Now I have to figure out what to do this year to keep it. With XNA being the proverbial red-headed stepchild right now to MS, that’s going to be more difficult.

I’ve been planning on looking into other technologies for doing games on Windows 8 so that they would be able to be featured in the Windows Store. That’s probably going to take away some time from doing anything XNA related to maintain my MVP status.

I’m still planning on, and currently taking a break from coding to write this, releasing at least one game on XBLIG. That won’t really help with with maintaining my MVP status, but it could be a step towards becoming a full-time indie game developer.

Note to self: I need to work on some other New Years resolutions besides getting a game on XBLIG.

In any case, I think it’s going to be an interesting year now that we’ve survived the non-existent Mayan apocalypse. :)

Picking up Microsoft’s slack

Seems like Quality Control is something MS (at least the Windows Phone/XNA/XBLIG/whoever is left these days) isn’t interested in. They broke a huge amount of content in the split between Windows Phone and XBLIG in the old App Hub site. One of the pieces of content was a Best Practices page for doing XNA games. While it’s still findable using the Way Back Machine, all the links in it are broken, so I figured I’d recreate it here and also use it as an excuse to update this blog which I’ve slacked on.


Best Practices for Indie Games 3.1


If you are interested in creating an Xbox LIVE Indie Game, use this guide to understand the expectations of the millions of gamers who will be downloading and playing your game, and the actions you can take to make your game look, feel, and play its very best.

This Guide references features in XNA Game Studio 3.1. A guide for XNA Game Studio 4.0 is being developed, but is not yet available.

A few things to remember:

  • The sections in this guide are ordered by priority, but everything in it is important! Please be sure to read it all and verify that your game take these issues into account.
  • While these best practices are suggestions and not requirements, in many cases your game will be unplayable if you do not follow them. While they are not necessary to pass peer review, and reviewers should not use these guidelines to pass or reject games, they may reject games that are unplayable!
  • Use the playtest support available in the submission process on the App Hub website to have other developers help validate and catch issues with your games, before millions of gamers do.

Gamers Expect Games to “Just Work” on Any TV

Background: Xbox 360 consoles can be plugged into TV sets of all types, with many different resolutions, aspect ratios, and more. Overscan (edges of the TV screen which don’t draw the entire viewport), stretching of your game’s visuals, and even crashes can occur if resolutions are not handled properly.


  • Set your game’s resolution to 1280 x 720 (720p native resolution) to work on all TVs. This gives you a single resolution target for all of your art content.
  • Draw the entire scene to your Viewport size, but draw your critical gameplay features (HUD, main character, and so on) to the region inside
  • Viewport.TitleSafeArea.
  • If using text, use a 14-point or higher font to insure the font can be read on standard-definition TVs. Draw the SpriteFonts at full size.

For Reference, See:

Gamers Expect a Good Trial Mode

Background: Many gamers want to try before they buy, and the Xbox LIVE Indie Games system allows players to try a timed trial of your game before they buy. Currently, the trial mode time is set at eight minutes. When the time runs out, the player is shown a screen where he or she can either purchase the full game, or exit. The only additional restriction in Trial Mode is that Xbox LIVE matchmaking is disabled. During the trial, you have the opportunity to show off the very best your game has to offer.


  • Check whether the game is in Trial Mode by checking if the Guide.IsTrialMode property is true. This will always start out as true, and can change shortly after game startup, or as part of a new player signing in, or in response to an in-game purchase. Be sure to check this once every frame, as opposed to just once at startup.
  • Consider ways to give the player the best experience in the limited amount of time available. This may mean you want avoid title screens or exposition on the story and get right to the gameplay as soon as possible. The time limit for trial mode time is currently set to eight minutes, although this may be changed in the future.
  • When the purchase screen opens, Xbox LIVE Indie Games will set Game.IsActive to false. If the player chooses to buy the game and a successful purchase is made, the game will resume and Guide.IsTrialMode will be set to false. You can manually activate the purchase screen before the time limit expires if you wish, by calling Guide.ShowMarketplace. Your game must be able to handle the IsTrialMode changing without re-starting. This may mean that you need to reload or re-initialize the menus, gameplay or other aspects of the game “on-the-fly” when the flag changes.
  • Consider displaying a scene as the gamer exits the game that gives the gamer the option of being taken to Marketplace to purchase the game using the Guide.ShowMarketplace API, if Guide.IsTrialMode property is true.
  • If your game has Xbox LIVE multiplayer support, disable it at the menu if the game is in Trial Mode – if the player selects the option, you can call Guide.ShowMarketplace. Remember to re-enable it if the Guide.IsTrialMode flag changes to false during the game!
  • Test out trial mode by setting Guide.SimulateTrialMode to true, or by using the “Play Trial Game” option to launch your game from the Xbox Dashboard. This forces the Guide.IsTrialMode flag to true. You can also test that the game handles the transition from Trial mode to being purchased by changing the Guide.SimulateTrialMode to false during game play using a button on the controller that game doesn’t ordinarily use. This way, you know that the game will work properly when they purchase the game without re-starting.

For Reference, See:

Gamers Expect a Friendly Menu and Control System

Background: Games are essentially a cycle – from the Main Menu (and alternate menus such as Options and Help), gamers expect to enter a game session, play, and return to the main menu when they are done. Any deviation from this should be intuitive and easy to remember.

For menu navigation, gamers expect to use both the stick and the D-Pad, with A being the “accept” or “go forward” button, and B and Back being the “cancel” or “go back” buttons.

Both successful and unsuccessful menu operations should be reported in some way to the user, in both graphical and audio form. If there are errors, they should be provided to the user in simple, prescriptive language that tells the player what to do.


  • Use a Menu system, such as in the Game State Management Sample.
  • Use the stick and D-pad to move the menu selector, and use A and B/Back to choose menu items or cancel, respectively. When using the stick for menu movement, poll with a delay to keep the menu selector from moving too fast.
  • The active menu item should stand out clearly from other menu options – use patterns, animations, or other graphical items to account for color blind players.
  • Make sure confirmations and errors are clearly shown to the player, with guidance about what the player should do next.
  • Consider changing the Back button on the controller which by default exits the game with no warning. Provide either a confirmation dialog to insure that the player really wanted to leave the game, or provide an exit menu option from the main menu and remove the Back button exit functionality entirely.
  • The game should bring up a pause menu if the active controller becomes disconnected, or if the player presses the Start button.
  • In networked games, gameplay should continue behind the pause menu even though the local player is no longer engaged in the action.
  • Make sure the game respects Game.IsActive and pauses as appropriate when this is set to false, such as when the guide is being displayed over the game.
  • Games should not stop or pause without game-representative, on-screen graphics. When the pause time is greater than five seconds, the game must indicate the reason and provide on-screen feedback/explanation (aka Loading Screen)

For Reference, See:

Gamers Use One Xbox 360 Controller

Background: This may seem obvious, but it is important. Not only do gamers expect to use an Xbox 360 Controller (not a plugged-in keyboard or Chatpad), but in a single-player game, they are going to expect whichever controller they pick up to be the one the game recognizes throughout their gaming session.


  • Be aware that the player may not be using the controller that is assigned to PlayerIndex.One. To detect which controller the player is using, create a splash screen or initial menu which prompts to the player to press A or Start. Detect which PlayerIndex pressed the button to start the game and use that as the active controller. Here is an example of code to do this:

PlayerIndex controllingPlayer = PlayerIndex.One;
for (PlayerIndex index = PlayerIndex.One; index <= PlayerIndex.Four; index++)
if (GamePad.GetState(index).Buttons.Start == ButtonState.Pressed)
controllingPlayer = index;

  • If your game requires a signed in player profile, you can then look up the profile details for the selected PlayerIndex, or if no profile is currently signed in at that index, call Guide.ShowSignIn to let the player select their profile:

SignedInGamer gamer = Gamer.SignedInGamers[controllingPlayer];
if (gamer != null)
playerName = gamer.Gamertag;
Guide.ShowSignIn(1, false);

  • Do not require the Keyboard for input.
  • Games should launch successfully and get to their menu and/or attract mode even if a controller is not active (For example: game is launched with an IR remote).
  • Use Guide.ShowSignIn to support the signing-in of multiple players to a local multiplayer game.

For Reference, See:

Be Kind With Audio

Background: Audio, at first glance, looks like a very easy technology to get right. Drop in sounds, and play them when asked. However, audio systems are as diverse as TVs. Volume, position, and frequency ranges may be different across the different systems.

Be sure you’re not playing sounds with wildly different volumes that force players to turn their TV’s volume up or down.

In addition, some gamers don’t like music in their games and will want to turn it off – or replace it with their own through the Xbox 360 Guide.


  • Be sure to test your game audio on as many audio configurations as possible (stereo, mono, 5.1, and headphones).
  • Identify and eliminate major volume changes between sounds that would force the player to change audio volume while playing your game. Do this by leveling your sounds to a standard sound. The Xbox 360 startup sound is a good reference. Adjust your speaker volume so that the Xbox 360 startup sound is loud, but not overly so, and adjust your game sounds to match that level.
  • If you have music in your game, you should tag it as such. If you are using XACT, drag the music sounds into the Music category in the tree. If you use the Sound Effects API, then be sure to load your background music files as Song objects, and play them with MediaPlayer.Play. These methods ensure that the player can replace the music through the Xbox 360 Guide.
  • Here’s a tip to lower your game binary size if you are using XACT: enable XMA compression on your wave banks. Add compression in your XACT project in the “Compression Presets” node, and choose the XMA format. Edit the properties of your wavebanks, setting their “Compression Preset” box to the new preset.
  • Be aware that MediaPlayer.Play on the Xbox 360 is asynchronous which means that the song doesn’t immediately start playing. Indeed, you can check the next frame and the song almost certainly won’t have started playing by then and theMediaPlayer.State will probably still be MediaState.Stopped! If you want to start a new song when the old finishes and you check every frame for the current song to be done, each frame you will change songs if you aren’t careful. Instead, add an eventhandler to the MediaPlayer.ActiveSongChanged event and when this event fires, you can begin checking for the current song to be done using MediaPlayer.State == MediaState.Stopped.
  • The content processor for the XNA Framework sound effect API defaults to high compression. Consider how compression affects the overall size and load times of your game, versus the quality of the audio.

Gamer Profiles Matter

Background: Gamers spend a lot of time and effort on their Xbox 360 Profiles. Even if they are not connected to Xbox LIVE, profiles are used in-game to identify which player is which, to store saved games, to identify a gamer in a high score list, and, in some cases, store game defaults such as controller sensitivity. Use these profiles to identify with your gamer, and do things that personalize the experience.


  • The key to profiles is the GamerServicesComponent. Add it to your Game component list. Then you can track profiles in your game.
  • When you start your game, check Gamer.SignedInGamers to check your active controller for a profile. You can choose to ask the gamer to sign in if a profile is not returned, or you can allow the gamer to play anonymously. Unfortunately, anonymous play prevents you opening a storage container for saving game progress, or looking up the player name (eg. for a high score chart) without them having to enter their name manually.
  • Use the gamer’s name. Check SignedInGamer.Gamertag and use it in your game, such as in a status bar or in high score charts.
  • The SignedInGamer class holds a variety of information about your player, including a GameDefaults property that may be useful in automatically tuning your game’s control scheme or difficulty. The GameDefaults.InvertYAxis property is of special interest to 3D games.
  • There’s even more data inside SignedInGamer.GetProfile, such as their gamer picture. You can use this at your discretion.
  • Respond to SignedInGamer.SignedOut on the active controller PlayerIndex. If the player signs out, you can decide what to do. Most games return to the main menu.

For Reference, See:

Represent Your Game

Background: After doing all the hard work to create your game, make sure you take the steps to represent your game in Xbox LIVE Marketplace. Also, you will want to know when people are playing it! Thumbnails, Box Art, Screenshots, Videos, and Rich Presence are key components to making sure your game shows well on Xbox 360.


  • Have a thumbnail. When you submit your game, you will be able to submit a 64×64 jpg file that is your game icon.
  • When submitting your game to the Peer Review process, there are more ways to represent your game – be sure to give your very best! Four screenshots, a short video trailer, and box art. Take the time to create these assets. Your game’s assets are the means by which the Xbox LIVE Marketplace displays your game!
  • Rich Presence is a way for your game to display on Xbox LIVE while it’s being played. For each SignedInGamer playing your game, set Presence.PresenceMode and, if needed, PresenceValue, based on what a gamer is doing in your game at any particular moment. Xbox LIVE Indie Games adds your game title automatically, so everyone knows people are having fun in your game.

Make Loading and Saving Seamless

Background: From the time the game starts to the time the gamer quits the game, there should be good interaction between players and the game – or at the very least, there should be something for gamers to look at.

Most games do a great deal of loading at start-up, so be sure to show something interesting during that time. When saving games, do not pause or freeze the gameplay – keep the action moving and the disk operations in the background.

Players might use Memory Units (MUs) and expect to save their game there. You must use the Storage APIs asynchronously to avoid locking up in the case that your users are using a Memory Unit. Be sure to test your game both with and without an MU connected.


  • Never start your game with a device selector screen. First, this is tacky and makes a poor first impression; second by requiring a player to hit start first you will know the active controller and can handle follow-up message boxes properly.
  • Use an animated loading screen when loading content in your game. This keeps the player from thinking the game has crashed or locked up.
  • Test that your game works when more than one memory device is present, such as having a hard drive AND a memory unit, or two memory units.
  • The first time a player’s game data must be saved or loaded, use Guide.BeginShowStorageDeviceSelector asynchronously to prevent locking up.
  • Do not ask for a storage device again after the first time – this may annoy the player.
  • If you are going to auto-save, notify the player of the auto-save, and tell them not to turn off their Xbox 360 Console while it is saving.
  • Make sure you associate saved games to a profile, but do not associate high scores to a profile. That way, everyone can see the high scores.
  • Saving and loading data in text formats can be problematic depending on the region the Xbox 360 is set to. If you convert a floating point number to a string during a save when the Xbox 360 is set to Germany, for example, you will get 1,234 when you might expect 1.234! To insure that that numeric conversions to and from strings generate the same values in all regions, be sure to store the numbers in a culturally invariant manner, or use a binary file format instead of text.

For Reference, See:

Xbox LIVE Multiplayer: Make it Full Featured

Background: Multiplayer is a valuable feature to have in your game. It increases replay value and connects gamers all over the world. However, it can be frustrating for customers if the experience is not optimized and made user-friendly. If you are building multiplayer into your game, be sure to go the extra mile and provide the features that make Xbox LIVE gameplay great.


  • Take full advantage of the Xbox LIVE Party system to get likeminded players together in your game. Use the SignedInGamer.PartySize to determine if you should inform the player that with a simple button press they can open up the Party UI and quickly send out game invites! A size of zero means you aren’t in a party, one means you are all alone, and anything greater means you are ready to invite some friends. A simple call to Guide.ShowParty() will open the guide directly to the Party screen to streamline the invites to your fellow party members.
  • Support invites, it improves game visibility and ease of joining others for gameplay. To do so, respond to the NetworkSession.InviteAccepted event, quitting any session that the player is in, and joining the new session by callingNetworkSession.JoinInvited. Players can then send each other invites – the invited player will be given the option to purchase the game if necessary – and can join each other’s games in progress.
  • Have a Quick Match feature – don’t make your player hunt for games. Run the matching process in the background and join up with the best session available. Make quick match the default, to improve the odds of gamers finding other players via the Xbox LIVE service.
  • Have a Custom Match feature with a few parameters such as level and rule sets. Limit the number of sessions returned to make it easy for the player to pick.
  • If you have a pre-game lobby, ensure that you are displaying the match settings so that players entering the lobby know what they are getting into.
  • Optimize, optimize, optimize! The XNA Framework can simulate latency and packet loss – you should make sure to turn on both when testing. You should target 8Kb of bandwidth for your network game has this will cover 90% of Xbox 360s. You should also make sure your game can continue playing well with 500 ms of latency. For more details, see the link to Shawn’s talk below!
  • Hosting and/or joining a Multiplayer Game through Xbox LIVE is not available on Xbox LIVE Silver and some Xbox LIVE child accounts, even when the game is purchased. You can determine if a particular Gamer is allowed to participate in an Xbox LIVE session by checking that the SignedInGamer class’s Privileges.AllowOnlineSessions flag is set to true. For example:

if (Gamer.SignedInGamers[activeController].Privileges.AllowOnlineSessions) …

  • Be sure to use the rich presence to let other gamers know that your game is being played. You can also specify where a particular player is in the game using the rich presence strings. Rich presence will also require the SignedInGamer’s PlayerIndex which is another reason why you need to poll for it at startup and save it during game play. For example:

Gamer.SignedInGamers[activeController].Presence.PresenceMode = GamerPresenceMode.AtMenu;

For Reference, See:

Gamers May Have Special Controllers

Background: Many different types of controllers are supported by the XNA Framework. These controllers, which range from flight sticks to dance pads, all return values inside the GamePadState class. Gamers who have these controllers expect them to work in the types of games for which they are traditionally used.

Regardless of the special types used in your game, you should always support the default Xbox 360 Gamepad, and never require special controllers to be able to play.


  • Determine what kind of controllers your game would best be suited for: racing games should support the wheel, flying games should support flight sticks, and so on.
  • When the player starts the game and you know which controller they are using, call GamePad.GetCapabilities and check the GamePadCapabilities.GamePadType returned value to understand what type of controller the player is using.
  • Respond to a special controller type by changing your control scheme to best fit that type. The trigger on an Xbox 360 Controller may not be best suited to a flight stick, for instance. Use the Input Reporter (linked below) to test special controller types to understand their inputs.

For Reference, See:


Background:Starting with XNA Game Studio 3.1, developers have the opportunity to use Avatars when making their Xbox LIVE Indie Game.


  • Users may not have an Avatar so your game should handle this situation. After retrieving the AvatarDescription via the Avatar property on the SignedInGamer the developer should check the IsValid property. If the description is not valid then the player doesn’t have a valid avatar. The developer can replace the users avatar with a random avatar using the AvatarDesctipion.CreateRandom method or load a pre created AvatarDescription.
  • If avatars are used in your networked game users should be able to see the real avatars of the other player. When creating a networked game that uses avatars the developer should send each players AvatarDescription across the network so that each player can display all of the other players avatars. A player should see a players real avatar and not a random avatar.
  • Games should be tested with different size avatars. A players avatar can be a number of different heights and sizes. A game should consider this when developing the game. Collisions may look incorrect with some size avatars.
  • Games should not expect a player to have an avatar with a specific gender. If the game contains gender specific text such as “she”, he”, “her”, or “him” the game should determine if the players gender if female or male using the AvatarDescription.BodyTypeproperty.
  • Keep in mind the rules regarding Avatar Use at all times.

For Reference, See: