TehOne.com Gaming And Development Blog

I am movEd in!!!

2007-04-03T11:40:00.001-07:00

Just wanted to post a quick update and inform everyone that I have finally finished moving into my new place. I'm still waiting for my new desk (end of week) and also for my DSL (should be on today when i get home unless SBC messed up again). Once I get those 2 things, I should be able to make some progress on a few things I have been working on/thinking about. I have been doing a little work on my Sprite; SpriteSheet; SpriteManager classes and so far it's turning out pretty good. I can't wait to be set in my new office in my new house so that I can get back to work and get the classes finished up and polished off and get them out the community for review.

After that, I plan to make a SpriteLayer class. Basically it will just be a parent Sprite with nested (child) Sprites. And when the parent is moved; scaled; rotated, the children will move. This will be useful for the next thing i intend on writing, which will be an animation utility for animating sprites. This will be useful for creating some effects. One of the big reasons for me in making this, will be to add transitions and effects (maybe for menu screens etc...).

Anyways, I just wante to give a quick update on where things are at with me right now. As I said in my last update post, this blog is not dead, it has just been hard to get things done while moving out of 2 different apartments into 1 new house. Well, hopefully I will have more posts next week and hopefully they will have the classes mentioned above that I have been working on!

Xbox Live Arcade Approval Process

2007-03-20T12:59:00.000-07:00

Via: http://www.gamedevblog.com/2007/03/some_answers.html

It's an interesting little read. Get a little insight on what it may take to get your XNA game onto XBLA

To get an Xbox Live Arcade game approved, there's various stages and greenlight meetings you have to get through. First you've got to get somebody there excited enough to get it into a greenlight meeting in the first place.

The next stage is the "Concept Greenlight"

The next stage is a due diligence meeting

Coming up later is the certification or TRC - the "technical requirements checklist"

Changed Rss/Atom Feed

2007-03-19T11:47:00.000-07:00

I have changed my feed over from the built in Blogger rss/atom feeds, to use FeedBurner instead. If you have subscribed to my blog, you may want to update your feed with the new address: http://feeds.feedburner.com/TehOne

Please let me know if you have any problems with the new feed.

Thanks.

Activity

2007-03-19T10:29:00.000-07:00

I haven't had much time to work on my XNA stuff lately or make a any new posts. I'm in the middle of moving out of 2 homes and into a new one. So, this has monopolized a lot of my free time. Hopefully I'll be able to get to work a little more once I get into the new place after the first week April. Things I have been working on are a Texture2DManager, a Sprite DrawableGameComponent and a SpriteLayer DrawableGameComponent. After these are done, I plan to work on some Transition effects stuff.

Well, just wanted to put this news out there (not that anyone is paying attention anyways). This blog isn't dead already or anything like that.

Looking for Shaders?

2007-03-13T14:15:00.000-07:00

If your looking for HLSL Shaders here is a great place to try to find one that fits your needs. NVidia has released a large library of "ready to go" HLSL shaders that you can download and use in your project. This license applies.

http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html

I personally don't have any experience with shaders. I have always thought they were only for 3D games. But now I have seen some 2D games where they are used for effects and also things like adding a bit of "depth" to the 2D game with water etc... An example can be seen here (by Ska Software):

Since seeing that shaders can be used in 2D games with great results, I will be spending more time exploring them. I was probably going to try to use sprites/textures for adding some "pop" to any games I developed. But now that I have seen shaders in 2D games, I think I'll explore using them instead. Only time will tell. In any case, this is a great resource.

Mouse2D GameComponent

2007-03-08T22:35:00.000-08:00

Here is my Mouse2D DrawableGameComponent. I started out just wanting to be able to put a custom Mouse pointer/cursor on the screen instead of the windows mouse. From there the code just seemed to keep evolving more and more. After I got my custom pointer on the screen, I wanted to then place a Texture2D where it clicked (this was mostly for debugging etc, but I think turned out to be useful for other things). I could see this feature being used in map editors maybe, or something where you want to give the user the ability to design what they see on the screen.

