Building XNA 2.0 Games- P9 pdf

To look at it from the application end of things, we’ll be telling our audio engine to play a cue, which will play a sound, which will play its tracks, which will fire their events, whic

Figure 8-11 The reverb after removing the peaking part

For some final cleanup, we quiet the duplicate track a little by selecting Effect ➤ Amplify and entering a negative value of –5, clip off the remaining 5 seconds of silence, and apply a Cross Fade Out to the trailing bit Figure 8-12 shows the final 50-cal sound for our game

Figure 8-12 50-cal: the final product

This should give you an idea of the basic functions that you can accomplish with Audacity and a good idea of how to collect and process audio It will become more important to under-stand the workflow of creating a piece of audio as you develop your own games

In summary, the important audio we ended up with is as follows:

• Gunshot

• Hit

• An assortment of crunching and splatter sounds

We’ll use the crunches and splatters to add some flavor to our combat audio Save all of the

audio files as wav files in ZombieSmashers\Content\sfx Now let’s get all of this set up in XACT!

Adding Audio to the Game

With our audio files ready, we can now add sounds to the game As you saw in Chapter 2, we

use XACT for this task

XACT organizes sound in a hierarchical manner You don’t need to be intimately familiar

with the layout, but it helps to have a vague idea of what’s going on:

• Waves are raw audio A wave bank is a collection of wave (.wav) files that could be used

in a game

• Sounds are composed of tracks that play simultaneously Tracks contain events Events

can, among other things, play waves A sound bank is the use of files in the wave bank

and can apply certain properties to sound files

• Cues play sounds Cues are what you tell your audio engine to play from within your

game Cues have their own properties that can be applied to sounds

To look at it from the application end of things, we’ll be telling our audio engine to play a

cue, which will play a sound, which will play its tracks, which will fire their events, which will

play waves.

There’s going to be a bit of déjà vu at work here (XNAPong, anyone?), but we’ll still hit all

of the steps, and in less of a rush this time Let’s get started by setting up our XACT project

Setting Up the Game Audio in XACT

Fire up XACT From the Start Menu, you can find XACT in Microsoft XNA Game Studio 2.0 ➤

Tools Once XACT is up and running, select File ➤ New Project, navigate to your

ZombieSmashers\Content\sfx folder, and save the new project as sfxproj, as shown in Figure 8-13

Next, right-click the Wave Banks item in the navigation pane on the left and select New

Wave Bank Name the new wave bank sfxwavs Then right-click the Sound Banks item, select

New Sound Bank, and name it sfxsnds XACT automatically gives us the following file paths:

• sfxproj.xgs is the XACT project file

• sfxwavs.xwb is the XACT wave bank file

• sfxsnds.xwb is the XACT sound bank file

Down the road, we’ll be loading these three files from ZombieSmashers, so it’s a good idea

to be vaguely familiar with what they’re called and what each represents

Start off by dragging all of the audio files into the wave bank They’ll show up in red italics,

meaning that they are not used in any cues, which we can now start to create

Figure 8-13 Creating a new XACT project

XACT has a shortcut in which you drag a wave from the Wave Bank window into the Cue panel of the Sound Bank window, and let XACT take care of the rest XACT will create a sound for the wave that has a track that contains the event play wave, as well as a cue that will play the sound we just created In other words, we can insert a wave file, drag it into the Cue panel of our Sound Bank window, and not worry about all the stuff happening in between This is what we did when we made XNAPong back in Chapter 2

We’re going to play around with this XACT hierarchy a bit more by making some variable zombie-smacking sounds We’ll create three hit variation sounds that are all called by one cue, which we’ll call zomhit

Drag hit from the Wave Bank window to the Cue panel in the Sound Bank window Now

we have a sound named hit and a cue named hit Rename the cue to zomhit Since we want three hit sounds, drag the hit wave into the Sound panel in the Sound Bank window twice (not creating a cue), and rename the three sounds in the Sound panel zomhit1, zomhit2, and zomhit3 Drag zomhit2 and zomhit3, one after another, from the Sound panel into the zomhit cue in the Cue panel Now we have one cue, zomhit, which will randomly play zomhit1, zomhit2, or zomhit3 when it is run

Right now, zomhit1, zomhit2, and zomhit3 play only the hit waves, so let’s add additional tracks to each sound In our project, we have three gooey mayhem sounds called crunch, crush,

and splatter Adding tracks to sounds is as an easy drag-and-drop operation Drag crunch to

zomhit1, crush to zomhit2, and splatter to zomhit3

We now have a single cue, zomhit, which will play three different sound variations Each

sound plays the hit sound and a different flavor of splatter Your XACT project should look like

the one shown in Figure 8-14

Figure 8-14 One cue, three variations

This looks nice enough, but how it sounds could be a very different story Fortunately, we

can listen to the sounds to hear how they will be in our game without actually putting them in

the game Let’s start testing and tweaking!

Auditioning Audio

Because XACT is set up to be cross-platform, audio auditioning is handled through a separate

