So, I’ve been plugging away at Slay the Beast and posting builds on IndieDB. It’s… pretty cool actually. I admit that I was a bit cautious going into the whole “open development” thing, but posting regular builds to IndieDB has been really enlightening and encouraged me to ferret out many bugs that I might otherwise have let fester. So, yay that!

In other, highly-related, news, I’ve release version 0.0.9 of Slay the Beast for your consumption.
Since the last build I have:

• Fixed characters not flashing red on fatal blow
• Knight will now fall in different directions depending on direction of fatal blow
• Added blue glow at base of flame attacks
• Added particle effects to fireball and slash impacts
• Fixed race-condition crash going from menu to in-game
• Archdemon can now turn-around by pressing RB (Right Bumper) / P on Keyboard
• Fixed some garbage collection issues
• Added particle effects on Knight and Archdemon death
• Fixed Knight knockback logic to be framerate independent
• Fireballs that land outside arena no longer spawn flames inside the arena
• Added shadow under fireballs
• Added breakable candles that release power-ups that can be used by heroes

Hit the link to enjoy the chaos:

Anyway, YouTuber and Twitterer (Tweeter?) @xtomass recently uploaded a video of his play-through of version 0.0.6 of Slay the Beast and I would be remiss not to share it.

So, enjoy!

A new version of my latest indie game, Slay the Beast, is now available on IndieDB. This build fixes several bugs and adds new Knight abilities.

New features / fixes in this build:

• Made Demon spit attack slightly faster
• Added Dash / Air-Dash ability to Knight
• Fixed bug where demon could get stuck in a waiting-to-respawn state
• Fixed animations and particles persisting between rounds
• Added Slash Projectile when Knight attacks with full HP
• Made life bars dual-layered so it’s easier to see recent damage inflicted
• Fixed intermittent boot crash

Just hit the button below to download version 0.0.3:

Click this banner to visit Slay the Beast on IndieDB:

This is an early PRE-ALPHA version of the game. This means that it is very far from feature complete. It is not representative of the final product. As development continues, this game will continue to be updated and have new features added regularly.

This version of Slay the Beast is for 2 players to compete in a 2-round match between a heroic Knight and a powerful Archdemon.

Just hit the button below to download the build (Version 0.0.1):

UPDATE:
Version 0.0.2 now available:

Or click below to visit Slay the Beast on IndieDB:

As proof, here’s a (very) early work-in-progress screenshot of my current indie game project, Slay the Beast:

Slay the Beast is a versus fighting game where one player controls a huge boss-level monster. While the other player controls a puny (but respawning) hero. The sprites are from Oryx Design Lab‘s Hifi Gothic Set and animation is done with Spine, from Esoteric Software.

The game is still at an early stage of development. Heck, I just started this project a few weeks ago! However, I plan on making WIP builds available soon. Stay tuned for more news.

EDIT:
Here are some more screenshots for your viewing pleasure:

And one more for people who’d like to see how characters look in-editor:

That is a whole lot of missiles!

I can’t think of any more appropriate back-of-the-box quote than that for Itano Alpha Flight, my latest game on Xbox Live Indie Games. This game is all about missiles, yours and your enemies. It’s a little bit of Afterburner, a little bit of Macross, and a whole lot of action.

You can see screenshots of the game below:

Grab the game here or on your Xbox 360 for 80 Microsoft Points ($1 US).

Okay, okay. I’m about two weeks late but I finally finished up my February #OneGameAMonth entry. In my defense, I did have a confluence of life and work events knock into my schedule. But, that’s neither here nor there. I said One Game a Month.

As I mentioned previously, my goal for February’s game was to capture some of that Itano Circus feel. With that in mind, I even went so far as to name the game “Itano Alpha Flight”. And now the game is available for you to play.

Itano Alpha Flight is an action game written in XNA and running on Windows. The goal of the game is to destroy enemies in rapid succession with your lock-on missiles while avoiding their projectiles. You can control the game with either the keyboard or with an Xbox Controller.

To play, you just need to download this file, unzip it, and run Itano.exe.
I’m just one guy, so I can’t really make an guarantees about the suitability of this game for any purpose but I expect it should run reasonably well on most Windows machines.

You can also see how the game turned out in these screenshots:

