WAM Games

Retrofit:Overload goes live – some press reactions

Will — Tue, 11 May 2010 19:22:22 +0000

Retrofit:Overload is now available for the Xbox 360! you can download it to your Xbox here

We have had some favourable reviews and comments from the gaming press, here are a few links to get you going.

Gamerbytes - “What if Namco’s Galaga Legions was actually more like Galaga? It would have probably turned out like this.”

Gamingtruth – “The great thing about Retrofit: Overload is that you can overload yourself or a friend with all the retroness this game has to offer.”

WastedSeconds – “It doesn’t try to reinvent the wheel, it just works and it works damn well.”

Xblaratings – “This mechanic is genius.”

Xboxhornet - “All your arcade favourites meshed into one!”

Gamasutra – “Xbox Live Indie Games – Ten Titles for 2010″

SFX-360 – “it’s Galaga on steroids!”

Gaygamer – “…the long lost arcade game that would have stolen all of your lunch money.”

Xnplay - “…it’s really, really good.”

XboxIndieGames – “Retrofit – Overload is a nigh-on perfect distillation of the fixed-screen vertical shmup”

The game is available on Xbox Live Indie Games and you can download the trial version directly to your Xbox from here free of charge. If you like it, the full version costs just 80 Microsoft Points! Enjoy

Are there enough explosions in this ?

Will — Wed, 28 Apr 2010 19:57:34 +0000

Updated Retrofit gameplay including ramped difficulty, new enemies, more mayhem and a few more explosions

Curing the Clicks – Release Curves in XACT

Martin — Thu, 22 Apr 2010 18:23:21 +0000

Once I’d worked out that the clicking noises I was getting in Retrofit:Overload were not clipping but were caused by stopping the sounds, I expected it to be easy to fix in XACT. It was, really, but only after some puzzling over the MSDN docs and a false start or two.

To save others similar confusion, here’s a step by step guide to adding a release curve to a sound in XACT…

In XACT, create a new RPC Preset. This brings up the RPC editor.
Set Variable to ReleaseTime.
Set Object to Track 1.
Set Parameter to Volume.
Now draw your release curve. To just prevent clicks, rather than create an audible fade out, it can be really short. I used half a second but it could probably be shorter. So at time 0 Volume is 0dB, and at 0.5 seconds Volume is -96dB.
Give your RPC an informative name, E.g. “ReleaseRPC”.
Now find the relevant sounds (not cues) in your Sound Bank and attach the RPC. (For single sounds you can do this on the sound’s right-click menu. Alternatively you can drag sounds onto your RPC entry in the project tree and this works with multiple sounds at once.)
Thats it for XACT. Save your project

To use the release when the sound is stopped, it must be stopped “as authored”.

With XNA: cue.Stop(AudioStopOptions.AsAuthored);
With DirectX: cue->Stop(0);

There’s no need to create a new XACT Variable to drive the RPC. The ReleaseTime variable is automatically available on each playing cue.

The MSDN entry on XACT envelope parameters has much more to say about this. It does actually make sense if you don’t let the jargon distract you.

SVG in XNA

Martin — Wed, 14 Apr 2010 10:41:31 +0000

Scalable Vector Graphics (SVG) seemed an ideal format for authoring the enemy paths in Retrofit: Overload but it turned out to be much harder to parse than it appeared at first sight. Fortunately the open-source SVG Rendering Engine works very nicely for reading SVG files in our content pipeline. Here’s how we use it:

Although library source code is available, it’s sufficient to add the Svg.dll to the content importer project’s References. This makes the Svg namespace available. We also need references to System.Drawing and System.Xml.

Here’s some fairly standard preamble:

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

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content.Pipeline;

using Svg;
using System.Drawing.Drawing2D;

// Alias our output type -- A dictionary mapping a path name to a list of 
// control points.
using PathDict = System.Collections.Generic.Dictionary<string,
    System.Collections.Generic.List>;

// The Svg library uses this matrix type not the XNA one:
using Matrix = System.Drawing.Drawing2D.Matrix;

namespace ContentPipeline {

    [ContentImporter(".svg", DisplayName = "SVG Path Importer")]
    public class SvgPathImporter : ContentImporter {

        // (I like to stash the filename at the start of my content
        // importers to make it easier to generate useful error messages in
        // nested calls.)
        string filename;

        public override PathDict Import(
                string filename,
                ContentImporterContext context) {

            this.filename = filename;

Now for the interesting stuff. Opening and parsing the SVG file is as simple as a single function call:

            SvgDocument doc = SvgDocument.Open(filename);

Now we scan for path nodes and pull out the data. The collectPaths() function is defined later on.

            var paths = new PathDict();
            collectPaths(ref paths, doc);
            return paths;
        }

We’re only going to consider Bézier curves. Here’s how we test for them:

        static bool isBezier(SvgPath path) {
            // All but the first point must be type '3'
            const int bezierPointId = 3;
            return path.Path.PathTypes.Skip(1).All(t => t == bezierPointId);
        }

SVG nodes may have multiple associated transforms. (This is one of the things that makes it impractical to throw together a quick parser for this stuff — There are many ways of representing transformations in SVG, and unless you know that your editor won’t use them, even the simplest SVG data is affected by them.) Fortunately SVGRE parses these for us and stores them with each node. The parsed points are stored untransformed though, so we need to accumulate the node’s transforms and apply them ourselves. Here’s a function to calculate the overall transform that applies to a node.