program: the XACT Auditioning Utility You’ll find the XACT Auditioning Utility on the Start

menu, under Microsoft XNA Game Studio 2.0 ➤ Tools ➤ XACT Auditioning Utility Windows

may give you some trouble about firewalls at some point; allow the program through and let it

do its business

From XACT, select your zomhit cue and click the Play button The XACT Auditioning Utility

should subtly let you know it received a connection from XACT, as shown in Figure 8-15, and

the sound should play Try playing it a few times It will behave just as it will in the game, giving you a different variation each time.

Figure 8-15 XACT Auditioning Utility

When we did this, we discovered that the flavoring sounds we put in (crunches, crushes, and splatters) were sometimes overpowering the hit sounds We want the flavor sounds to be very subtle Fortunately, we can modify the volume on individual tracks

For each sound, select the track that plays the flavor sound (it will be Track 2), and in the Properties panel, adjust the volume, as shown in Figure 8-16 You can click the sound in the Sound panel and play it to get a feel for how it’s working Remember that sounds like this will

be played quite a bit, so we don’t want them to be abrasive or annoying

Figure 8-16 Modifying track volume

After tweaking, we ended up with only three cues for this iteration of sound project editing: zomhit, revol (for the revolver), and bullethit We created bullethit by combining hit and crunch, making it quieter than the zomhit variations The final Sound Bank window looks like Figure 8-17

Three cues is a good place to start Our next task is to integrate the sounds into the ZombieSmashersXna project We can always enrich our audio environment later

Figure 8-17 Our three cues

Bringing Sound into the Game

To bring audio functionality into Zombie Smashers XNA, we need to do three things:

• Add the XACT project to our Content project

• Create a class to load our XACT project and play cues

• Hard-code some cues to play at specific spots in our game

Let’s start by adding the XACT project In the Content project, with Show All Files enabled,

refresh Solution Explorer Then right-click sfx and choose Include in Project Do the same for

sfxproj.xap, which will automatically be given the proper Content Pipeline properties

Next, let’s create a class to play audio We’ll make all the members public and static so that

we can play sounds from anywhere We are going to be using a special feature of static portions

of a class: the static constructor The static constructor is never declared with a scope (such as

public or private) because it is automatically fired before any other static member or method

is used This bit of functionality in the language removes the dependency on creating a basic

initialize method and making sure it is called only once

private static AudioEngine engine;

private static SoundBank sound;

private static WaveBank wave;

static Sound()