So, if you have a chance, give Itano Alpha Flight a try and let me know what you think. In the meantime, I’ll be plugging away on my next project.

Yuck.

So, in the interest of helping other XNA devs out there, let me tell you about what I screwed up and how I fixed it.

So, let’s get to the meat. Let me show you how I screwed up my save data handling.

First, this is how I read my save data:

// Deserialization
XmlSerializer s = new XmlSerializer(typeof(T));
if (container.FileExists(filename))
{
    TextReader r = new StreamReader(container.OpenFile(filename, FileMode.Open));
    saveDataItem = (T)s.Deserialize(r);
    r.Close();
}
container.Dispose();

And this is how I wrote it:

// Serialization
XmlSerializer s = new XmlSerializer(saveDataItem.GetType());
TextWriter w = new StreamWriter(container.OpenFile(filename, FileMode.OpenOrCreate));
s.Serialize(w, saveDataItem);
w.Close();

See the bug? Yeah, well, neither did I. You see, there was this little problem with how I wrote my save data. The code above would work in most cases, but if I wrote data that was shorter than the previous file’s save data, the old save data would only be partially overwritten. Any bytes of the old save data not explicitly overwritten by the new save data would remain appended to the end of the new save data. Thus potentially turning data like this:

<RobotSaveData><Cash>12345</Cash></RobotSaveData>

Into data like this:

<RobotSaveData><Cash>123</Cash></RobotSaveData>a>

And totally confounding the XML deserializer. Voila! Broken save data and unhappy customers. To top it off, as far as I can tell, this behavior doesn’t replicate on Windows, only on the Xbox 360. You can imagine my consternation.

Enough about what went wrong. Here’s how I went about fixing it. I changed the way I opened a file for writing my save data:

// Serialization
XmlSerializer s = new XmlSerializer(saveDataItem.GetType());
TextWriter w = new StreamWriter(
    container.FileExists(filename) ?
    container.OpenFile(filename, FileMode.Truncate) :
    container.OpenFile(filename, FileMode.Create)
);
s.Serialize(w, saveDataItem);
w.Close();

This big difference here is that I use FileMode.Truncate when opening the file for writing save data. By doing this, I’m able to dispose of the old contents and completely overwrite them with my new save data.

EDIT: I was recently informed by one of the fine members of the XBLIG community that simply using FileMode.Create when I open a file is sufficient for my purposes since it’s behavior when a file exists is the same as FileMode.Truncate.

The core functionality of my text pre-rendering solution is drawing a given string to a texture using a given font. I’m then able to use that text texture anywhere in my game as I would any normal texture. This allows me to avoid the overhead of calling DrawString() for text in my game that doesn’t have to change often.

SpriteFont demoFont = Game.Content.Load<SpriteFont>("TextRenderingDemo/DemoFont");
Texture2D textTexture = textWriter.CreateTextSpriteTexture(demoFont, "The quick, brown fox jumped over Richter Belmont");

In addition to the core functionality, I added the following features:

Button Guides
The XBLIG Creator’s site provides images of the Xbox Controller’s buttons compatible with XNA’s SpriteFont for providing on-screen control instructions. While it’s possible to combine the button images with another sprite font image and use them as one SpriteFont, I prefer to combine the button images with fonts I choose at runtime. To do this, I prepared a version of my string rendering function with extra parameters for rendering the button image and positioning it relative to the text of my choice.

SpriteFont demoFont = Game.Content.Load<SpriteFont>("TextRenderingDemo/DemoFont");
SpriteFont buttonFont = Game.Content.Load<SpriteFont>("Fonts/xboxControllerSpriteFont");
Texture2D textTexture = textWriter.CreateButtonGuideTextSpriteTexture(demoFont, buttonFont, ": Do Something", "'", 0.5f, new Vector2(0.0f, 0.0f));

Drop Shadows
In a lot of cases, just rendering SpriteFonts as is tends to feel a little flat. Drawing a darkened version of the same text offset by a couple pixels before drawing the text in question goes a long way to helping it stand out. It’s a trick I use so often that I decided to bake drop shadows into my text pre-renderer. With this functionality, a call like this:

