Music and sound design for the 60-second trailer of the racing game Space Racerz. It makes little sense without the video of gameplay footage, but still conveys the scifi arcade flavor of the game.

Although the iPhone audio playback mechanism is native, it doesn’t require a plugin from Unity, so it ought to work with Unity iPhone Basic (although I believe plugins are expected to be available for free once 3 is out of beta). Anyway, some of that code originally came from the awesome power that is Jeff Murray at Psychic Parrot Games (http://psychicparrotgames.com/) who in turn was inspired (I think) by a tutorial from the amazing guys at Blurst (http://blurst.com).

I updated the objective-c and added a bunch of things, so obviously anything that breaks is my fault, not theirs.

Here’s a zip archive containing the source files and documentation. After you extract it, open the index.html file in the docs directory for all the details.

It’s free for any kind of use you like, commercial or otherwise, and you can make any changes to it that you desire (standard BSD license, to be specific).

MusicLoader_Unity.zip

This is a commercial background bed which is looped here rather than faded. Written for a car commercial (production house work).

For getting music into indie games, consider submitting to licensing agencies, if you haven’t already. Many indie devs prefer to purchase non-exclusive music from stock or production libraries instead of having adaptive music custom-crafted (as a budget issue). You won’t make much money that way, and the audio isn’t as effective in the game itself (since it’s limited to loops and underscore), but it will garner some credits, and often the production folks can steer your music in a very helpful direction since they hear so much of what’s out there and know what clients need. Make sure to use libraries that do not require exclusivity.

Sound Design and Voiceovers

Consider adding sound design and voiceover work to your offering. It’s tough to attract indies doing music only, especially for non-orchestral music (your electronic, rock and pop competition in licensing agencies can be very strong and very inexpensive). If you become skilled at custom sound design — meaning you have some foley and field recording ability as well as the best libraries for layering together modified effects — then you become more attractive to small teams that need people to fill multiple roles. Sound design is its own unique discipline as well, and you may find that you’re even more drawn to it than you are to composition. It’s hard to explain why, but doing foley work is incredibly fun and fulfilling.

Middleware and Code

Consider learning the basics of audio middleware like FMOD and/or wWise — and further, learn a bit of coding, at least in a simple scripting language. It’s important to understand how sound and audio is scheduled and modified in real-time by game engines, and if you can put that together yourself for a game project, then that implementation becomes an extension of your composition and feeds into the overall soundscape. Indie gamers are just waking up to the possibility of practical interactive audio, but even when interactive audio is not called for on a title, you should be able to make your music and sound files very tiny without losing too much quality and be able to get it into the game code for multiple platforms, plus be able to perform effective pitch, volume, EQ, and potentially other DSP effects in realtime to create multiple meaningful sounds from the same sources without necessarily relying on a non-audio programmer to manage it.

Don’t Condescend

This one is a frequent pet peeve of many developers and producers: Don’t sound like a film composer or DJ/producer who is only posting once to a couple of game forums because you think breaking into games will be easier than directly applying for the job you secretly really desire — John Williams’ job on the next Harry Potter score. If you don’t want to write music and create sound specifically for games, then you won’t be able to fake it for very long. It’s a discipline and art of its own, not a springboard to other sorts of audio work. In fact, plenty of film composers these days aspire to write for games (and find very tough competition, as AAA titles boast superstar composers in their own right). Although I realize that scoring cut scenes is linear and that process is close to scoring a film short, otherwise the two mediums differ in important creative ways, not just technical process ways.

Ship Something

Finally, the single most important thing to be able to show folks in the business is your credit on a shipped title, as it is the final say in whether you can really work on and communicate with a successful team under deadline and budget constraints, iterating on your sound and music through bug databases, source control systems, and under processes such as Scrum. If you don’t have this shipped title yet, then consider writing and shipping your own game when you have downtime. There are plenty of game engines, starter packs, art packs, etc., that enable non-programmers to put together a game. Even if you do not have a unique mechanic or aesthetic based on such starter assets, it can be a good showcase of your sound design and music work in a finished, shipped title.

Hope some of this is of help for fellow audio folks — best of luck!

It’s also subtly disconcerting to have a single sound — an explosion, for example — with the exact same waveform representing both local and remote audio, even though that is realistic; that is, it’s often more effective to diverge from realism in some cases, and employ different filters and even sometimes different waveforms altogether. I won’t argue for this statement intellectually, but we can trust our ears to tell us when it is true.

Unity3D, the engine of choice for many indie devs these days, is an example of a great tool that still does not surface these kinds of audio API’s (although as of version 2.6 it does include FMOD, those API’s are not yet exposed through Unity). And even packages such as UDK, which boast powerful audio features, lack a sound propagation engine.

Bad Local Player Gun

For example, here’s a weak, watered-down effect produced by a single sound used to represent a large mortar round firing when it is imported in Unity to be placed in 3D space:

Good Local Player Gun

We want that sound for the local player to be a lot more powerful and there’s no need for it to be directed in 3D space or filtered through a rolloff, since the camera (which is the primary audio listener in most games) is right on top of the local player.

Here’s what it sounds like after adjusting the implementation but not changing the actual audio file at all:

Eliminating the unneeded 3D effects and applying some volume, pitch and EQ changes in the engine make it full omnipresent stereo for the local player who fired the gun, and didn’t require modifying the actual audio file itself.

Remote Players

When that same gunshot is heard by a remote player who is in the same game as the player who fires that gun, we want the remote player to hear more bass and less treble in the sound, because of the difference in the way lower frequencies travel compared to higher frequencies — just as you hear the thumping bass and kick drum from a radio when a car passes but can’t hear the hi-hats or a female vocal. Using the previous example sound, the remote player should not hear the gun clip sound at the end of the shot. This is not a master volume thing, it’s an EQ thing, and if the audio engine can’t do that well, then you need a separate file to represent it even though it is the same logical sound caused by the same object and action in the game.

For example, at a distance of 50 meters and rotated away from the gun source, you might want the remote player to hear this gunfire like this:

It is still the same sound source, and the produced sound is still stereo, but there is no clip sound, there is less treble, the sound has been EQ’d to carve out a space in the frequency range which doesn’t muddle the more important local sounds this player is causing, etc. It also still leverages the game’s audio engine — the engine is placing it to the left (at about 9 o’clock) in 3D space and applying a rolloff factor as well as slightly varying the pitch.

Technical Strategy

This is a fairly simple solution that works even in the absence of powerful audio engines:

Set up multiple audio assets with varied characteristics and use them in combination with the engine’s audio features to represent one single logical sound. In Unity, for example, this can be accomplished by scripting a wrapper AudioClip replacement that includes an internal array of source audio clip pairs, with each member of that pair containing different stereo/mono and 3D/omnipresent settings — one for the local player and one for the remote players to hear when the audio is played. The remote clip can be the same physical audio file as the local player if that makes sense (though again, sometimes it is better to diverge from reality here), but with different asset import settings applied.

This wrapper object should also contain some variable to represent ideal distance at which the individual sound files can be played, so that the implementation code can quickly iterate through the source to find the correct clip pair. It would then select which clip in a pair to play based on whether the current player is the local source of the sound or whether the sound was generated by a remote player. Code summary: (1) Find which audio pairs are best for a given distance, and (2) choose one member of the pair based on whether the sound was originated locally or remotely.

Of course, the audio engine will place the ‘remote’ member of the audio pair into 3D space and your distance variable is not used for that purpose (it is used only to select the proper audio pair, not actually to apply distance). But again, unless the engine exposes strong audio API’s, that placement needs to be coupled with filtering you apply either (a) through the game’s audio engine import settings and tools, even if the sound source is the same single file, to generate a second asset; or (b) externally and bounced into a new version of the file itself, if the game engine lacks that sort of audio support. This is the reason for this remote member of the audio pair.

If you have two different physical files for a single pair — one for the local and one for all remote players — then it’s quite likely that the local pairs at long distances will apply distance effects in the file itself, while the remote versions need to be much louder and apply no external distance effect, only EQ and the like, because the game engine will push the sound into space appropriately.

Finally, the sound is filtered by the local game engine — in Unity this currently means pitch and volume and rolloff factors, while in other engines EQ and other DSP effects such as reverb, distortion, gates, etc. can also be applied in real-time. These effects work in conjunction — not in conflict — with this general implementation approach.

Unity-Specific Tip

In Unity v2.6, I find it best to employ non-3D stereo sounds when the local player is the cause of big BOOM sounds, like cannons and explosions, while the exact same logical sound results in playing a different sound imported as a 3D sound (either mono or stereo, based on what sounds correct) for remote players. This is not realistic, but players expect immediate feedback and they expect to have massive effect — they are less demanding when it comes to the effects caused by other players.

Final Words

As a final example, here’s an explosion heard by the local player:

Here is that same explosion sound as heard from a much greater distance by a remote player in the same multiplayer game, at a distance directed in 3D space by the game engine, after import settings were tweaked to generate a new asset with very different EQ applied:

A final word on this approach:

Combining multiple audio files with the proper code settings takes a great deal of tweaking and listening, as it’s a combination of programming and music production, which is most efficiently performed if the sound designer and audio engineer are sitting side-by-side (or if they are the same person).

Main theme from Reign of Steel, the Facebook multiplayer tank game, for which I created music, sound design, and performed audio programming. Check out: http://www.reignofsteel.net

Montage of various cues from the film Hank and Maggie. Cues range from a cheesy 80′s pop song to typical romantic comedy underscore to battle music to suspense to an over-the-top crazy choir climax. That’s what happens when your boyfriend turns out to be a ninja and your best friend turns out to be a Russian spy.

This theme elaborates on a short 30-second loop written for a military shooter game.

Here’s a medley containing a few separate themes I wrote for a soon-to-be-released project — more frenetic action, though I personally most enjoyed working on the slower harp, cello, violin and synth three-part counterpoint piece which starts at 1:25 in this cut.

Short underscore for a strategy game prototype that involves coordinating a team of modern-day burglars through a heist. David Holmes-influenced.