g.scale(0.5f, 0.5f);
// existing drawing code here
g.scale(2f, 2f);

// Play the level up sound
if (levelEnd) {
   levelUpSound.stop();
   levelUpSound.setFramePosition(0);
   levelUpSound.start();
}

Map<String, List<String>> myMap = new HashMap<>();

package ca.townsends.games.templates;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.StringTokenizer;

/**
 * Takes a csv-like file of notes in {duration}{octave}{note} format, and outputs one byte per note.  The input
 * ignores all whitespace, including linefeeds and carriage returns, so you can group music as you please.  For example,
 * the first few stanzas of the song "Music Box Dancer" are:
 * 
 * 13C,13E,13G,13E,14C,13G,13E,13G,
 * 13C,13E,13G,13E,14C,13G,13E,13G,
 * 13C,13E,13G,13E,14C,13G,13E,13G,
 * 13C,13E,13G,13E,14C,13G,13E,13G,
 * 
 * 14C,13G,14C,14E,14C,14E,14G,14C,
 * 15C,15B,15A,34G,20R,
 * 14G,14F,14D,14B,13G,14C,14D,14F,
 * 14E,14C,15A,34G,20R,
 * 14C,13G,14C,14E,14C,14E,14G,14C,
 * 15C,15B,15A,34G,20R,
 * 
 * Note that the input accepts notes in any mixed-case, and recognizes both sharps
 * and flats (e.g.: "A", "C#" and "Db" are all valid notes within an octave.)  "R" is used for a Rest note.
 * 
 * I've named the output format "ca.townsends.music", with a ".music" extension, but that's purely arbitrary.
 * 
 * 
 * @author Rick Townsend
 * @version 1.1
 * 2012-02-25
 */
public class EncodeMusic {

   /** Notes are between 0 and 63:
    * - Shifting down by 40 gives a range of -40 to +22, with 23 reserved for silent beat.
    * - Since -9 is middle C, that leaves (-40 - -9) = 31 notes below middle C, and (22 - -9) = 31 notes above middle C
    * - This also means incoming, encoded notes should have 31 as middle C (so it translates to shifted value -9).
    */
   public static final int NOTE_SHIFT = -40;
   
   /**
    * Main method
    * @param args Not used
    */
   public static void main(String[] args) {
      HashMap<String,Integer> noteMap = new HashMap<String,Integer>();
      
      // The recognized notes within an octave
      noteMap.put("A",   0);
      noteMap.put("A#",   1);
      noteMap.put("Bb",   1);
      noteMap.put("B",   2);
      noteMap.put("C",   3);
      noteMap.put("C#",   4);
      noteMap.put("Db",   4);
      noteMap.put("D",   5);
      noteMap.put("D#",   6);
      noteMap.put("Eb",   6);
      noteMap.put("E",   7);
      noteMap.put("F",   8);
      noteMap.put("F#",   9);
      noteMap.put("Gb",   9);
      noteMap.put("G",   10);
      noteMap.put("G#",   11);
      noteMap.put("Ab",   11);
      noteMap.put("R",   63); // Rest note
      
      InputStream inStream = null;
      OutputStream outStream = null;
      
      // If we get an IO exception at any time, there's no point in continuing.
      try {
         // You could change these to be parameters from the args[] array, instead of hard-coded.
         inStream = EncodeMusic.class.getResourceAsStream("MusicBoxDancer.csv");
         outStream = new FileOutputStream("src/ca/townsends/games/templates/outputMusic.music");
         byte[] bytes = new byte[4096 * 4]; // 4K notes is a very, very long song... But if you overrun it, just make this bigger.
         
         // Grab all the bytes from the file
         inStream.read(bytes);
         
         // Dump it to a String so we can parse it more easily
         String data = (new String(bytes)).toUpperCase();
         
         // Split on commas
         StringTokenizer st = new StringTokenizer(data, ",");
           
         // Parse all the notes
           while(st.hasMoreTokens()) {
              // Trim off whitespace
              String token = st.nextToken().trim();
              
              // Skip any empty values (ie, where the input was only whitespace between two commas, or simply ",,")
              if (token.length() == 0) continue;
              
              // Grab the duration, octave and note
              int inDuration = Integer.parseInt(token.substring(0, 1));
              int inOctave = Integer.parseInt(token.substring(1, 2));
              String inNote = token.substring(2); // This grabs all text from the third character onward, so it will get both single ("C") and double ("C#) character notes
              
              //System.out.println(inNote);
              // Grab the notes value from the map
              int noteVal = noteMap.get(inNote);
              
              // Calculate the actual note value (0 - 62), by multiplying by the octave and shifting down by 7 so that middle C is dead center at note 31. 
              int outNote = (byte)(inOctave * 12 + noteVal - 7);
              // Shift the duration up by 6 bits
              int duration = inDuration << 6;

              // Hard-code the Rest note as note 63.
              if (noteVal == 63) outNote = 63;
              
              // Write the note in the lower 6 bits and the duration in the top 2 bits to both the output stream and system.out
              outStream.write((byte)(outNote | duration));
              System.out.print((byte)(outNote | duration) + ",");
              //System.out.print((char)(outNote | duration));
              //System.out.print("0x" + Integer.toHexString(outNote | duration).toUpperCase() + ",");

           }
      } catch (IOException e) {
         e.printStackTrace();
      } finally {
           try {inStream.close();} catch (Exception e){};
           try {outStream.close();} catch (Exception e){};
      }
      
   }

}