SpriteFont demoFont = Game.Content.Load<SpriteFont>("TextRenderingDemo/DemoFont");
List<TextWriterDropShadow> dropShadows = new List<TextWriterDropShadow>();
dropShadows.Add(new TextWriterDropShadow(new Vector2(2.0f, 2.0f), Color.Black));

Texture2D textTexture = textWriter.CreateTextSpriteTexture(demoFont, "The quick, brown fox jumped over Richter Belmont", Color.White, dropShadows);

Can give me text that looks like this:

Text Borders
You’ll notice that I pass lists of drop shadows to my sprite pre-renderer. It may seem like overkill, but being able to define a multiple drop shadows allows me to create various effects when rendering text. For example, I can define a list of drop-shadows like this:

SpriteFont demoFont = Game.Content.Load<SpriteFont>("TextRenderingDemo/DemoFont");
List<TextWriterDropShadow> dropShadows = new List<TextWriterDropShadow>();
dropShadows.Add(new TextWriterDropShadow(new Vector2(-1.0f, -1.0f), Color.Black));
dropShadows.Add(new TextWriterDropShadow(new Vector2(1.0f, -1.0f), Color.Black));
dropShadows.Add(new TextWriterDropShadow(new Vector2(-1.0f, 1.0f), Color.Black));
dropShadows.Add(new TextWriterDropShadow(new Vector2(1.0f, 1.0f), Color.Black));

dropShadows.Add(new TextWriterDropShadow(new Vector2(0.0f, -2.0f), Color.Black));
dropShadows.Add(new TextWriterDropShadow(new Vector2(0.0f, 2.0f), Color.Black));
dropShadows.Add(new TextWriterDropShadow(new Vector2(-2.0f, 0.0f), Color.Black));
dropShadows.Add(new TextWriterDropShadow(new Vector2(2.0f, 0.0f), Color.Black));

Texture2D textTexture = textWriter.CreateTextSpriteTexture(demoFont, "The quick, brown fox jumped over Richter Belmont", Color.White, dropShadows);

To give me fancy bordered text like this:

How’s that for pop?

