LECTURE 11Announcements

Deadline Approaching• Course policy: you

must turn in a working version of all projects

• Deadline for incomplete projects is December 19

• Same day as Final V

Playtesting Reminders• Don’t give hints or

instructions• Watch your

playtesters: more useful than their feedback

• Turn in handwritten signatures

QUESTIONS?Announcements

LECTURE 11Sound

Sound in Games• In the real world,

computers have sound• Background music• Sound effects• Can be an important

part of gameplay– Listening for footsteps– Dramatic music

Sound File Formats• Many ways to encode

and store sound• Open standards

– Ogg Vorbis– FLAC

• Closed standards– mp3– m4a– wav

Sampled Audio• mp3, wav, etc.• Recordings of live sounds• Samples of sound wave

at regular intervals• Can be any sound that

exists in real life, but must create & record it

• More common in today’s games 11001001101010110111010110010001

10101

Generated Audio• MIDI• Instructions for computer

to play music• Sound cards have tables of

note sounds• Can instruct computer to

play something even if you can’t play it

• Used to be popular to save space, not as common now

Compressed vs. UncompressedCompressed Sound Files• Lossy or Lossless?

– Lossy remove “least important” parts of sound wave

– Lossless just use smart compression on raw wave

• Smaller file size (esp. lossy)• Lossy is lower quality• Slower to decode and play• Used for music

Uncompressed Sound Files• Record as much as

possible of sound wave

• Much larger file size• Usually high quality• Faster to decode and

play• Used for sound effects

Buffering• Decompressing and

decoding is slow• Read sound into buffer,

play back from buffer• Size of buffer depends

on speed of system• Playback delay while

buffer is filled

Buffer

Sound file

Sound device

Decoding

Sound in Java• Lines, DataLines, and Clips– Sources of audio for

software audio mixer– Clip is preloaded samples, DataLine is streaming audio from buffer

• AudioSystem– Provides factory methods

for loading audio sources

AudioInputStream stream = AudioSystem .getAudioInputStream(new

File(“mysound.wav”));Clip clip = AudioSystem.getClip();clip.open(stream);clip.start();AudioFormat format = stream.getFormat();SourceDataLine line = AudioSystem .getSourceDataLine(format);line.open(format);int nRead=0; byte[] data=new byte[4096];while(nRead > -1) {

nRead = stream.read(data, 0,

data.length);line.write(data, 0, nRead);

}

Sound in Java• Sequencer plays

MIDI sounds• MidiSystem is like AudioSystem for MIDI files

Sequence song = MidiSystem.getSequence(new File(“mysong.mid”));Sequencer midiPlayer = MidiSystem.getSequencer();midiPlayer.open(); midiPlayer.setSequence(song);midiPlayer.setLoopCount(0);midiPlayer.start();

QUESTIONS?Sound

LECTURE 11Data Persistence

What to Save• Settings– User profile– Game settings

• Game state– Progress through

level– Various styles of

saving

SETTINGSData Persistence

Saving User Settings• Custom controls• Player name• Considerations

– Need to save per user– Should be able to

export between game instances

– Ideally put in cloud sync

Saving Game Settings• Preferred resolution• Graphics detail level• Considerations

– Need to save per installation of game

– Should not go in cloud storage – machine-specific, can’t “sync”

Strategies• Serialize a Java object• Java properties file• XML/JSON file

– Easy for humans to read

– Harder to parse

• Custom text format– Can be more concise,

easy to parse

User Interface• User probably doesn’t

need to know file location– Still make it easy to find

so user can back it up

• Don’t save automatically, revert graphics changes if no response

GAME STATEData Persistence

When to Save Game• Only at checkpoints

– Easier to implement– Each checkpoint is a

level, reload level when player dies

– More frustrating for player

– Ensure they’re frequent enough

When to Save Game• Any time at save

stations– Like checkpoints, but user

can go back and resave– Better for nonlinear

games– Need to save level state/

progress, but not exact positions (save room usually empty)

When to Save Game• Whenever user wants

– Harder to implement, need a “snapshot” of current game state

– Good for difficult games with frequent failure

– Can still restrict when user can save (e.g. not during combat)

Automatic Saving• Always a good idea,

even when user can choose when to save

• Just because saves are available doesn’t mean user will use them

• Don’t set user too far back when they fail

Strategies• Serialize and restore entire game

world• Save some info about player

progress and reload level• Concise save file that can be

unmarshaled into game world

User Interface• Save “slots”

– Easy, simple, annoying

• Native file browser– Easy way to allow

arbitrary saves– Doesn’t mesh well

with game, unprofessional

User Interface• Custom save-file browser