package ca.townsends.games.templates;

import java.applet.Applet;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.InputStream;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;

/**
 * Generate Sound
 * 
 * Ideas:
 * - Pre-generate the sound so it doesn't slow down framerate.
 * - Loop notes in groups of 8
 * - add changes by:
 *   - increasing/decreasing tempo
 *   - adjusting notes up/down by a set amount
 *   - play up down scale
 *   - repeat two notes
 * 
 * - Maybe pre-store some music in a byte string, using first six bits as the note, and the last two bits as the length?
 * 
 * - Note that with the current implementation, note 0 is the lowest Treble A, so -9 is middle C.
 * 
 * @author Rick Townsend
 * @version 1.0
 *
 */
public class Sound4K extends Applet implements Runnable {

   private static final int SCREEN_WIDTH = 800;
   private static final int SCREEN_HEIGHT = 600;
   private static final long LOOP_DELAY = 16; // 16 = approx 60 FPS

   // in hz, number of samples in one second 
   private static final int SAMPLE_RATE = 44100;
    
   // this is the time BETWEEN Samples 
   private static final double SAMPLE_PERIOD = 1.0 / SAMPLE_RATE;
   
   // volume
   private static int AMPLITUDE = 20;
   
   // Incoming notes are between 0 and 63:
   // - Shifting down by 40 gives a range of -40 to +22, with 23 reserved for silent beat.
   // - Since -9 is middle C, that leaves (-40 - -9) = 31 notes below middle C, and (22 - -9) = 31 notes above middle C
   // - This also means incoming, encoded notes should have 31 as middle C (so it translates to shifted value -9).
   private static final int NOTE_SHIFT = -40;
   
   // Incoming durations are between 0 and 3
   // - The code shifts them to be between 1 and 4
   // - This multiple is how many seconds a duration of 1 represents.
   private static final double DURATION_MULTIPLE = 0.2;
   
   /** array of keys (to detect which ones are currently being pressed */
   private boolean[] keys = new boolean[65536];
   private int mouseButton = MouseEvent.NOBUTTON;
   private int dMouseX = 0;
   private int dMouseY = 0;
   

   public void start() {
      new Thread(this).start();
   }