        static Matrix getTransform(SvgElement node) {
            var m = new Matrix();
            while (node != null) {
                if (node.Transforms != null && node.Transforms.Count > 0) {
                    var temp = new Matrix();
                    foreach (var trans in node.Transforms) {
                        temp.Multiply(trans.Matrix, MatrixOrder.Prepend);
                    }
                    m.Multiply(temp, MatrixOrder.Append);
                }
                node = node.Parent;
            }
            return m;
        }

We traverse the tree of SvgElement nodes recursively. If a node is of type SvgPath, and is a Bézier curve, then we process it and add it to our dictionary.

        void collectPaths(ref PathDict paths, SvgElement e) {
            SvgPath path = e as SvgPath;
            if (path != null) {
                if (!isBezier(path)) {
                    // Complain about any non-Bezier curves
                    // so we can fix them in the editor.
                    throw new InvalidContentException(
                        String.Format("Cubic Beziers only: {0}", path.ID),
                        new ContentIdentity(filename));
                }
                // Transform points in-place.
                var pts = path.Path.PathPoints;
                getTransform(e).TransformPoints(pts);
                // Convert to Vector2.
                var vpts = pts.Select(p => new Vector2(p.X, p.Y)).ToList();
                paths.Add(path.ID, vpts);
            }

            foreach (var child in e.Children) {
                 collectPaths(ref paths, child);
            }
        }

    }
}

That’s it. To load the path data in-game we use:

var paths = Content.Loadstring, List>>("test");

Here’s the code in one handy chunk.

The same approach can be used to extract other SVG data. In fact in the Retrofit:Overload importer we look for a screen rectangle too and offset the paths relative to that.

The main disadvantage of SVG Rendering Engine is the lack of documentation, however it is possible to work out quite a lot by loading a simple file and browsing the object structure in the debugger.

You can find the game on the Xbox Dashboard (Game Marketplace -> Indie Games) or schedule a download via the web.

retrofit:overload

Will — Mon, 12 Apr 2010 21:35:39 +0000

Now with moving parts !

Zone out with retrofit:overload

Will — Thu, 01 Apr 2010 12:16:03 +0000

retrofit:overload is coming soon to Xbox Live Indie games. (Well, soon-ish, when it’s ready etc.)

An arcade mash-up of some of our favourite old school cabinet games with some added funk
The concept is this: Take some heritage arcade action, mix up the bits that you like, ditch the bits don’t like, speed it up, add more weapons and shield deflectors. The goal was to draw from retro heritage but not copy it, to try to recapture the essence of what those games were all about and add some special sauce to get you in the zone.

Why? Because it’s full of win and you can zone out to it in a big way.

When? All going well, it should be out in April sometime on Xbox Live marketplace.

Video soon.

New Xbox Live puzzle games group comes to Facebook

Will — Fri, 19 Mar 2010 10:34:03 +0000

It’s been a while since we’ve done anything for Xbox Live Indie Games (Xblig), but that’s all about to change. We have a new title ready to go out this month and will be posting more details here next week.

Catching up with the Xblig news and blogs, it seems the channel has grown a lot since we last hung out there, and one of it’s chief supporters, Xboxhornet and his crew, have put together a cool Facebook page covering news and reviews of all the puzzle games available on the channel.

Definitely worth a look if you want to keep abreast of current and upcoming puzzlers.

http://bit.ly/bcsozD

Rola Trooper – Tyrant enemy forces #1

Will — Thu, 25 Feb 2010 21:10:54 +0000

A quick update to show how the Tyrant army is shaping up, ranging from the small but nippy Patrola to the slow but powerful Tankmega. All the vehicles have ball wheels and are 360 degree motion capable with no nasty turning circles to slow down the action !

Rola Trooper is on the way!

Will — Fri, 22 Jan 2010 17:50:32 +0000

We finally made it! After several months of hard work and sleepless nights we’re so very proud to announce our new game in development, Rola Trooper.

A twin stick action shooter set in full physics based 3D environments, Rola Trooper is our experiment with mixing arcade shmup action with semi realistic environments and a real physics system, let us know what you think!

No release date or pricing info as yet.

More info on the Rola Trooper main page here>

Rola Trooper

Will — Fri, 22 Jan 2010 16:26:20 +0000

Rola Trooper is an arcade action shooter set in full physics based 3D environments, it’s our experiment with mixing arcade shmup action with semi realistic environments and a real physics system.

In order to introduce a lot of speed into the gameplay, we’ve come up with our new “Rola Tech” motion system, All the characters ride around on Rola ball feet providing super fluid character motion, so it plays like a fast 2D shooter, but with real physics, explosions, 3d environments and destructible scenery.

The Story

Rola Trooper has been betrayed, the 3 remaining members of his old fireteam are incarcerated at various locations around the Tyrant Prison Network and guess what? It’s your job to locate and free them.

With a variety of weapons at your disposal, you must guide Rola through the Tyrant Network, dispatching hordes of robot enemies on your way. Rescue your buddies and stop the evil Tyrant from escaping the system.

The game is still in development so the posted screenshots are works in progress, we’ll keep you up to date with regular posts about how the project is going and post new screenies of the current state of development. Please follow along and let us know what you think. Got a suggestion? We’d love to hear from you!