Well, from there I just kept adding more and more to the code. Instead of just placing a Texture2D where a click occurred, I wanted to create an event system for the clicks. So, I started adding this in. Then, instead of just tracking clicks, I decided to track when the button is released as well. I also added events for the Mouse scroll wheel as well. Then I created events for when the Mouse was moved. After all that I decided that I should pass back some useful information from the events. So, when the MouseMoved event is fired, we pass back MouseMovedEventArgs which contains the Movement property which is a Vector2 that represents how much the Mouse has moved in the X and Y direction since the last update.

As well as adding some useful information into the events for Mouse movement, I also wanted to add some information on the Mouse button clicks and releases. So the ClickEventArgs class was then created. This contains the Click and PreviousClick properties. By using these, you can figure out how a click occured, and how much the user moved the Mouse before they release the button. This could be useful for drag and drop type of actions (maybe for selecting units in an rts style game) etc. It can also be used to find out how much time in between the click and the release of the button. There are event handlers for each Mouse button and it's state, and for the scroll wheel changes and for the mouses movement.

I called this DrawableGameComponent Mouse2D because it was developed with 2D games in mind (since I have zero 3D game developing skills). I'm not familiar with 3D enough yet to know if this class would need to be changed in order to be affective for 3D game projects. Well, I think that gives enough of an introduction to this. Now I'll post some code. Since the code for Mouse2D is a bit long, especially with the xml comments etc), I won't be putting code from it in this blog post. You will have to download the code in order to view it. Instead, I'm going to post some sample code of how you might use it in a game.

Ok, now on to the code. (code license)

You can download the full source code here: TehOne.Xna.GameComponents.zip
The Mouse2D game demo is here Mouse2DDemo.zip
The online documentation is here: Documentation
The offline documentation is here: Documentation.chm (recommended)

Ok, to start, you would just create a new Widows Game using XNA GSE. You should now have a project with a Game1.cs file in it. This is the base for starting your XNA game. You should end up with something like the below for the first few lines of your new Game1.cs file:

#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
#endregion
namespace WindowsGame1
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
ContentManager content;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
}

Ok, so, we'll change the above to this:

#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using TehOne.Xna.GameComponents;
#endregion
namespace WindowsGame1
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
ContentManager content;
MousePointer2D mousePointer;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
mousePointer = new MousePointer2D(this);
this.Components.Add(mousePointer);
}

Basically, what we did was, we added a field to the class to hold our Mouse2D object. Then, in the constructor, we instantiated the Mouse2D object and stored it in our newly created field. Then, we add the object to the Game.Components collection. If you were to build the game now, you should see a mouse cursor/pointer on the screen. The Texture2D being used for the Mouse is an embedded resource in the TehOne.Xna.GameComponents dll. If you want to use your own Texture2D, then you would set the PointerAssetName in the constructor, like below:

public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
mousePointer = new MousePointer2D(this);
this.Components.Add(mousePointer);
mousePointer.PointerAssetName = @"Content\Sprites\YourMouseAsset";
}

As long as the PointerAssetName that you set exists, then you will now see your custom pointer on the screen if you rebuild the project. If the PointerAssetName that you set doesn't exist, the Mouse2D will still use it's internal Texture2D for the mouse. That is unless you set CanUseInteralAssets property to false. If you did set that to false, and your PointerAssetName you set doesn't exist, then you will get an exception thrown.

Now, to show how to hook into the events. This is a very simple example (to keep this post shorter). A more complete example is included in the code download. This shows you how to move a sprite when the mouse moves. I currently only having it moving from left to right for the sake of example (boundry detection is not being done either). What we are doing is adding a method to be fired when the mouse moves. Then we wire this event into the MouseMoved event of the Mouse2D object.