Playing with the number of drop shadows, their offsets, and colors can allow you to produce a variety of decorations for your game’s text. Give it a try if you’re interested. You can find the code for my text pre-renderer below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace EstrellaLib.Sprite
{
    public class TextWriterDropShadow
    {
        public Vector2 Offset;
        public Color Color;

        public TextWriterDropShadow(Vector2 offset, Color color)
        {
            Offset = offset;
            Color = color;
        }
    }

    public class TextTextureWriter
    {
        GraphicsDevice _graphics;
        SpriteBatch _spriteBatch;

        public TextTextureWriter(GraphicsDevice graphics)
        {
            _graphics = graphics;
            _spriteBatch = new SpriteBatch(graphics);            
        }

        public Texture2D CreateTextSpriteTexture(SpriteFont spriteFont, string textString)
        {
            return CreateTextSpriteTexture(spriteFont, textString, Color.White, null);
        }

        public Texture2D CreateTextSpriteTexture(SpriteFont spriteFont, string textString, Color textColor, List<TextWriterDropShadow> dropShadows)
        {
            return RenderTextTexture(spriteFont, textString, textColor, null, "", 1.0f, Vector2.Zero, dropShadows);
        }

        public Texture2D CreateButtonGuideTextSpriteTexture(SpriteFont textSpriteFont, SpriteFont buttonGuideSpriteFont, string textString, string buttonGuideText, float buttonGuideScale, Vector2 buttonGuidePositionOffset)
        {
            return CreateButtonGuideTextSpriteTexture(textSpriteFont, buttonGuideSpriteFont, textString, buttonGuideText, buttonGuideScale, buttonGuidePositionOffset, Color.White, null);
        }

        public Texture2D CreateButtonGuideTextSpriteTexture(SpriteFont textSpriteFont, SpriteFont buttonGuideSpriteFont, string textString, string buttonGuideText, float buttonGuideScale, Vector2 buttonGuidePositionOffset, Color textColor, List<TextWriterDropShadow> dropShadows)
        {
            return RenderTextTexture(textSpriteFont, textString, textColor, buttonGuideSpriteFont, buttonGuideText, buttonGuideScale, buttonGuidePositionOffset, dropShadows);
        }

        private Texture2D RenderTextTexture(SpriteFont textSpriteFont, string textString, Color textColor, SpriteFont buttonGuideSpriteFont, string buttonGuideText, float buttonGuideScale, Vector2 buttonGuidePositionOffset, List<TextWriterDropShadow> dropShadows)
        {
            if (textSpriteFont != null)
            {
                Vector2 stringDimensions = textSpriteFont.MeasureString(textString);

                float buttonHorizontalShift = 0.0f;
                Vector2 buttonTextDimensions = Vector2.Zero;
                if (buttonGuideSpriteFont != null)
                {
                    buttonTextDimensions = buttonGuideSpriteFont.MeasureString(buttonGuideText);
                    buttonTextDimensions.X *= buttonGuideScale;

                    buttonTextDimensions.X += Math.Abs(buttonGuidePositionOffset.X);
                    if (buttonGuidePositionOffset.X < 0.0f)
                    {
                        buttonHorizontalShift = -buttonGuidePositionOffset.X;
                    }

                    //Eliminate potential non-integral values that could result in lost pixels on texture render
                    buttonTextDimensions.X = (float)Math.Ceiling(buttonTextDimensions.X);
                }

                Vector2 dropShadowPositionAdjust = Vector2.Zero;
                Vector2 dropShadowSizeAdjust = Vector2.Zero;
                if (dropShadows != null)
                {
                    Vector2 lowestVals = Vector2.Zero;
                    Vector2 hightestVals = Vector2.Zero;
                    foreach (TextWriterDropShadow dropShadow in dropShadows)
                    {
                        if( dropShadow.Offset.X < 0.0f )
                            lowestVals.X = Math.Min(lowestVals.X, dropShadow.Offset.X);

                        if (dropShadow.Offset.Y < 0.0f)
                            lowestVals.Y = Math.Min(lowestVals.Y, dropShadow.Offset.Y);

                        if (dropShadow.Offset.X > 0.0f)
                            hightestVals.X = Math.Max(hightestVals.X, dropShadow.Offset.X);

                        if (dropShadow.Offset.Y > 0.0f)
                            hightestVals.Y = Math.Max(hightestVals.Y, dropShadow.Offset.Y);
                    }

                    dropShadowPositionAdjust.X = Math.Abs(lowestVals.X);
                    dropShadowPositionAdjust.Y = Math.Abs(lowestVals.Y);

                    dropShadowSizeAdjust.X = Math.Abs(lowestVals.X) + Math.Abs(hightestVals.X);
                    dropShadowSizeAdjust.Y = Math.Abs(lowestVals.Y) + Math.Abs(hightestVals.Y);
                }

                RenderTarget2D renderTarget = new RenderTarget2D(_graphics, (int)stringDimensions.X + (int)buttonTextDimensions.X + (int)dropShadowSizeAdjust.X, (int)stringDimensions.Y + (int)dropShadowSizeAdjust.Y);

                _graphics.SetRenderTarget(renderTarget);
                _graphics.Clear(Color.Transparent);
                _spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, null, null);
                
                if (buttonGuideSpriteFont != null)
                {
                    _spriteBatch.DrawString(buttonGuideSpriteFont, buttonGuideText, dropShadowPositionAdjust + new Vector2(buttonHorizontalShift, buttonTextDimensions.Y * -0.25f * buttonGuideScale) + buttonGuidePositionOffset, Color.White, 0.0f, Vector2.Zero, buttonGuideScale, SpriteEffects.None, 1.0f);
                }

                Vector2 textPosition = dropShadowPositionAdjust + new Vector2(buttonHorizontalShift + buttonTextDimensions.X, 0.0f);
                if (dropShadows != null)
                {
                    foreach (TextWriterDropShadow dropShadow in dropShadows)
                    {
                        _spriteBatch.DrawString(textSpriteFont, textString, textPosition + dropShadow.Offset, dropShadow.Color);
                    }
                }

                _spriteBatch.DrawString(textSpriteFont, textString, textPosition, textColor);
                
                _spriteBatch.End();
                _graphics.SetRenderTarget(null);

                return renderTarget;
            }
            return null;
        }
    }
}

