Building a Better User Experience - Games

Excellent Free Sound Effects Resource

Keith Rome — Thu, 19 Jun 2008 18:17:48 GMT

I ran across SoundSnap today – what a great resource for finding free sound effects and music loops. For those participating in the GGMUG Silverlight Game Development Contest, this might come in handy for you, so please check it out!

http://www.soundsnap.com/

By the way, the GGMUG is a great venue to meet new people who are passionate about .NET development. If you live on the East side of town, and just can’t make it to those Alpharetta meetings held by the other user groups, then please check this new group out if you haven’t already.

A Simple Sound Effects Engine for Silverlight 2

Keith Rome — Mon, 09 Jun 2008 21:59:22 GMT

Audio support is all too often one of the last things a developer thinks of when it comes to building a user interface. Fortunately, Silverlight offers some basic building blocks that make it fairly trivial to add event-driven sounds to our applications. I have taken the built-in functionality one step further, and created a simple run-time audio engine that makes it even easier.

First, I will discuss the requirements that I had in mind when I created this engine. Second, I will discuss the ideal API for a complete solution. Third, I submit the simple effects engine that I developed in order to meet those requirements and API.

Sound Effects Engine Requirements

Must be able to play looping “background music” tracks.
Must be able to play smaller sound effects on demand.
Must support concurrent (and overlapping) sounds effects without interfering with already-playing audio.
Must adequately handle the possibility of download delays when pulling down external audio files.
Should cache audio files between playbacks.
Should allow serving of audio from high-bandwidth CDN such as Silverlight Streaming.

An Ideal Sound Effects API

Should be very approachable. If possible, only a single line of code to play any audio (similar to PlaySound() API).
Should support any formats supported by Silverlight.
Should be efficient.
Should offer download and playback completion callbacks (for chaining and synchronization).
Should support aggressive background pre-caching of audio files.

The SilverlightToolbox Solution

To address the simplicity requirements, this sound effects engine is implemented as a single static C# class that can be easily included into any Silverlight project. It can exist in a referenced class library, or can be linked directly into the main project.

To address looping background music, a single method SetBackgroundLoop() is supplied. This will begin playback of a single audio clip, and will automatically repeat it. Only one track can be played as the background loop – calling this method again will terminate the running track and start the new one. You can also pass String.Empty to stop all background music.

To address typical sound effect clips. two overloads of the PlaySoundEffect() method are supplied. The simpler of the two methods will simply play a clip once it has been downloaded. The extended version allows you to specify a callback for when the clip has been downloaded and started playing, and a second callback that can be used for notification that the clip has ended.

To address the scenario where multiple sound effects might be played at the same time, the engine internally maintains a queue of MediaElements. When a new sound needs to played, it pulls an unused element and puts it into service. Once the sound is finished, the element is returned to the queue. This allows Silverlight itself to handle media mixing, and by caching those MediaElements, it does so without placing undue stress on the environment.

To address the issue of download delays, the startedCallback and completedCallback parameters of PlaySoundEffect() were introduced.

To address caching of audio files, a WebClient is used (which in turn leverages the browser’s cache). Furthermore, the engine will reuse any downloaded file streams (and is smart enough to not re-queue the same file if it already queued for download).

By using a MediaElement for playback, audio tracks are automatically supported from streaming sources and Content Delivery Networks, and can be of any type supported by Silverlight.

To support chaining of audio effects, and to support synchronization of UI with audio, the PlaySoundEffect() method accepts callback events that are fired when the clip has been downloaded, and again when it has completed playback. To further help with UI synchronization, a second utility class is provided (DelayedAction) which provides a simple wrapper for BackgroundWorker that can be used to easily delay execution of a block of code after a specified amount of time.

To support pre-caching of audio files, the PreloadMedia() method can be used.

Typical usage:

In order for the sound effects engine to function properly, it must be provided with a top-level XAML container (MediaElement currently will not perform playback without a parent object). This is done by calling the Initialize() method, typically from your program’s startup code:

SoundEffects.Initialize(this.LayoutRoot);

After this has been done, background music can be played, and we can also queue up some sound effect clips for later:

SoundEffects.SetBackgroundLoop("cautious-path.wma");
SoundEffects.PreloadMedia("pop1.wma");

Then, at various points throughout the application, we can play the sound effect (for example, in response to a control event):

SoundEffects.PlaySoundEffect("pop1.wma");

If at any point we need to delay the sound effect slightly, we can control this be introducing a short delay:

DelayedAction.Execute(2.0, () => SoundEffects.PlaySoundEffect("pop1.wma"));

Complete Source Code for DelayedAction.cs:

using System;
using System.ComponentModel;
using System.Threading;
  
namespace Wintellect.SilverlightToolbox
{
public class DelayedAction
{
class DelayedCallback
{
public TimeSpan
Delay { get; set; }
public Action
Callback { get; set; }
}
  
public static void Execute(double seconds,
Action callback)
{
BackgroundWorker
Delay = new BackgroundWorker();
Delay.DoWork
+= (s, e) =>
{
DelayedCallback
DelayCallback = (DelayedCallback)e.Argument;
Thread.Sleep(DelayCallback.Delay);
e.Result
= DelayCallback.Callback;
};
Delay.RunWorkerCompleted
+= (s, e) =>
{
Action
Callback = e.Result as Action;
Callback();
};
Delay.RunWorkerAsync(new DelayedCallback
{
Delay
= TimeSpan.FromSeconds(seconds),
Callback
= callback
});
}
}
}

Complete Source Code for SoundEffects.cs:

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
  