{

engine = new AudioEngine(@"Content/sfx/sfxproj.xgs");

wave = new WaveBank(engine, @"Content/sfx/sfxwavs.xwb");

sound = new SoundBank(engine,

Now in Game1, we need to make sure that we don’t forget to keep the engine updated Failure

to do so will result in terrible things happening (choppy playback, reduced game performance, loss of sleep while trying to determine why performance is going down the drain, and so on) Add Sound.Update() anywhere in Game1.Update()

Next, we’ll add some PlayCue() calls Our first stop will be in HitManager In CheckHit(), we basically have two big if blocks to choose from when we’ve hit something: a bullet hit if code block and a default hit if code block In the bullet hit if statement, add the following:

We have one more sound to implement In Character.FireTrig(), we need a switch where

we create particles on a case-by-case basis Let’s set it up to play the revol sound for all three pistol-firing triggers:

Great! Now Zombie Smashers has been brought, kicking and screaming, from the

silent-movie era into XACT-enriched modern times

Playing audio at hard-coded points is working well enough so far, but what happens when

we want to have a wrench-swishing sound? We couldn’t really hard-code that, because there

are too many possibilities in a current combo system So what do we do? The solution is to

inte-grate audio controls into our character-scripting system

Scripting Audio

We’ll start with the sound file Find a “swing” sound—think swinging a baseball bat or, hey, a

wrench! Drag your new swing.wav file into your XACT wave bank, and then drag it from there

to the Cue panel in your Sound Bank window Save the project

Let’s add a new script command to our character-scripting language In the Commands

enumeration, go ahead and add a new one at the end:

Finally, we need to add a case to the big switch case block in the constructor for ScriptLine

to parse the command string into our script line command format In the switch block in the

constructor for ScriptLine, add this:

Run the CharacterEditor application and load Guy Let’s add play swing commands to our Guy character For the swing-swing-swing-kick combo, add a play swing command near the start of every attack, as shown in Figure 8-18.

Figure 8-18 Play swing!

You can see how easy it would be to add sounds for landing, yelling, footsteps, and much, much more We’ll leave that up to you!

Adding Music

We’ve covered a bit of what XACT has to offer, but there’s still a lot more ground in the audio department A few simple things we can implement are streaming audio, looping audio, cate-gories, and compression—all things we’ll need for music implementation

Music audio can get large It may not seem like a big deal now, but if we end up with 100MB

of music audio in our game, it will make much more sense to load a couple kilobytes of it at a time, swapping blocks in and out of memory, so we’ve loaded only what we’re playing or about

to play This is the essence of streaming audio This also used to be a big hassle to implement, but it’s a snap with XACT

Now we’ll add some music to our game Of course, you’ll need a music track for this We’ll leave this up to you—you can really use anything We recommend that it be at least three minutes, and it doesn’t have to seamlessly loop Again, FlashKit has some nice tracks available Also, you can use the music provided with this book’s downloadable files, called music1.wav (we made this sample track using ACID software)

In XACT, add the wave bank musicwavs and the sound bank musicsnds Select musicwavs and, in the Properties panel, click the Streaming button Figure 8-19 shows what’s going on Notice how the wave bank icon now has “DVD” above it This evidently indicates that these waves would stream from a DVD if our game were based on a DVD Because it’s an XNA title, this won’t exactly be the case, but we can forgive Microsoft for this, can’t we?

When we load this wave bank, we’ll need to set some special parameters to tell our audio engine how to stream, but we’ll get to that once we finish in XACT

Drag music1.wav into the musicwavs wave bank, and then drag the music1 wave into the Cue panel of the musicsnds Sound Bank window To set music1 to loop, click music1 in the Sound panel of the Sound Bank window and check Infinite under Looping in the Properties panel, as shown in Figure 8-20 Also, set the category to Music

Figure 8-19 Setting up streaming audio in the wave bank properties

■ Note Setting the sound category to Music will cause XNA to not play the audio if the Xbox 360 gamer is

playing music through the dashboard—a handy feature!

Finally, we can set the compression of the audio Right-click Compression Presets and select

New Compression Preset Name the new preset music, and set the parameters For Xbox 360, we set

Quality to 38 For Windows, we set Samples Per Block to 64, as shown in Figure 8-21 You’ll

need to play with the parameters a bit to see how heavily you can compress your audio before

you start to hear artifacts

Figure 8-20 Setting up infinite looping

Figure 8-21 Setting compression presets

Select the music wave bank again, and in the Properties panel, set the Compression Preset

to music

Now we’ll create a Music class in ZombieSmashers It will use the AudioEngine we have in Sound to load its wave bank and sound bank When we load our wave bank, we’ll do it to work with streaming We set the parameters to start at offset 0 and keep 16 block chunks of audio in memory Using smaller block sizes will cause our game music to stutter if things get hectic, but

16 seemed to work fine

private static WaveBank wave;

private static SoundBank sound;

private static Cue musicCue;

private static string musicStr;

In Game1.Update(), call Music.Play("music1"), which will play music1 if nothing else is

playing We now have streaming, looping, compressed, and properly behaving music!

Of course, as this is the “sensory overload” chapter, we have more to do

Rumble, Quake, and Blast!

We’ve already worked with force feedback in previous chapters, but we’re going to give it a more general implementation this time around We’ll create a global “quake” value that will indicate how much the screen is shaking and how much rumble is to be applied, as well as a cool stylized “blast” effect We can allow the quake value to be set from character scripts, as well as hard-coded events (certain hits, for example)

Setting Up Quaking, Rumbling, and Blasting

Let’s create a few classes to encapsulate and manage all things quakey We’re putting it all in a folder named Shakes

We’ll start with a Rumble class Remember how the Xbox 360 gamepad works? We have two rumble motors, thoughtfully named leftMotor (the low-frequency motor) and rightMotor (the high-frequency motor) We’ll use one Rumble object per gamepad, and let the class know which gamepad it is in the constructor Our Rumble.Update() method will reduce our vibration values and set our gamepad vibration

private Vector2 rumbleValue = Vector2.Zero;

private PlayerIndex playerIndex;

public Rumble(int idx)

get { return rumbleValue.X; }

set { rumbleValue.X = value; }

}

public float Right

{

get { return rumbleValue.Y; }

set { rumbleValue.Y = value; }

}

}

}

We’ll create a Quake class to encapsulate screen shaking This is pretty easy to implement

Remember how we calculate the scroll value in Game1? Well, we’ll just add a random Vector2

calculated by the current quake value to scroll to end up with a shaky camera effect that we can

use to accentuate a particular bit of brutality in our Zombie Smashing epic Otherwise, we’re

just doing the same linear rundown of our quake value as we did with the Rumble class

class Quake

{

private float val;

public void Update()

get { return val; }

set { val = value; }

return Rand.GetRandomVector2(-val, val, -val, val) * 10f;

private float val;

private float mag;

public Vector2 Center;

public void Update()

get { return val; }

set { val = value; }

}

public float Magnitude

{

get { return mag; }

set { mag = value; }

}

}

We’ll manage all of this through a class we’ll call QuakeManager This will keep all of our quake-related objects as statics, so that they’ll be accessible from anywhere (we’ll want to use them from HitManager, Character, and Game1 off the bat)

static class QuakeManager

{

public static Rumble[] Rumbles = new Rumble[4];

public static Quake Quake;

public static Blast Blast;

static QuakeManager()

{

Quake = new Quake();

Blast = new Blast();