/* Button Guide Mapping
Character	Image
Space       Left Thumbstick
!	        Directional Pad
"	        Right Thumbstick
#	        BACK
$	        Guide
%	        START
&	        X
'	        A
(	        Y
)	        B
*	        Right Shoulder
+	        Right Trigger
,	        Left Trigger
-	        Left Shoulder
*/

Fixing Problem #1: Structs as Dictionary Keys
So, according to the CLRProfiler, I’m creating ActorStates via Generic.ObjectEqualityComparer::Equals() during my ChooseTargetNode() function. Looking at that code, it simple looks like I’m checking against a Dictionary that uses ActorState as a key. A quick Google search turns up this tidbit on XNA Wikia. The article talks about how Enums cause memory allocations when used as keys in Dictionaries. It’s fair to assume that structs would have similar behavior and cause garbage to be created when used by the Dictionary’s internal comparison functions. Luckily, the fix for this is easy. If a struct implements IEquatable, Dictionary won’t allocate instances of that struct during comparisons. Since my ActorState struct already implemented comparison functions, I just needed to add IEquatable as a part of its declaration.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EstrellaLib.Actor
{
    public struct ActorState : IEquatable<ActorState>
    {
        string _stateName;

        public ActorState(string stateName)
        {
            _stateName = stateName.ToUpperInvariant();
        }

        public string StateName
        {
            get
            {
                return _stateName;
            }
            set
            {
                _stateName = value.ToUpperInvariant();
            }
        }

        public override bool Equals(object obj)
        {
            if (obj is ActorState)
            {
                return this.Equals((ActorState)obj);
            }
            return false;
        }

        public bool Equals(ActorState p)
        {
            return _stateName == p._stateName;
        }

        public override int GetHashCode()
        {
            return _stateName.GetHashCode();
        }

        public static bool operator ==(ActorState lhs, ActorState rhs)
        {
            return lhs.Equals(rhs);
        }

        public static bool operator !=(ActorState lhs, ActorState rhs)
        {
            return !(lhs.Equals(rhs));
        }

        public static ActorState None = new ActorState("NONE");
    }
}

Once I did that, ActorState disappeared from my allocation list on a second CLRProfiler run.

Fixing Problem #2: Value Type Boxing with PropertyInfos
While the boxing problem caused by my code is relatively straight-forward:

        public override void ApplyToActor(Actor targetActor)
        {
            if (_targetProperty == null)
            {
                _targetProperty = targetActor.GetType().GetProperty(_targetName);
                _targetActor = targetActor;
            }
            System.Diagnostics.Debug.Assert(_targetActor == targetActor);

            //PropertyInfo.SetValue(object obj, object value, object[] index)'s second parameter
            // causes any value types I pass to it to be boxed in a temporary System.Object
            _targetProperty.SetValue(targetActor, _targetValue, null);
        }

Fixing it, is not quite as easy as simply implementing a particular interface. I need to find a way to avoid calling SetValue(). Thankfully, PropertyInfo provides a way for me to get a delegate for setting the properties value that is typed to the value I’m trying to set. This means that, if I go through the setter delegate, I can avoid implicitly casting my value type to a System.Object and creating garbage. With a bit of work, I modify my code and end up with something like this:

        public override void ApplyToActor(Actor targetActor)
        {
            if (_targetActor == null)
            {
                PropertyInfo targetProperty = targetActor.GetType().GetProperty(_targetName);
                _targetActor = targetActor;

                MethodInfo setter = targetProperty.GetSetMethod();
                System.Diagnostics.Debug.Assert(setter != null);
                _propertySetter = (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), targetActor, setter);
            }
            System.Diagnostics.Debug.Assert(_targetActor == targetActor);
            System.Diagnostics.Debug.Assert(_propertySetter != null);
            _propertySetter(_targetValue);
        }

It’s not as easy to read as the version using SetValue, but it doesn’t produce any garbage. For a function that will be called multiple times a frame, it’s totally worth it.

Enjoying the Fruits of my Labor
With my code changes in place, I fire up CLRProfiler again to make sure I get the expected effect. The GC Timeline ends up looking something like this.

There we go! A few GCs occurring when the game starts up, but once we get to the Title screen: nothing. Just a flat plane of constant memory use. My garbage collection problems are solved! At least in this part of the game.