   public void run() {
      // Turn on event handling
      this.enableEvents(
            AWTEvent.KEY_EVENT_MASK |
            AWTEvent.MOUSE_EVENT_MASK |
            AWTEvent.MOUSE_MOTION_EVENT_MASK);

      // Set the screen size
      setSize(SCREEN_WIDTH, SCREEN_HEIGHT); // For AppletViewer, TODO: remove later.

      // Set up the graphics stuff, double-buffering.
      BufferedImage screen = new BufferedImage(SCREEN_WIDTH, SCREEN_HEIGHT, BufferedImage.TYPE_INT_RGB);
      Graphics2D g = (Graphics2D) screen.getGraphics();
      Graphics appletGraphics = this.getGraphics();
      
      long fps = 0;

      int iteration = 0;
      
      byte[] pcmMusic = new byte[0];

      /* e.g.: 
       * Play three fixed notes, each for 0.3 seconds
       */
      /*
      rawOutput = generateNote(rawOutput, -15, 0.3);
      rawOutput = generateNote(rawOutput, -17, 0.3);
      rawOutput = generateNote(rawOutput, -19, 0.3);
       */
      
      /* e.g.:
       * Generate a repeating sequence of:
       * - two notes
       * - played four times
       * - repeated three times, each time the two notes are three notes higher than the previous two
       * - repeated six times, each time the two notes are played for 0.1 seconds shorter than the previous time
       */
      /*
      for (int k = 0; k < 6; k++) {
         double duration = 0.6 - (k * 0.1);
         for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
               pcmMusic = generateNote(pcmMusic, i * 3 - 8, duration);
               pcmMusic = generateNote(pcmMusic, i * 3 + 4, duration);
            }
         }
      }
      */
      
      /* e.g.:
       * Load the music from a file (each byte is a note: top two bits are the duration, bottom 6 bits are the note to play.)
       */
      InputStream stream = this.getClass().getResourceAsStream("MusicBoxDancer.music");
      pcmMusic = parseMusicStream(stream);
      
      // Play the music
        AudioFormat audioFormat = new AudioFormat(SAMPLE_RATE, 8, 1, true, true);
        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
        Clip music;
      try {
         music = (Clip) AudioSystem.getLine(info);
           music.open(audioFormat, pcmMusic, 0, pcmMusic.length);
           music.loop(Clip.LOOP_CONTINUOUSLY); 
      } catch (LineUnavailableException e1) {
         // TODO Auto-generated catch block
         e1.printStackTrace();
      }
      
      // Game loop.
      while (isActive()) {
         iteration++;
         long lastTime = System.currentTimeMillis();
         
         // Clear the screen
         g.setColor(Color.WHITE);
         g.fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
         
         // TODO add some update logic here.

         
         // TODO: Animation goes here
         
         g.drawString("FPS: " + fps, 20, SCREEN_HEIGHT);
         
         // Game title
         g.setFont(new Font("Arial", Font.BOLD, 26));
         // Draw a drop-shadow first
         g.setColor(Color.GRAY);
         g.drawString("Sound 4K v1.0", SCREEN_WIDTH - 180, SCREEN_HEIGHT - 3);
         // Then the main title
         g.setColor(Color.BLUE);
         g.drawString("Sound 4K v1.0", SCREEN_WIDTH- 180, SCREEN_HEIGHT - 3);

         // Draw the entire results on the screen.
         appletGraphics.drawImage(screen, 0, 0, null);

         //Lock the frame rate
         long delta = System.currentTimeMillis() - lastTime;
         if(delta < LOOP_DELAY)
         {
            try {
               Thread.sleep(LOOP_DELAY - delta);
            } catch(Exception e) {
               // Nothing to do here
            }
         }
         if (iteration % 10 == 0) fps = 1000 / (System.currentTimeMillis() - lastTime);
      }
   }