– Harder to implement, but most flexible/featureful

• Features– Screenshot of saved game– Show only current player’s

saves– Sort by time & type of save

QUESTIONS?Data Persistence

LECTURE 11Tips for Final III

Gameplay is Important• Implement most of

your game logic this week

• Playtest early and often

• Use the feedback you’re getting

JAVA TIP OF THE WEEKTips for Final III

The Many Uses of final• Did you know? final can be applied to:– Instance variables– Local variables– Method parameters– Classes– Methods

Final Instance Variables• Value never changes• Can be set in

constructor or initializer block– Must be set by the time

an instance is created

• Can be different between instances of same class

public class Example {private final float

mass;private final String

name;private final int[]

values = {1, 2, 3, 4, 5};

public Example(String name, float mass) {

this.name = name;

this.mass = mass;

}}

Warning: final Objects Aren’t Immutable

• final makes object reference constant, not object itself

• Can still change a final field if object is mutable

• Arrays are objects

public class FinalContainer {public final List<Integer>

stuff;public final String[] things;public

FinalContainer(List<Integer> stuff, String[] things) {

this.stuff = stuff;this.things = things;

}}…FinalContainer container = new FinalContainer(myList, mySet);container.stuff.clear();container.things[0]= “oops”;

Final Instance Variables• Denote fields that

should never change over lifetime of object

• Safe(r) to make final fields public

• Useful for ensuring objects are immutable

• Useful for making “structs”

public class Vec2f {public final float x;public final float y;public Vec2f(float x,

float y)…}public class Results {

public final boolean collision;

public final Vec2f point;public final Vec2f mtv;public Results(boolean

collision, Vec2f point, Vec2f mtv)…}

Final Local Variables• Must be set immediately

at declaration• Value can’t change• Can assign new final

variable with same name• Same warning: Object

references can’t change, objects are still mutable

public float doStuff(int[] nums) {

int sum = 0;for(final int num :

nums)sum += num;

final float ave = sum / (float)

nums.length;//illegal: ave += 1;final List<Float> list =

new ArrayList<Float>();

list.add(sum);list.add(ave);return ave;

}

Final Local Variables• Help guarantee a

value doesn’t change after being computed

• Allow inner classes to access local variables– Inner class “saves”

state of local variables, only works if they don’t change

public void addShowField(String text) {

final TextField field = new TextField(text);

field.setVisible(false);this.add(field);Button button = new

Button(“Click to show”, new ButtonListener() {

public void onClicked() {

field.setVisible(true);}

});this.add(button);

}

Final Parameters• Special kind of

local variable, same behavior

• Set by caller, can’t change once in method

• Note that changing parameters wouldn’t affect caller anyway

public boolean contains(final String query, final int start, final int end) {

//illegalwhile(start < end) {

start++; …}//legalfor(int i = start; i < end;

i++) {…

}}if(sequence.contains(“stuff”, 0, 5))…if(sequence.contains(“things”, 8, 60))…

Final Parameters• Guarantee that

parameters always represent caller’s values

• If you need to compute something, use a local variable

• Easier maintainability in long methods

public void compute(final Vec2f point, final float dist) {

Vec2f endPoint =

point.plus(dist, dist);float mag =

Math.sqrt(dist);//many more computations…

//much later in the method

float sqr = dist * dist;

Vec2f extend = point.smult(sqr);

//do more stuff…}

Final Classes• Can’t be extended• Useful for designing

libraries• Ensures clients

can’t break other classes by changing expected behavior

public final class Data {private int count;private float total;…public float

getAverage() {return total /

count;}public void add(float

datum) {total += datum;count++;

}}

Final Methods• Can’t be overridden• Selectively allow

inheritance• In a final class, all

methods are final• Abstract classes can

have final methods

abstract class Parser {//can’t be overriddenfinal void loadFile(File file)

{//(read file into

memory)}//can be overriddenboolean validateFile() {

boolean success = true;for(String line :

fileLines)success =

success && validate(line);return success;

}//must be overriddenabstract boolean

validate(String line);}

Final Methods• Also useful for libraries

– Can even guard yourself against bad design

• Prevent subclasses from changing some behavior

• Guarantee important setup happens

• More useful if your code is modular

public class Tree<E extends Element> {

public final boolean add(E elem) {

Node<E> newNode = new Node<E>(elem);

Node<E> parent =

getParent(elem);

parent.addChild(newNode);rebalance(parent);

}public Node<E> getParent(E

elem){…}public void

rebalance(Node<E> changed) {…}

}

QUESTIONS?Tips for Final III

FINAL II PLAYTESTING

Your games are playtestable now!