public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
ContentManager content;
MousePointer2D mousePointer;
private SpriteBatch _spriteBatch;
private Texture2D _sprite;
private Vector2 _spritePosition = new Vector2(0, 0);
public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
mousePointer = new MousePointer2D(this);
this.Components.Add(mousePointer);
mousePointer.PointerAssetName = @"Content\Sprites\YourMouseAsset";
mousePointer.MouseMoved += new MousePointer2D.MouseMovedHandler(mousePointer_MouseMoved);
}
void mousePointer_MouseMoved(object sender, MousePointer2D.MouseMovedEventArgs e)
{
_spritePosition.X = mousePointer.Position.X;
}
protected override void LoadGraphicsContent(bool loadAllContent)
{
if(loadAllContent)
{
_spriteBatch = new SpriteBatch(graphics.GraphicsDevice);
_sprite = content.Load<Texture2D>(@"Content\Sprites\YourSpriteName");
}
}
protected override void Draw(GameTime gameTime)
{
device.Clear(Color.CornflowerBlue);
_spriteBatch.Begin();
_spriteBatch.Draw(_sprite, _spritePosition, Color.White);
_spriteBatch.End();
base.Draw(gameTime);
}

For the last example, I'll wire up some events for the scroll wheel and a left click. First we need to create our methods for each, and then wire them up to the proper events. For the ScrollChanged event, we create a mousePointer_ScrollChanged method and when it is fired, we check to see which way the scroll wheel was moved (up or down). And then we set our sprites Y position based on it. For the LeftButtonPressed event, we create the mousePointer_LeftButtonClicked method and when it is fired we move the our sprites postion to the postion where the click occured.

public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
mousePointer = new MousePointer2D(this);
this.Components.Add(mousePointer);
mousePointer.PointerAssetName = @"Content\Sprites\YourMouseAsset";
mousePointer.MouseMoved += new MousePointer2D.MouseMovedHandler(mousePointer_MouseMoved);
mousePointer.ScrollChanged +=new MousePointer2D.ScrollChangedHandler(mousePointer_ScrollChanged);
mousePointer.LeftButtonPressed += new MousePointer2D.ClickHandler(mousePointer_LeftButtonClicked);
}
void mousePointer_MouseMoved(object sender, MousePointer2D.MouseMovedEventArgs e)
{
_spritePosition.X = mousePointer.Position.X;
}
void mousePointer_ScrollChanged(object sender, MousePointer2D.ScrollChangedEventArgs e)
{
if (e.Direction == MousePointer2D.ScrollChangedEventArgs.ScrollDirection.Up)
_spritePosition.Y -= _sprite.Height;
if (e.Direction == MousePointer2D.ScrollChangedEventArgs.ScrollDirection.Down)
_spritePosition.Y += _sprite.Height;
}
void mousePointer_LeftButtonClicked(object sender, MousePointer2D.ClickEventArgs e)
{
_spritePosition = e.Click.Position;
}

As always, I would really appreciate some feeback on this. I'm sure people can make use of this code (especially beginers). And I'm even more sure that it can be improved with input from others (especially those with more experience then me).

New Source Code Formatting

2007-03-06T23:40:00.000-08:00

Well, after some talking back and forth with ziggy about the code formatting I was using, I have decided to change it. Luckily for me, the page I was using to do the formatting, also has the source code available. I have taken the code and modified it with a look and features that I wanted. You can check out how the code looks by checking out my articles where I posted code, and you can view the tool here... http://tehone.com/utils/SourceFormat/ I'm open to opinions on the code format and I'll be posting the modified source soon.

Dream-Build-Play’s main competition has gone live.

2007-03-05T01:51:00.000-08:00

As well as the new creators website being launched, the kind folks over at the official xna team blog also released the information below. I must say, those are some pretty fantastic prizes. Unfortunately for me, I don't think my skills are up to entering the contest. But, I'll have a lot of fun watching/reading (and hopefully seeing the source code eventually) what others are up to. I guess Ultrahead didn't have to stay tuned very long. Too bad he went to sleep i bet, and let me snap up this information first.

Dream-Build-Play’s main competition has gone live. Fame, fortune and a chance at global envy await you in our Dream-Build-Play competition. The grand prize is a $10,000, an awesome Alienware PC with a smokin’ fast AMD FX processor and ATI graphics card, 3D modeling software, Xbox 360, XNA Creators Club subscription tokens and an amazingly cool Xbox Live Arcade publishing contract for your chance to get your game published on Xbox Live Arcade. Do you have what it takes to win all that and more? Then get started on making your dream game using XNA Game Studio Express and head on over to http://www.dreambuildplay.com to enter it into the contest.