   /**
    * Generates a new note, and appends it to the original array.
    * 
    * @param originalArray An array of bytes representing pcm music (can be empty/zero length)
    * @param note The note to generate.  There are 12 notes per octave: -9 = middle C, -8 = C#/Db, -7 = D, etc. 
    * @param duration How long to play the note, in seconds.
    * @return A new byte array containing the originalArray followed by the pcm bytes for the new note. 
    */
   private byte[] generateNote(byte[] originalArray, int note, double duration){
      
      int durationInSamples = (int) Math.ceil(duration * SAMPLE_RATE) + 1;
      
      byte[] noteArray = new byte[durationInSamples * 2];
                                   
      double time = 0;
      int i = 0;
      
      // Put in a pause if this note is the max value
      if (note == 63 + NOTE_SHIFT) {
         i = durationInSamples;
         
      } else {
         
         double tone = 440 * Math.pow(2,note/12f);
         
         boolean finishedNote = false;
         
         // Generate the note using a SINE wave.
         for(int j = 0; j < durationInSamples || !finishedNote; j++, i++) { 
            noteArray[i] = (byte) (AMPLITUDE * Math.sin(2 * Math.PI * tone * time));
            time += SAMPLE_PERIOD;
            // Keep going until the wave is finished at zero
            if (i > 0) finishedNote = (noteArray[i - 1] < 0 && noteArray[i] >= 0);
         }
      
      }

      // Append the note
      byte[] finalArray = new byte[originalArray.length + i];
      System.arraycopy(originalArray, 0, finalArray, 0, originalArray.length);
      System.arraycopy(noteArray, 0, finalArray, originalArray.length, i);
      
      return finalArray;
   }
   
   /**
    * Parses the bytes of an InputStream and returns a byte array containing the represented
    * notes in pcm format.
    * 
    * - The InputStream must be in "ca.townsends.music" format, where each byte represents a note and its duration.
    * - For each byte, the top 2 bits are the duration, the bottom 6 bits are the note to play.
    * - The duration is multiplied by the duration multiple and shifted up by 0.1.  So a duration of 0 = 0.1, 1 = 0.1 + (duration * multiple), etc.
    * - The note is shifted up by NOTE_SHIFT, which lets you adjust the note range up or down as desired. For example,
    *   to shift the music being parsed up by an octave, just increase NOTE_SHIFT by 12 (the number of notes in an octave.)
    * 
    * See ca.townsends.games.templates.EncodeMusic for a "music" encoder.
    * 
    * @param stream An InputStream in "music" format.
    * 
    * @return A byte array with the parsed music in pcm format.
    */
   private byte[] parseMusicStream (InputStream stream) {
      byte[] music = new byte[0];
      
      int b;
      try {
         while((b = stream.read()) != -1) {
            double duration = (b >> 6) * DURATION_MULTIPLE + 0.1;
            int note = (b & 63) + NOTE_SHIFT;
            // XXX: System.out.println(note + ", " + duration + ", " + (byte)b);
            music = generateNote(music, note, duration);
         }
      } catch (Exception e) {
         // TODO: Handle an error here
         e.printStackTrace();
      } finally {
         try {
            stream.close();
         } catch (Exception io) {
            // Can't do anything here
            io.printStackTrace();
         }
      }
      
      return music;
   }
   
   /**
    * Just standard key handling for a Java4K applet.
    */
   public void processKeyEvent(KeyEvent e) {
      switch (e.getID()) {
         case Event.KEY_PRESS:
         case Event.KEY_ACTION:
            // skip keypresses more than 0.1 seconds old, because they indicate bad lag time
            if (System.currentTimeMillis() - e.getWhen()  > 100)
               break;
            keys[e.getKeyCode()] = !keys[e.getKeyCode()];
            break;
      }
      
   }
   
   /**
    * Just standard mouse handling for a Java4K applet.
    */
   public void processMouseEvent(MouseEvent e) {
      dMouseX = e.getX();
      dMouseY = e.getY();

      switch (e.getID()) {
         case MouseEvent.MOUSE_PRESSED:
            // mouse button pressed
            mouseButton = e.getButton();
            break;
         case MouseEvent.MOUSE_RELEASED:
            // mouse button released
            mouseButton = MouseEvent.NOBUTTON;
            break;
         case MouseEvent.MOUSE_MOVED:
            break;
         case MouseEvent.MOUSE_DRAGGED:
            break;
      }
      
   }
   /**
    * Just standard mouse handling for a Java4K applet.  Delegates to processMouseEvent().
    */
   public void processMouseMotionEvent(MouseEvent e){
      processMouseEvent(e);
   }
}