namespace Wintellect.SilverlightToolbox
{
public static class SoundEffects
{
static Panel
Root;
static MediaElement
BackgroundLoop = new MediaElement();
static WebClient
EffectDownloader = new WebClient();
  
static Queue<MediaElement>
AvailableSoundEffectGenerators = new Queue<MediaElement>();
static Dictionary<string,
Stream> DownloadedEffects = new Dictionary<string,
Stream>();
static Queue<string>
PendingDownloads = new Queue<string>();
static Queue<QueuedEffect>
PendingEffects = new Queue<QueuedEffect>();
static Dictionary<MediaElement,
Action> PendingStartupCallbacks = new Dictionary<MediaElement,
Action>();
static Dictionary<MediaElement,
Action> PendingCompletionCallbacks = new Dictionary<MediaElement,
Action>();
  
enum TargetType
{
BackgroundMusic,
SoundEffect,
}
  
class QueuedEffect
{
public string MediaName
{ get; set; }
public TargetType
Target { get; set; }
public Action
StartedCallback { get; set; }
public Action
CompletedCallback { get; set; }
}
  
public static void Initialize(Panel
root)
{
Root
= root;
InitializeTarget(root,
BackgroundLoop);
EffectDownloader.OpenReadCompleted
+= (s, e) =>
{
DownloadedEffects[(string)e.UserState]
= e.Result;
DownloadEffects();
PlayEffect();
};
}
  
static void DownloadEffects()
{
if (PendingDownloads.Count
== 0)
return;
string MediaName
= PendingDownloads.Dequeue();
EffectDownloader.OpenReadAsync(new Uri(MediaName,
UriKind.Relative), MediaName);
}
  
static void InitializeTarget(Panel
root, MediaElement target)
{
target.Width
= 0;
target.Height
= 0;
target.Visibility
= Visibility.Collapsed;
root.Children.Add(target);
target.AutoPlay
= false;
target.MediaOpened
+= (s, e) =>
{
MediaElement
Target = s as MediaElement;
Target.Volume
= 0.35;
Target.Play();
if (PendingStartupCallbacks.ContainsKey(Target))
{
Target.Dispatcher.BeginInvoke(PendingStartupCallbacks[Target]);
PendingStartupCallbacks.Remove(Target);
}
};
target.MediaEnded
+= (s, e) =>
{
MediaElement
Target = s as MediaElement;
Target.Stop();
if (s
== BackgroundLoop)
Target.Play();
else
AvailableSoundEffectGenerators.Enqueue(Target);
  
if (PendingCompletionCallbacks.ContainsKey(Target))
{
Target.Dispatcher.BeginInvoke(PendingCompletionCallbacks[Target]);
PendingCompletionCallbacks.Remove(Target);
}
};
}
  
static MediaElement
GetUnusedEffectGenerator()
{
if (AvailableSoundEffectGenerators.Count
> 0)
return AvailableSoundEffectGenerators.Dequeue();
else
{
MediaElement
Result = new MediaElement();
InitializeTarget(Root,
Result);
return Result;
}
}
  
static void PlayEffect()
{
lock (PendingEffects)
{
if (PendingEffects.Count
== 0)
return;
QueuedEffect
Effect = PendingEffects.Dequeue();
if (DownloadedEffects.ContainsKey(Effect.MediaName))
{
MediaElement
TargetElement = null;
switch (Effect.Target)
{
case TargetType.BackgroundMusic:
{
TargetElement = BackgroundLoop; break; }
case TargetType.SoundEffect:
{
TargetElement = GetUnusedEffectGenerator(); break;
}
}
if (Effect.StartedCallback
!= null)
PendingStartupCallbacks.Add(TargetElement,
Effect.StartedCallback);
if (Effect.CompletedCallback
!= null)
PendingCompletionCallbacks.Add(TargetElement,
Effect.CompletedCallback);
TargetElement.SetSource(DownloadedEffects[Effect.MediaName]);
}
else
{
PendingEffects.Enqueue(Effect);
}
}
}
  
static void PlaySound(TargetType
target, string mediaName, Action startedCallback,
Action completedCallback)
{
if (target
== TargetType.BackgroundMusic)
if (BackgroundLoop.CurrentState
!= MediaElementState.Stopped)
BackgroundLoop.Stop();
  
if (mediaName
!= String.Empty)
{
lock (PendingEffects)
{
if (!DownloadedEffects.ContainsKey(mediaName))
{
PendingDownloads.Enqueue(mediaName);
}
PendingEffects.Enqueue(new QueuedEffect
{
MediaName
= mediaName,
Target
= target,
StartedCallback
= startedCallback,
CompletedCallback
= completedCallback
});
}
DownloadEffects();
PlayEffect();
}
}
  
public static void SetBackgroundLoop(string mediaName)
{
PlaySound(TargetType.BackgroundMusic,
mediaName, null, null);
}
  
public static void PlaySoundEffect(string effectName)
{
PlaySound(TargetType.SoundEffect,
effectName, null, null);
}
  
public static void PlaySoundEffect(string effectName,
Action startedCallback, Action completedCallback)
{
PlaySound(TargetType.SoundEffect,
effectName, startedCallback, completedCallback);
}
  
public static void PreloadMedia(string mediaName)
{
if (!DownloadedEffects.ContainsKey(mediaName))
{
PendingDownloads.Enqueue(mediaName);
DownloadEffects();
}
}
}
}

Gem Blaster entered into "RIA Run" contest

Keith Rome — Sun, 01 Jun 2008 05:30:38 GMT

As a follow-up to the previous post, I have entered Gem Blaster into a game development contest held by the Microsoft RIA Development Center Portal web site. I am happy to say that it has made it into the Finalists group of 6 games that are being showcased for the next few weeks on the RIA web site:

http://www.devx.com/RIA/Door/37728

The final judging is done based on popularity among visitors there. They basically track number of visits to each game, as well as how long people stay there, whether they come back and revisit, etc. So if you like it, please pass the link around to your friends and ask them to check it out too.

Gem Blaster updated and enhanced for Silverlight 2

Keith Rome — Tue, 13 May 2008 21:37:56 GMT