XNA Creators site launched

2007-03-05T01:29:00.000-08:00

A new site for XNA "Creators" has been put up by our friends at Microsoft. I took a brief look at the site and I think it's great. I think it has some bugs (wouldn't let me log in, something about not having a gamer tag even though i do have one). But, overall, the site looks great and it already has a few nice things on it. The first, a new starter kit. I think this is fantastic, we can never have too many examples check out. Another of interest to me, is a sample for font rendering in XNA. I have been hoping we would get this without having to wait too long and it looks like its coming. Not sure when, but they look like they could release it the way it is, or at least in the near future. There are other resources on the site too and hopefully they will be very active with the site and keep posting updates/code/tutorials/starter kits etc. I think the biggest winner here will be the community.

From the article:

The XNA Creators Club Online community site is open for business! Head on over to http://creators.xna.com and register for the XNA Creators Club Online community. You’ll find some great content such as: * A brand new starter kit! (Marblets) * Several samples including a skinning (animation) sample using the XNA Framework Content Pipeline! * Downloadable sample games. New developer forums. * Video tutorials. * Much, much, more!

Framerate GameComponent

2007-03-03T03:11:00.001-08:00

Updated Again: Reformatted source again. Should be the last time. Check out this post for details.

Updated: Removed line numbers in code snippets after some constructive criticism from ziggy.

Here is my implementation of a Framerate (FPS) GameComponent. It is a DrawableGameComponent even though in it's current form it doesn't actually draw anything to the screen. Since there is currently no built in font/text rendering in XNA, this component currently only updates the game window title with the current FPS. It can be easily adapted to draw the framerate to the screen by using something like Nuclex.Fonts or BitmapFonts. But to keep implementation as simple as possible, this is left out of this component for now. This component exposes a CurrentFramerate property that you can use in your Game code to easily draw the FPS to the screen without having to recompile the TehOne.Xna.GameComponents code.

This Framerate component isn't that dissimilar to other framerate GameComponents that you may have seen out there. The main difference is that it has a base class of TehOne.Xna.GameComponents.XnaDrawableGameComponent instead of the regular DrawableGameComponent provided by Microsoft. To see the reason behind this, read up on my previous post here. There are two other main differences from this and other framerate components that you may have seen on the web.

The first difference:
This class exposes a CurrentFramerate property that you can then use in your game. I did this for two reasons: To allow you to have easy access to the current FPS from your game, so you can render text without having to integrate it into this component (and having to recompile it). And, the other reason is that now you can write code in your game that uses the FPS for some sort of logic. I was thinking that this would be useful for something like smoothing out animation based on the current FPS, or smoothing out movement or something else along those lines.
The second difference:
This class has an UpdateFrequency property. This property allows you to set how often you want to calculate the FPS. I don't know about you, but most of the games I play update the FPS more then once a second. So, I thought that I would implement this feature. You can set the frequency to anything higher then 99 as long as it is divisible by 100. This property is based on milliseconds, so if you want to update your FPS every 10th of a second, then you would set this property to 100. Likewise, if you want to update your FPS every other second, you would set this property to 2000.

Ok, now on to the code. (code license)