I finally got around to updating my Gem Blaster game from Silverlight 1.1 alpha to the 2.0 beta bits. Since there were very heavy changes to the control model and other aspects of the managed runtime, I had to rewrite a lot of the original code (this was fully expected by the way). While I was in there, I also took the opportunity to add a number of other new features such as a simple sound FX engine, a self-playing "demo mode", and a bunch of other improvements.

I intend to update CodePlex soon with the new source code, but for now you can try out the game here (embedded below). It is hosted on the Silverlight Streaming service, so feel free to pass the link around (it won't kill *my* servers). If you like, you can also directly embed the game using the following embeddable HTML snippet:

<iframe 
    src="http://silverlight.services.live.com/invoke/5683/GemBlasterV2/iframe.html" scrolling="no" frameborder="0" style="width:800px;
height:625px"> </iframe>

Now that this project has been updated for Silverlight 2, I can move on to my next game project idea which (I am hoping) should really push the runtime to its limits :)

Source Code for Gem Blaster finally published to CodePlex

Keith Rome — Thu, 31 Jan 2008 05:00:56 GMT

Last fall I showed off a new game that I had built using Silverlight 1.1 at a few User Group meetings across the southeast. I showed the internal "guts" of the puzzle game, and I think people generally thought it was a really cool project. I promised that I would make the code available, but never actually got around to publishing it.

Until tonight.

Gem Blaster is now (finally!) published to CodePlex at http://www.codeplex.com/gemblaster

Full source code is available there.

Also, if you just want to play the game (after all, it IS a game, and somewhat addictive too), I have a "live demo" posted to the Wintellect server here: http://demo.wintellect.com/gemblaster/default.html

Enjoy!

The Atlanta .NET Doubleheader: Visual Studio 2008 Loadfest and XBox Gaming Night

Keith Rome — Sat, 01 Dec 2007 04:59:37 GMT

This coming Monday night would normally be our monthly Atlanta MS Pros / Atlanta Cutting Edge .NET / Atlanta VB.NET user group meeting, but this month we have a special treat lined up...

Microsoft (aka Doug Turnure) will be providing a FREE copy of Visual Studio 2008 (Professional Edition) to the first 150 people that arrive. This is a GREAT way to get an upgrade right away without having to convince your boss to buy a license! Well, technically we will be giving out DVDs with the trial version, but as soon as the Retail Packages are ready, each person that gets a Trial copy on Monday will receive a full Retail Boxed copy.

So bring your laptop. Most folks will be loading it up right there, so you might as well join in and get your upgrade on.

And then, after the LoadFestivities, everyone will be welcome to come join in some XBOX fun... we have 9 (yes, NINE) xbox 360 consoles and 9 matching big-screen TV's, so there should be plenty of room for everyone to have a good time. The name of the game is Halo3, so put on your MJOLNIR armor and get ready to frag your buddies! And if John-117 is too intense for you, we will also have Guitar Hero cranking on some of the consoles... so you can come and rock out to some Hit Me With Your Best Shot on Easy.

I hear the Master Chief himself might be there to take on challengers!

Please register in advance, so that we can have an accurate count of attendees. The registration link is here.

Location:

Microsoft Corporation [Alpharetta]
1125 Sanctuary Pkwy.
Suite 300
Atlanta, GA 30004

See you there!

Everquest 2!

Keith Rome — Sat, 04 Sep 2004 21:19:59 GMT

Yes I am an Everquest junkie, I admit it. But this new game Everquest II which is the sequel is due out soon. Yesterday the beta process opened up a few more spots and I was finally able to start playing it (in an albeit unfinished form). The graphical detail is superb, the content seems very deep, and the player controls are well done (I adapted from my EQ1 keyboard layout very quickly). Even on my relatively weak machine (non-HT p4 1.5G with less than 1G memory and a GeForce FX5700u), the game was certainly playable with default settings. I intend to build a new system before release though (scheduled for mid november).

I am really looking forward to this game, and it might finally be the one that draws me away from EQ1 after these last 4 years...