You can download the full source code here: TehOne.Xna.GameComponents.zip
The online documentation is here: Documentation
The offline documentation is here: Documentation.chm (recommended)

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
namespace TehOne.Xna.GameComponents
{
/// <summary>
/// This is a <see cref="XnaDrawableGameComponent"/> that is used to calculate and display the current framerate (FPS, FramesPerSecond) of the game.
/// <para>Extends <see cref="XnaDrawableGameComponent"/> so that we can use it's <see cref="XnaDrawableGameComponent.PreviouslyEnabled"/> property and take advantage of it auto-enabling and disabling when the game is focused/not-focused.</para>
/// </summary>
public partial class Framerate : XnaDrawableGameComponent
{
private double _fps = 0;
private float _elapsedRealTime = 0;
private string _gameWindowTitle;
private ushort _updateFrequency = 1000;
private float _updateFrequencyRatio;
/// <summary>
/// The CurrentFramerate property represents the current frames per second (FPS) for the game.
/// </summary>
/// <value>The CurrentFramerate property gets the <see cref="_fps"/> data member.</value>
public double CurrentFramerate
{
get
{
return _fps;
}
}
/// <summary>
/// The UpdateFrequency property represents, in milliseconds, how often we are updating the <see cref="_fps"/> count.
/// </summary>
/// <value>The UpdateFrequency property gets/sets the <see cref="_updateFrequency"/> data member.</value>
/// <remarks>
/// This is used to set how often we are calculating the frames per second count.
/// <para>The default value is <c>1000</c>.</para>
/// </remarks>
/// <exception cref="System.ArgumentOutOfRangeException">This exception will be thrown when the <c>value</c> is set less then <c>100</c> or when <c>value</c> is not divisible by <c>100</c>.</exception>
public ushort UpdateFrequency
{
get
{
return _updateFrequency;
}
set
{
if(value % 100 != 0 || value < 100)
throw new ArgumentOutOfRangeException("UpdateFrequency", value, "The UpdateFrequency for the Framerate must is based on milliseconds and must be must be a positive number that is greater then or equal to 100, and the number must be divisable by 100.");
_updateFrequency = value;
// Figure out the new ratio, this way we are reporting the correct frames per second even when we are not calculating ever second.
_updateFrequencyRatio = 1000 / (float)_updateFrequency;
}
}
/// <summary>
/// The main constructor for the class.
/// </summary>
/// <param name="game">The <see cref="Microsoft.Xna.Framework.Game" /> instance for this <see cref="XnaDrawableGameComponent"/> to use.</param>
/// <remarks>Sets the <see cref="_gameWindowTitle"/> data member to the value of <see cref="Microsoft.Xna.Framework.GameWindow.Title"/>.</remarks>
public Framerate(Game game) : base(game)
{
// Save the original game window title
_gameWindowTitle = game.Window.Title;
// We are basing the ratio on 1 second (1000 milliseconds)
_updateFrequencyRatio = 1000 / (float)_updateFrequency;
}
/// <summary>
/// Allows the game component to perform any initialization it needs to before starting
/// to run. This is where it can query for any required services and load content.
/// </summary>
public override void Initialize()
{
base.Initialize();
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (!this.Enabled)
return;
// The total real time in milliseconds since the last Update().
float elapsed = (float)gameTime.ElapsedRealTime.TotalMilliseconds;
// Adds the Update() elapsed real time to the cumulative elapsed real time.
_elapsedRealTime += elapsed;
// If the elapsed time is greater than our update frequency then: calculate the framerate, and reduce the elapsed real time count.
if(_elapsedRealTime > _updateFrequency)
{
_fps = (_updateFrequency / elapsed) * _updateFrequencyRatio; // calculate the framerate
_elapsedRealTime -= _updateFrequency; // adjust the elapsedRealTime
}
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Draw(GameTime gameTime)
{
base.Draw(gameTime);
if (!this.Visible || !this.Enabled)
return;
this.Game.Window.Title = _gameWindowTitle + " FPS: " + _fps.ToString("F");
}
/// <summary>
/// This method is the <see cref="System.EventHandler"/> for the <see cref="Microsoft.Xna.Framework.GameComponent.EnabledChanged"/> event.
/// </summary>
/// <param name="sender">The events sender</param>
/// <param name="args">The events arguments.</param>
protected override void OnEnabledChanged(object sender, EventArgs args)
{
if(!this.Enabled)
this.Game.Window.Title = _gameWindowTitle;
base.OnEnabledChanged(sender, args);
}
/// <summary>
/// This method is the <see cref="System.EventHandler"/> for the <see cref="Microsoft.Xna.Framework.GameComponent.EnabledChanged"/> event.
/// </summary>
/// <param name="sender">The events sender</param>
/// <param name="args">The events arguments.</param>
protected override void OnVisibleChanged(object sender, EventArgs args)
{
if (!this.Visible)
this.Game.Window.Title = _gameWindowTitle;
base.OnVisibleChanged(sender, args);
}
}
}

Ok, so now we need to put this into our game. Add a member to your class for the Framerate. It should look something like this:

public class Game1 : Microsoft.Xna.Framework.Game
{
ContentManager content;
GraphicsDeviceManager graphics;
Framerate framerate;

Now we need to instantiate the Framerate and add it to the Game.Components collection. This is done in your constructor for your game. It should look something like this:

public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
framerate = new Framerate(this);
framerate.UpdateFrequency = 100;
this.Components.Add(framerate);

Note: We also set the UpdateFrequency to 100 which will cause our FPS to be calculated every 10th of a second instead of the default of every once per second.

Well, that is pretty much all there is to it. If you have done everything correctly, when you launch your (windowed) game, you should see the framerate in the window title.

You can download the full source code here: TehOne.Xna.GameComponents.zip
The online documentation is here: Documentation
The offline documentation is here: Documentation.chm (recommended)

Enabling-Disabling GameComponents when a game is Activated-Deactivated

2007-03-01T08:00:00.000-08:00

Updated Again: Reformatted source again. Should be the last time. Check out this post for details.

Updated: Removed line numbers in code snippets after some constructive criticism from ziggy.

For my GameComponents, I wanted a graceful way to Disabled and then Re-Enable them when the Game is Activated and when it is Deactivated. The important thing for me was to Disable all of the GameComponents when the Game gets Deactivated and then when the Game is Activated, I want to Re-Enable the GameComponents that were already Enabled prior to the Game being Deactivated.

The best way I saw to do this, was to extend the GameComponent class. So, that's what I have done for all (not that there is a lot yet, only 2 so far) of my custom GameComponents.

So, here you'll find the code that I used to accomplish this. Maybe in a future version of XNA this will be included into the GameComponent class.

All of the code on this site is subject to this license:

/*
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies
* or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

Ok, now on to the code. (code license)

You can download the full source code here: TehOne.Xna.GameComponents.zip
The online documentation is here: Documentation
The offline documentation is here: Documentation.chm (recommended)

I chose to first create an Interface. I created this because I needed to extend both GameComponent and also DrawableGameComponent, but I wanted to extend both of them in the same way and wanted to make sure each new extended class would adhere to a set of rules about its structure. If you are not familiar with Interfaces, see this great post on jsedlak.org for an introduction about them.

So, let's start with the Interface code. It's a pretty simple Interface, not much going on. Remember, we are only extending the GameComponent class to add 3 things: a way to keep track of the previous Enabled state, an EventHandler for Game.Activated, and an EventHandler for Game.Deactivated. Ideally, by using an Interface, I leave the ability to easily add other features later if needed and still make sure that my new extended classes adhere to a structure.

using System;
namespace TehOne.Xna.GameComponents
{
/// <summary>
/// This <c>interface</c> is used to help extend the base <see cref="Microsoft.Xna.Framework.GameComponent"/> object.
/// <para>We add the <see cref="PreviouslyEnabled"/> field and an <see cref="System.EventHandler"/> method for handling the <see cref="Microsoft.Xna.Framework.GameComponent.EnabledChanged"/> event.</para>
/// </summary>
public interface IXnaGameComponent
{
/// <summary>
/// The PreviouslyEnabled property represents the previous value of <see cref="Microsoft.Xna.Framework.GameComponent.Enabled"/> for this <see cref="IXnaGameComponent"/>.
/// </summary>
bool PreviouslyEnabled
{
get;
set;
}
/// <summary>
/// This method is the <see cref="System.EventHandler"/> for the <see cref="Microsoft.Xna.Framework.Game.Activated"/> event.
/// </summary>
/// <param name="sender">The <see cref="System.Object"/> that called this event.</param>
/// <param name="e">The arguments that were passed into this event.</param>
void Game_Activated(object sender, EventArgs args);
/// <summary>
/// This method is the <see cref="System.EventHandler"/> for the <see cref="Microsoft.Xna.Framework.Game.Deactivated"/> event.
/// </summary>
/// <param name="sender">The <see cref="System.Object"/> that called this event.</param>
/// <param name="e">The arguments that were passed into this event.</param>
void Game_Deactivated(object sender, EventArgs args);
}
}

Ok, so from here, we need to create 2 classes that implement the Interface we just created and extend a base class from the XNA framework. One that extends GameComponent and one that extends DrawableGameComponent. The 2 new classes are basically exactly the same. The only difference is the base class which they extend.

using System;
using Microsoft.Xna.Framework;
namespace TehOne.Xna.GameComponents
{
/// <summary>
/// This <c>partial class</c> is used to extend the base <see cref="Microsoft.Xna.Framework.DrawableGameComponent"/> object.
/// <para>Implements the members of <see cref="IXnaGameComponent"/>.</para>
/// </summary>
public partial class XnaDrawableGameComponent : Microsoft.Xna.Framework.DrawableGameComponent, IXnaGameComponent
{
private bool _previouslyEnabled = true;
/// <summary>
/// The PreviouslyEnabled property represents the previous value of <see cref="Microsoft.Xna.Framework.GameComponent.Enabled"/> for this <see cref="Microsoft.Xna.Framework.GameComponent"/>.
/// </summary>
/// <value>The PreviouslyEnabled property gets/sets the <see cref="_previouslyEnabled"/> data member.</value>
/// <remarks>The value of the <see cref="_previouslyEnabled"/> data member is set when the <see cref="OnEnabledChange(object, EventArgs)"/> event is fired.</remarks>
public bool PreviouslyEnabled
{
get
{
return _previouslyEnabled;
}
set
{
_previouslyEnabled = value;
}
}
/// <summary>
/// The main constructor for <see cref="XnaDrawableGameComponent" />
/// </summary>
/// <param name="game">The <see cref="Microsoft.Xna.Framework.Game" /> instance.</param>
public XnaDrawableGameComponent(Game game)
: base(game)
{
game.Activated += new EventHandler(Game_Activated);
game.Deactivated += new EventHandler(Game_Deactivated);
}
/// <summary>
/// This method is the <see cref="System.EventHandler"/> for the <see cref="Microsoft.Xna.Framework.Game.Activated"/> event.
/// </summary>
/// <param name="sender">The <see cref="System.Object"/> that called this event.</param>
/// <param name="e">The arguments that were passed into this event.</param>
/// <remarks>When this <see cref="System.EventHandler"/> is fired, we set our <see cref="Microsoft.Xna.Framework.GameComponent.Enabled"/> value to be the value of the <see cref="_previouslyEnabled"/> data member.</remarks>
public void Game_Activated(object sender, EventArgs e)
{
this.Enabled = _previouslyEnabled;
}
/// <summary>
/// This method is the <see cref="System.EventHandler"/> for the <see cref="Microsoft.Xna.Framework.Game.Deactivated"/> event.
/// </summary>
/// <param name="sender">The <see cref="System.Object"/> that called this event.</param>
/// <param name="e">The arguments that were passed into this event.</param>
/// <remarks>When this <see cref="System.EventHandler"/> is fired, we set our <see cref="_previouslyEnabled"/> data member value to be the value of <see cref="Microsoft.Xna.Framework.GameComponent.Enabled"/>. Then, we set our <see cref="Microsoft.Xna.Framework.GameComponent.Enabled"/> state to <c>false</c>.</remarks>
public void Game_Deactivated(object sender, EventArgs e)
{
_previouslyEnabled = this.Enabled;
this.Enabled = false;
}
/// <summary>
/// Allows the game component to perform any initialization it needs to before starting
/// to run. This is where it can query for any required services and load content.
/// </summary>
public override void Initialize()
{
_previouslyEnabled = this.Enabled;
base.Initialize();
}
}
}

Ok, so that is all we need. Now, when we create a custom GameComponent or DrawableGameComponent we will just have it extend from one of these 2 new classes. As an example:

public partial class Framerate : XnaDrawableGameComponent

That's all there is too it. Now any GameComponent that use XnaGameComponent as it's base class, or any DrawableGameComponent that use XnaDrawableGameComponent as it's base class, will automatically be disabled when the Game is Deactivated and they will re-enable (if they were enabled before the Deactivate) themselves when the Game is Activated.

You can download the full source code here: TehOne.Xna.GameComponents.zip
The online documentation is here: Documentation
The offline documentation is here: Documentation.chm (recommended)

I hope this code proves usefull for others. Any comments/suggestions/feedback?

Getting Started

2007-02-28T18:53:00.000-08:00

Ok. So a little about me. I've been a programmer since 1995. I've worked mostly on non-public facing websites for small to medium sized companies. I have a degree in Computer Sciences, and so I of course did take C and C++ in school. But, since then I have rarely used either and so now prefer to avoid both if I can. I also have some experience with Java and JSP. However, I have done mostly all Microsoft technologies related programming in my professional career. I have done tons of ASP and VB Script coding over the last 10 years. But ever since the first or second beta of ASP.Net I have been working mostly with it using the C# language.

Ever since I can remember, I have also been a gamer at heart. I've probably never been through a time in my life when I didn't have some kind of game console hooked up to my TV. As I got older, I started to get more into PC gaming though. And with this, came the possibility and desire to make/mod games. This has been a thought in the back of my mind for a long time now, but I never started really diving into it. My reasons for not starting on it are basically: 1. Being too busy to make time for it (see: Procrastination) and 2. Barrier to entry. Reason #2 is what I think was my biggest reason that I never got started. As I said above, I haven't done C++ since my school days. And since the majority of games are made in C++, I wasn't very motivated to jump right in. Another facet of #2 is cost. As I think most of us are aware of, the cost of making a game has skyrocketed over the last decade or so. Now, I know this doesn't affect indie game makers that much, but it still weighed in on my mind. I would have probably wanted to license/use a game engine since I had limited experience with game design. I am also not a 3D modeler either, so I probably would have needed to either contract out to one or pay for some pre-made models. I am also not an artist, so again I would have had to contract out to one or hire one, or purchase some pre-made stuff.

So, with all those worries in my mind, I thought I would start smaller. Since I was (and still am) a very dedicated Day of Defeat gamer, I decided that I would try to make some maps for the game. I downloaded their map/world editor and got to playing around. It wasn't the easiest to use, and the new release of the game (Day of Defeat:Source, using Valves Source game engine) and it's map/world editor was coming soon, so I never made a map for the game. So, when they release the new map/world editor, I got into it again and map a few sample maps. This was before the new game came out though. So I was just testing the editor and viewing them in Half Life2. Finally, the new game came out, and unfortunately it didn't live up to my expectations and I had no interest in playing the new version of the game. And of course, with that went my desire to make maps for it.

Ok, so on to today in the gaming market. For one, I have been playing more and more games over the years, and it seems with the more I play, the more I want to get into game development. And, I think today there are more things available for free/inexpensive then ever before too. There are a number of open source and free game engines. There are a number of free/inexpensive assets out there too, from textures, models etc... And, now there is XNA and Game Studio Express (GSE). With these two new tools, game developing has taken another step in the right direction to lower the barrier to entry into game development. With these new technologies/tools, my interest in game design has again been peaked. So, I think to start, I will just make some 2D games. Maybe puzzle/ball games (see: Zuma, Luxor - Amun Rising) or just simple games in general.

Along my journey into game development, I will be posting some code and looking for feedback/comments/suggestions. I also hope to develop some good re-usable code (class libraries) and some GameComponents for others to use. Hopefully I'll develop some stuff that will be useful for others that are new to game development. And hopefully for anything that I publish, people will provide me with some feedback on it with some criticisms and or suggestions.

I expect to publish my first GameComponents in the next few days or so. There will be one for Framerate calculation and display (probably similar to a lot of other Framerate components that are already out there), and more importantly, one for Mouse related stuff. Like using a custom pointer and also an event driven system for movement/clicks/scrolls.

Well, I hope that this gives a clear introduction of who I am and what my current/thoughts and goals are.