diff --git a/css/pacman.css b/css/pacman.css
index dba163f..d525747 100644
--- a/css/pacman.css
+++ b/css/pacman.css
@@ -207,6 +207,21 @@ h3 {
 	font-style: normal;
 }
 
+.sound { 
+	position: absolute;
+}
+.sound img { 
+	height: 28px;
+}
+#home .sound { 
+	bottom: 0px;
+	right: 5px;
+}
+#panel .sound { 
+	top: 77px;
+	right: 5px;
+}
+
 .github { 
 	position: absolute;
 	bottom: 0px;
@@ -216,8 +231,8 @@ h3 {
 .help-button { 
 	position: absolute;
 	text-align: center;
-	bottom: 0px;
-	right: 5px;
+	bottom: 8px;
+	right: 55px;
 	margin: auto;
 	font-size: 14px;
 	font-weight: bold;
@@ -272,6 +287,10 @@ h3 {
 	text-align: left;
 }
 
+#sound { 
+	position: absolute;
+}
+
 .ui-mobile {
 	-webkit-touch-callout: none;
 	-webkit-user-select: none;
@@ -290,7 +309,7 @@ h3 {
 }
 
 @media screen and (max-width:1024px), screen and (min-device-width : 768px) and (max-device-width : 1024px) { 
-	#home .help-button, #panel .help-button, #home .github { 
+	#home .help-button, #panel .help-button, #home .github, #sound, .sound { 
 		display: none;
 	}
 	#panel, #home { 
@@ -308,7 +327,7 @@ h3 {
 	#control { 
 		display: inline; 
 	} 
-	#home .help-button, #panel .help-button, #home .github { 
+	#home .help-button, #panel .help-button, #home .github, #sound, .sound { 
 		display: none;
 	}
 	h1, #canvas-panel-title-pacman { 
@@ -322,7 +341,7 @@ h3 {
 	#control { 
 		display: inline; 
 	} 
-	h1, #canvas-panel-title-pacman, #control-up-second, #control-down-second, #home .help-button, #panel .help-button, #home .github { 
+	h1, #canvas-panel-title-pacman, #control-up-second, #control-down-second, #home .help-button, #panel .help-button, #home .github, #sound, .sound { 
 		display: none;
 	}
 	#score, #highscore { 
diff --git a/img/sound-off.png b/img/sound-off.png
new file mode 100644
index 0000000..b790975
Binary files /dev/null and b/img/sound-off.png differ
diff --git a/img/sound-on.png b/img/sound-on.png
new file mode 100644
index 0000000..d4ba08a
Binary files /dev/null and b/img/sound-on.png differ
diff --git a/index.html b/index.html
index 3218012..3ac5270 100644
--- a/index.html
+++ b/index.html
@@ -18,6 +18,7 @@
 	
 		<script type="text/javascript" src="js/jquery.js"></script>
 		<script type="text/javascript" src="js/jquery-mobile.js"></script>
+		<script type="text/javascript" src="js/jquery-buzz.js"></script>
 		
 		<script type="text/javascript" src="js/game.js"></script>
 		<script type="text/javascript" src="js/tools.js"></script>
@@ -28,6 +29,7 @@
 		<script type="text/javascript" src="js/pacman.js"></script>
 		<script type="text/javascript" src="js/ghosts.js"></script>
 		<script type="text/javascript" src="js/home.js"></script>
+		<script type="text/javascript" src="js/sound.js"></script>
 		
 		<script type="text/javascript">		
 			
@@ -44,9 +46,25 @@
 			
 			$(document).ready(function() { 
 				$.mobile.loading().hide();
+				loadAllSound();
 				
 				HELP_TIMER = setInterval('blinkHelp()', HELP_DELAY);
 				
+				$(".sound").click(function(e) { 
+					e.stopPropagation();
+					
+					var sound = $(this).attr("data-sound");
+					if ( sound === "on" ) { 
+						$(".sound").attr("data-sound", "off");
+						$(".sound").find("img").attr("src", "img/sound-off.png");
+						GROUP_SOUND.mute();
+					} else { 
+						$(".sound").attr("data-sound", "on");
+						$(".sound").find("img").attr("src", "img/sound-on.png");
+						GROUP_SOUND.unmute();
+					}
+				});
+				
 				$(".help-button, #help").click(function(e) { 
 					e.stopPropagation();
 					if (!PACMAN_DEAD && !LOCK && !GAMEOVER) { 
@@ -156,6 +174,8 @@
 		
 	<body>
 	
+		<div id="sound"></div>
+	
 		<div id="help">
 			<h2>Help</h2>
 			<table align="center" border="0" cellPadding="2" cellSpacing="0">
@@ -183,6 +203,7 @@ <h3>Lucio PANEPINTO<br><em>2015</em></h3>
 			</div>
 			<canvas id="trailer"></canvas>
 			<div class="help-button">- help -</div>
+			<a class="sound" href="javascript:void(0);" data-sound="on"><img src="img/sound-on.png" alt="" border="0"></a>
 			<a class="github" target="_blank" href="https://github.com/luciopanepinto/pacman"><img src="img/github.png" alt="GitHub - Lucio PANEPINTO - Pac-Man"></a>
 		</div>
 	
@@ -214,6 +235,7 @@ <h1>pac-man</h1>
 			<canvas id="canvas-level-fruits"></canvas>
 			<div id="message"></div>
 			<div class="help-button">- help -</div>
+			<a class="sound" href="javascript:void(0);" data-sound="on"><img src="img/sound-on.png" alt="" border="0"></a>
 		</div>
 	
 	</body>
diff --git a/js/fruits.js b/js/fruits.js
index 9b7f287..9579cab 100644
--- a/js/fruits.js
+++ b/js/fruits.js
@@ -100,6 +100,8 @@ function getLevelFruitsCanevasContext() {
 }
 
 function eatFruit() { 
+	playEatFruitSound();
+	
 	var s = 0;
 	if (FRUIT === "cherry")  s = 100;
 	else if (FRUIT === "strawberry")  s = 300;
diff --git a/js/game.js b/js/game.js
index 3eaa22c..30c6137 100644
--- a/js/game.js
+++ b/js/game.js
@@ -100,6 +100,8 @@ function initGame(newgame) {
 }
 
 function win() { 
+	stopAllSound();
+
 	LOCK = true;
 	stopPacman();
 	stopGhosts();
@@ -168,9 +170,12 @@ function ready() {
 	LOCK = true;
 	message("ready!");
 	
-	setTimeout("go()", "2000");
+	playReadySound();
+	setTimeout("go()", "4100");
 }
 function go() { 
+	playSirenSound();
+
 	LOCK = false;
 	
 	startTimes();
@@ -219,7 +224,9 @@ function stopTimes() {
 }
 
 function pauseGame() { 
+
 	if (!PAUSE) { 
+		stopAllSound();
 		PAUSE = true;
 		
 		message("pause");
@@ -232,6 +239,8 @@ function pauseGame() {
 }
 function resumeGame() { 
 	if (PAUSE) { 
+		testStateGhosts();
+
 		PAUSE = false;
 		
 		clearMessage();
@@ -245,6 +254,9 @@ function resumeGame() {
 
 function lifes(l) { 
 	if (l) { 
+		if ( l > 0 ) { 
+			playExtraLifeSound();
+		}
 		LIFES += l;
 	}
 	
diff --git a/js/ghosts.js b/js/ghosts.js
index e8bb01c..120a4ec 100644
--- a/js/ghosts.js
+++ b/js/ghosts.js
@@ -154,6 +154,9 @@ function drawGhost(ghost) {
 }
 
 function affraidGhosts() { 
+	
+	playWazaSound();
+	
 	SCORE_GHOST_COMBO = 200;
 
 	affraidGhost("blinky");
@@ -181,10 +184,31 @@ function cancelAffraidGhost(ghost) {
 		stopGhost(ghost);
 		eval('GHOST_' + ghost.toUpperCase() + '_STATE = 0');
 		moveGhost(ghost);
+		testStateGhosts();
+	}
+}
+function testStateGhosts() { 
+
+	if ( GHOST_BLINKY_STATE === 1 ||  
+		 GHOST_PINKY_STATE === 1 ||  
+		 GHOST_INKY_STATE === 1 ||  
+		 GHOST_CLYDE_STATE === 1 
+	) { 
+		playWazaSound();
+	} else if ( GHOST_BLINKY_STATE === -1 ||  
+		 GHOST_PINKY_STATE === -1 ||  
+		 GHOST_INKY_STATE === -1 ||  
+		 GHOST_CLYDE_STATE === -1 
+	) { 
+		playGhostEatenSound();		
+	} else { 
+		playSirenSound();
 	}
 }
 
 function startEatGhost(ghost) { 
+	playEatGhostSound();
+
 	LOCK = true;
 	
 	if ( eval('GHOST_' + ghost.toUpperCase() + '_AFFRAID_TIMER !== null') ) { 
@@ -202,6 +226,8 @@ function startEatGhost(ghost) {
 
 function eatGhost(ghost) { 
 
+	playGhostEatenSound();
+	
 	if (eval('GHOST_' + ghost.toUpperCase() + '_STATE === 1')) { 
 		$("#board span.combo").remove();
 		eval('GHOST_' + ghost.toUpperCase() + '_STATE = -1');
@@ -218,6 +244,7 @@ function cancelEatGhost(ghost) {
 		stopGhost(ghost);
 		eval('GHOST_' + ghost.toUpperCase() + '_STATE = 0');
 		moveGhost(ghost);
+		testStateGhosts();
 	}
 }
 
diff --git a/js/jquery-buzz.js b/js/jquery-buzz.js
new file mode 100644
index 0000000..b373e91
--- /dev/null
+++ b/js/jquery-buzz.js
@@ -0,0 +1,730 @@
+ // ----------------------------------------------------------------------------
+ // Buzz, a Javascript HTML5 Audio library
+ // v1.1.10 - Built 2015-04-20 13:05
+ // Licensed under the MIT license.
+ // http://buzz.jaysalvat.com/
+ // ----------------------------------------------------------------------------
+ // Copyright (C) 2010-2015 Jay Salvat
+ // http://jaysalvat.com/
+ // ----------------------------------------------------------------------------
+
+(function(context, factory) {
+    "use strict";
+    if (typeof module !== "undefined" && module.exports) {
+        module.exports = factory();
+    } else if (typeof define === "function" && define.amd) {
+        define([], factory);
+    } else {
+        context.buzz = factory();
+    }
+})(this, function() {
+    "use strict";
+    var AudioContext = window.AudioContext || window.webkitAudioContext;
+    var buzz = {
+        defaults: {
+            autoplay: false,
+            duration: 5e3,
+            formats: [],
+            loop: false,
+            placeholder: "--",
+            preload: "metadata",
+            volume: 80,
+            webAudioApi: false,
+            document: window.document
+        },
+        types: {
+            mp3: "audio/mpeg",
+            ogg: "audio/ogg",
+            wav: "audio/wav",
+            aac: "audio/aac",
+            m4a: "audio/x-m4a"
+        },
+        sounds: [],
+        el: document.createElement("audio"),
+        getAudioContext: function() {
+            if (this.audioCtx === undefined) {
+                try {
+                    this.audioCtx = AudioContext ? new AudioContext() : null;
+                } catch (e) {
+                    this.audioCtx = null;
+                }
+            }
+            return this.audioCtx;
+        },
+        sound: function(src, options) {
+            options = options || {};
+            var doc = options.document || buzz.defaults.document;
+            var pid = 0, events = [], eventsOnce = {}, supported = buzz.isSupported();
+            this.load = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.load();
+                return this;
+            };
+            this.play = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.play();
+                return this;
+            };
+            this.togglePlay = function() {
+                if (!supported) {
+                    return this;
+                }
+                if (this.sound.paused) {
+                    this.sound.play();
+                } else {
+                    this.sound.pause();
+                }
+                return this;
+            };
+            this.pause = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.pause();
+                return this;
+            };
+            this.isPaused = function() {
+                if (!supported) {
+                    return null;
+                }
+                return this.sound.paused;
+            };
+            this.stop = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.setTime(0);
+                this.sound.pause();
+                return this;
+            };
+            this.isEnded = function() {
+                if (!supported) {
+                    return null;
+                }
+                return this.sound.ended;
+            };
+            this.loop = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.loop = "loop";
+                this.bind("ended.buzzloop", function() {
+                    this.currentTime = 0;
+                    this.play();
+                });
+                return this;
+            };
+            this.unloop = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.removeAttribute("loop");
+                this.unbind("ended.buzzloop");
+                return this;
+            };
+            this.mute = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.muted = true;
+                return this;
+            };
+            this.unmute = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.muted = false;
+                return this;
+            };
+            this.toggleMute = function() {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.muted = !this.sound.muted;
+                return this;
+            };
+            this.isMuted = function() {
+                if (!supported) {
+                    return null;
+                }
+                return this.sound.muted;
+            };
+            this.setVolume = function(volume) {
+                if (!supported) {
+                    return this;
+                }
+                if (volume < 0) {
+                    volume = 0;
+                }
+                if (volume > 100) {
+                    volume = 100;
+                }
+                this.volume = volume;
+                this.sound.volume = volume / 100;
+                return this;
+            };
+            this.getVolume = function() {
+                if (!supported) {
+                    return this;
+                }
+                return this.volume;
+            };
+            this.increaseVolume = function(value) {
+                return this.setVolume(this.volume + (value || 1));
+            };
+            this.decreaseVolume = function(value) {
+                return this.setVolume(this.volume - (value || 1));
+            };
+            this.setTime = function(time) {
+                if (!supported) {
+                    return this;
+                }
+                var set = true;
+                this.whenReady(function() {
+                    if (set === true) {
+                        set = false;
+                        this.sound.currentTime = time;
+                    }
+                });
+                return this;
+            };
+            this.getTime = function() {
+                if (!supported) {
+                    return null;
+                }
+                var time = Math.round(this.sound.currentTime * 100) / 100;
+                return isNaN(time) ? buzz.defaults.placeholder : time;
+            };
+            this.setPercent = function(percent) {
+                if (!supported) {
+                    return this;
+                }
+                return this.setTime(buzz.fromPercent(percent, this.sound.duration));
+            };
+            this.getPercent = function() {
+                if (!supported) {
+                    return null;
+                }
+                var percent = Math.round(buzz.toPercent(this.sound.currentTime, this.sound.duration));
+                return isNaN(percent) ? buzz.defaults.placeholder : percent;
+            };
+            this.setSpeed = function(duration) {
+                if (!supported) {
+                    return this;
+                }
+                this.sound.playbackRate = duration;
+                return this;
+            };
+            this.getSpeed = function() {
+                if (!supported) {
+                    return null;
+                }
+                return this.sound.playbackRate;
+            };
+            this.getDuration = function() {
+                if (!supported) {
+                    return null;
+                }
+                var duration = Math.round(this.sound.duration * 100) / 100;
+                return isNaN(duration) ? buzz.defaults.placeholder : duration;
+            };
+            this.getPlayed = function() {
+                if (!supported) {
+                    return null;
+                }
+                return timerangeToArray(this.sound.played);
+            };
+            this.getBuffered = function() {
+                if (!supported) {
+                    return null;
+                }
+                return timerangeToArray(this.sound.buffered);
+            };
+            this.getSeekable = function() {
+                if (!supported) {
+                    return null;
+                }
+                return timerangeToArray(this.sound.seekable);
+            };
+            this.getErrorCode = function() {
+                if (supported && this.sound.error) {
+                    return this.sound.error.code;
+                }
+                return 0;
+            };
+            this.getErrorMessage = function() {
+                if (!supported) {
+                    return null;
+                }
+                switch (this.getErrorCode()) {
+                  case 1:
+                    return "MEDIA_ERR_ABORTED";
+
+                  case 2:
+                    return "MEDIA_ERR_NETWORK";
+
+                  case 3:
+                    return "MEDIA_ERR_DECODE";
+
+                  case 4:
+                    return "MEDIA_ERR_SRC_NOT_SUPPORTED";
+
+                  default:
+                    return null;
+                }
+            };
+            this.getStateCode = function() {
+                if (!supported) {
+                    return null;
+                }
+                return this.sound.readyState;
+            };
+            this.getStateMessage = function() {
+                if (!supported) {
+                    return null;
+                }
+                switch (this.getStateCode()) {
+                  case 0:
+                    return "HAVE_NOTHING";
+
+                  case 1:
+                    return "HAVE_METADATA";
+
+                  case 2:
+                    return "HAVE_CURRENT_DATA";
+
+                  case 3:
+                    return "HAVE_FUTURE_DATA";
+
+                  case 4:
+                    return "HAVE_ENOUGH_DATA";
+
+                  default:
+                    return null;
+                }
+            };
+            this.getNetworkStateCode = function() {
+                if (!supported) {
+                    return null;
+                }
+                return this.sound.networkState;
+            };
+            this.getNetworkStateMessage = function() {
+                if (!supported) {
+                    return null;
+                }
+                switch (this.getNetworkStateCode()) {
+                  case 0:
+                    return "NETWORK_EMPTY";
+
+                  case 1:
+                    return "NETWORK_IDLE";
+
+                  case 2:
+                    return "NETWORK_LOADING";
+
+                  case 3:
+                    return "NETWORK_NO_SOURCE";
+
+                  default:
+                    return null;
+                }
+            };
+            this.set = function(key, value) {
+                if (!supported) {
+                    return this;
+                }
+                this.sound[key] = value;
+                return this;
+            };
+            this.get = function(key) {
+                if (!supported) {
+                    return null;
+                }
+                return key ? this.sound[key] : this.sound;
+            };
+            this.bind = function(types, func) {
+                if (!supported) {
+                    return this;
+                }
+                types = types.split(" ");
+                var self = this, efunc = function(e) {
+                    func.call(self, e);
+                };
+                for (var t = 0; t < types.length; t++) {
+                    var type = types[t], idx = type;
+                    type = idx.split(".")[0];
+                    events.push({
+                        idx: idx,
+                        func: efunc
+                    });
+                    this.sound.addEventListener(type, efunc, true);
+                }
+                return this;
+            };
+            this.unbind = function(types) {
+                if (!supported) {
+                    return this;
+                }
+                types = types.split(" ");
+                for (var t = 0; t < types.length; t++) {
+                    var idx = types[t], type = idx.split(".")[0];
+                    for (var i = 0; i < events.length; i++) {
+                        var namespace = events[i].idx.split(".");
+                        if (events[i].idx === idx || namespace[1] && namespace[1] === idx.replace(".", "")) {
+                            this.sound.removeEventListener(type, events[i].func, true);
+                            events.splice(i, 1);
+                        }
+                    }
+                }
+                return this;
+            };
+            this.bindOnce = function(type, func) {
+                if (!supported) {
+                    return this;
+                }
+                var self = this;
+                eventsOnce[pid++] = false;
+                this.bind(type + "." + pid, function() {
+                    if (!eventsOnce[pid]) {
+                        eventsOnce[pid] = true;
+                        func.call(self);
+                    }
+                    self.unbind(type + "." + pid);
+                });
+                return this;
+            };
+            this.trigger = function(types, detail) {
+                if (!supported) {
+                    return this;
+                }
+                types = types.split(" ");
+                for (var t = 0; t < types.length; t++) {
+                    var idx = types[t];
+                    for (var i = 0; i < events.length; i++) {
+                        var eventType = events[i].idx.split(".");
+                        if (events[i].idx === idx || eventType[0] && eventType[0] === idx.replace(".", "")) {
+                            var evt = doc.createEvent("HTMLEvents");
+                            evt.initEvent(eventType[0], false, true);
+                            evt.originalEvent = detail;
+                            this.sound.dispatchEvent(evt);
+                        }
+                    }
+                }
+                return this;
+            };
+            this.fadeTo = function(to, duration, callback) {
+                if (!supported) {
+                    return this;
+                }
+                if (duration instanceof Function) {
+                    callback = duration;
+                    duration = buzz.defaults.duration;
+                } else {
+                    duration = duration || buzz.defaults.duration;
+                }
+                var from = this.volume, delay = duration / Math.abs(from - to), self = this;
+                this.play();
+                function doFade() {
+                    setTimeout(function() {
+                        if (from < to && self.volume < to) {
+                            self.setVolume(self.volume += 1);
+                            doFade();
+                        } else if (from > to && self.volume > to) {
+                            self.setVolume(self.volume -= 1);
+                            doFade();
+                        } else if (callback instanceof Function) {
+                            callback.apply(self);
+                        }
+                    }, delay);
+                }
+                this.whenReady(function() {
+                    doFade();
+                });
+                return this;
+            };
+            this.fadeIn = function(duration, callback) {
+                if (!supported) {
+                    return this;
+                }
+                return this.setVolume(0).fadeTo(100, duration, callback);
+            };
+            this.fadeOut = function(duration, callback) {
+                if (!supported) {
+                    return this;
+                }
+                return this.fadeTo(0, duration, callback);
+            };
+            this.fadeWith = function(sound, duration) {
+                if (!supported) {
+                    return this;
+                }
+                this.fadeOut(duration, function() {
+                    this.stop();
+                });
+                sound.play().fadeIn(duration);
+                return this;
+            };
+            this.whenReady = function(func) {
+                if (!supported) {
+                    return null;
+                }
+                var self = this;
+                if (this.sound.readyState === 0) {
+                    this.bind("canplay.buzzwhenready", function() {
+                        func.call(self);
+                    });
+                } else {
+                    func.call(self);
+                }
+            };
+            this.addSource = function(src) {
+                var self = this, source = doc.createElement("source");
+                source.src = src;
+                if (buzz.types[getExt(src)]) {
+                    source.type = buzz.types[getExt(src)];
+                }
+                this.sound.appendChild(source);
+                source.addEventListener("error", function(e) {
+                    self.trigger("sourceerror", e);
+                });
+                return source;
+            };
+            function timerangeToArray(timeRange) {
+                var array = [], length = timeRange.length - 1;
+                for (var i = 0; i <= length; i++) {
+                    array.push({
+                        start: timeRange.start(i),
+                        end: timeRange.end(i)
+                    });
+                }
+                return array;
+            }
+            function getExt(filename) {
+                return filename.split(".").pop();
+            }
+            if (supported && src) {
+                for (var i in buzz.defaults) {
+                    if (buzz.defaults.hasOwnProperty(i)) {
+                        if (options[i] === undefined) {
+                            options[i] = buzz.defaults[i];
+                        }
+                    }
+                }
+                this.sound = doc.createElement("audio");
+                if (options.webAudioApi) {
+                    var audioCtx = buzz.getAudioContext();
+                    if (audioCtx) {
+                        this.source = audioCtx.createMediaElementSource(this.sound);
+                        this.source.connect(audioCtx.destination);
+                    }
+                }
+                if (src instanceof Array) {
+                    for (var j in src) {
+                        if (src.hasOwnProperty(j)) {
+                            this.addSource(src[j]);
+                        }
+                    }
+                } else if (options.formats.length) {
+                    for (var k in options.formats) {
+                        if (options.formats.hasOwnProperty(k)) {
+                            this.addSource(src + "." + options.formats[k]);
+                        }
+                    }
+                } else {
+                    this.addSource(src);
+                }
+                if (options.loop) {
+                    this.loop();
+                }
+                if (options.autoplay) {
+                    this.sound.autoplay = "autoplay";
+                }
+                if (options.preload === true) {
+                    this.sound.preload = "auto";
+                } else if (options.preload === false) {
+                    this.sound.preload = "none";
+                } else {
+                    this.sound.preload = options.preload;
+                }
+                this.setVolume(options.volume);
+                buzz.sounds.push(this);
+            }
+        },
+        group: function(sounds) {
+            sounds = argsToArray(sounds, arguments);
+            this.getSounds = function() {
+                return sounds;
+            };
+            this.add = function(soundArray) {
+                soundArray = argsToArray(soundArray, arguments);
+                for (var a = 0; a < soundArray.length; a++) {
+                    sounds.push(soundArray[a]);
+                }
+            };
+            this.remove = function(soundArray) {
+                soundArray = argsToArray(soundArray, arguments);
+                for (var a = 0; a < soundArray.length; a++) {
+                    for (var i = 0; i < sounds.length; i++) {
+                        if (sounds[i] === soundArray[a]) {
+                            sounds.splice(i, 1);
+                            break;
+                        }
+                    }
+                }
+            };
+            this.load = function() {
+                fn("load");
+                return this;
+            };
+            this.play = function() {
+                fn("play");
+                return this;
+            };
+            this.togglePlay = function() {
+                fn("togglePlay");
+                return this;
+            };
+            this.pause = function(time) {
+                fn("pause", time);
+                return this;
+            };
+            this.stop = function() {
+                fn("stop");
+                return this;
+            };
+            this.mute = function() {
+                fn("mute");
+                return this;
+            };
+            this.unmute = function() {
+                fn("unmute");
+                return this;
+            };
+            this.toggleMute = function() {
+                fn("toggleMute");
+                return this;
+            };
+            this.setVolume = function(volume) {
+                fn("setVolume", volume);
+                return this;
+            };
+            this.increaseVolume = function(value) {
+                fn("increaseVolume", value);
+                return this;
+            };
+            this.decreaseVolume = function(value) {
+                fn("decreaseVolume", value);
+                return this;
+            };
+            this.loop = function() {
+                fn("loop");
+                return this;
+            };
+            this.unloop = function() {
+                fn("unloop");
+                return this;
+            };
+            this.setSpeed = function(speed) {
+                fn("setSpeed", speed);
+                return this;
+            };
+            this.setTime = function(time) {
+                fn("setTime", time);
+                return this;
+            };
+            this.set = function(key, value) {
+                fn("set", key, value);
+                return this;
+            };
+            this.bind = function(type, func) {
+                fn("bind", type, func);
+                return this;
+            };
+            this.unbind = function(type) {
+                fn("unbind", type);
+                return this;
+            };
+            this.bindOnce = function(type, func) {
+                fn("bindOnce", type, func);
+                return this;
+            };
+            this.trigger = function(type) {
+                fn("trigger", type);
+                return this;
+            };
+            this.fade = function(from, to, duration, callback) {
+                fn("fade", from, to, duration, callback);
+                return this;
+            };
+            this.fadeIn = function(duration, callback) {
+                fn("fadeIn", duration, callback);
+                return this;
+            };
+            this.fadeOut = function(duration, callback) {
+                fn("fadeOut", duration, callback);
+                return this;
+            };
+            function fn() {
+                var args = argsToArray(null, arguments), func = args.shift();
+                for (var i = 0; i < sounds.length; i++) {
+                    sounds[i][func].apply(sounds[i], args);
+                }
+            }
+            function argsToArray(array, args) {
+                return array instanceof Array ? array : Array.prototype.slice.call(args);
+            }
+        },
+        all: function() {
+            return new buzz.group(buzz.sounds);
+        },
+        isSupported: function() {
+            return !!buzz.el.canPlayType;
+        },
+        isOGGSupported: function() {
+            return !!buzz.el.canPlayType && buzz.el.canPlayType('audio/ogg; codecs="vorbis"');
+        },
+        isWAVSupported: function() {
+            return !!buzz.el.canPlayType && buzz.el.canPlayType('audio/wav; codecs="1"');
+        },
+        isMP3Supported: function() {
+            return !!buzz.el.canPlayType && buzz.el.canPlayType("audio/mpeg;");
+        },
+        isAACSupported: function() {
+            return !!buzz.el.canPlayType && (buzz.el.canPlayType("audio/x-m4a;") || buzz.el.canPlayType("audio/aac;"));
+        },
+        toTimer: function(time, withHours) {
+            var h, m, s;
+            h = Math.floor(time / 3600);
+            h = isNaN(h) ? "--" : h >= 10 ? h : "0" + h;
+            m = withHours ? Math.floor(time / 60 % 60) : Math.floor(time / 60);
+            m = isNaN(m) ? "--" : m >= 10 ? m : "0" + m;
+            s = Math.floor(time % 60);
+            s = isNaN(s) ? "--" : s >= 10 ? s : "0" + s;
+            return withHours ? h + ":" + m + ":" + s : m + ":" + s;
+        },
+        fromTimer: function(time) {
+            var splits = time.toString().split(":");
+            if (splits && splits.length === 3) {
+                time = parseInt(splits[0], 10) * 3600 + parseInt(splits[1], 10) * 60 + parseInt(splits[2], 10);
+            }
+            if (splits && splits.length === 2) {
+                time = parseInt(splits[0], 10) * 60 + parseInt(splits[1], 10);
+            }
+            return time;
+        },
+        toPercent: function(value, total, decimal) {
+            var r = Math.pow(10, decimal || 0);
+            return Math.round(value * 100 / total * r) / r;
+        },
+        fromPercent: function(percent, total, decimal) {
+            var r = Math.pow(10, decimal || 0);
+            return Math.round(total / 100 * percent * r) / r;
+        }
+    };
+    return buzz;
+});
\ No newline at end of file
diff --git a/js/pacman.js b/js/pacman.js
index d93e7da..bddee07 100644
--- a/js/pacman.js
+++ b/js/pacman.js
@@ -16,7 +16,8 @@ var PACMAN_EAT_GAP = 15;
 var PACMAN_GHOST_GAP = 20;
 var PACMAN_FRUITS_GAP = 15;
 var PACMAN_KILLING_TIMER = -1;
-var PACMAN_KILLING_SPEED = 100;
+var PACMAN_KILLING_SPEED = 70;
+var PACMAN_RETRY_SPEED = 2100;
 var PACMAN_DEAD = false;
 
 function initPacman() { 
@@ -246,6 +247,8 @@ function erasePacman() {
 }
 
 function killPacman() { 
+	playDieSound();
+
 	LOCK = true;
 	PACMAN_DEAD = true;
 	stopPacman();
@@ -265,7 +268,7 @@ function killingPacman() {
 		erasePacman();
 		if (LIFES > 0) { 
 			lifes(-1);
-			retry();
+			setTimeout('retry()', (PACMAN_RETRY_SPEED));
 		} else { 
 			gameover();
 		}
@@ -334,15 +337,19 @@ function testBubblesPacman() {
 				BUBBLES[testX + "," + testY] = b.substr(0, b.length - 1) + "1";
 				if (type === "s") { 
 					score(SCORE_SUPER_BUBBLE);
+					playEatPillSound();
 					affraidGhosts();
 				} else { 
 					score(SCORE_BUBBLE);
+					playEatingSound();
 				}
 				BUBBLES_COUNTER --;
 				if (BUBBLES_COUNTER === 0) { 
 					win();
 				}
 				return;
+			} else { 
+				stopEatingSound();
 			}
 		}
 	}
diff --git a/js/sound.js b/js/sound.js
new file mode 100644
index 0000000..df7a5a1
--- /dev/null
+++ b/js/sound.js
@@ -0,0 +1,155 @@
+var EATING_SOUND = new buzz.sound([
+    "./sound/eating.ogg",
+    "./sound/eating.mp3" 
+]);
+var GHOST_EATEN_SOUND = new buzz.sound([
+    "./sound/ghost-eaten.ogg", 
+	"./sound/ghost-eaten.mp3" 
+]);
+var EXTRA_LIFE_SOUND = new buzz.sound([
+    "./sound/extra-life.ogg",
+    "./sound/extra-life.mp3" 
+]);
+var EAT_PILL_SOUND = new buzz.sound([
+    "./sound/eat-pill.ogg",
+    "./sound/eat-pill.mp3" 
+]);
+var EAT_FRUIT_SOUND = new buzz.sound([
+    "./sound/eat-fruit.ogg",
+    "./sound/eat-fruit.mp3" 
+]);
+var EAT_GHOST_SOUND = new buzz.sound([
+    "./sound/eat-ghost.ogg",
+    "./sound/eat-ghost.mp3" 
+]);
+var SIREN_SOUND = new buzz.sound([
+    "./sound/siren.ogg",
+    "./sound/siren.mp3" 
+]);
+var WAZA_SOUND = new buzz.sound([
+    "./sound/waza.ogg",
+    "./sound/waza.mp3" 
+]);
+var READY_SOUND = new buzz.sound([
+    "./sound/ready.ogg",
+    "./sound/ready.mp3" 
+]);
+var DIE_SOUND = new buzz.sound([
+    "./sound/die.ogg",
+    "./sound/die.mp3" 
+]);
+
+var GROUP_SOUND = new buzz.group([ EATING_SOUND, SIREN_SOUND, EAT_PILL_SOUND, EAT_GHOST_SOUND, READY_SOUND, DIE_SOUND, WAZA_SOUND, GHOST_EATEN_SOUND, EXTRA_LIFE_SOUND, EAT_FRUIT_SOUND ]);
+
+var EATING_SOUND_LOOPING = false;
+
+function isAvailableSound() { 
+	return !($("#sound").css("display") === "none");
+}
+
+function loadAllSound() { 
+	if ( isAvailableSound() ) GROUP_SOUND.load();
+}
+
+function playEatingSound() { 
+	if (isAvailableSound()) { 
+		if ( !EATING_SOUND_LOOPING ) { 
+			EATING_SOUND_LOOPING = true;
+			
+			EATING_SOUND.setSpeed(1.35);
+			EATING_SOUND.loop();
+			EATING_SOUND.play();
+		}
+	}
+}
+function stopEatingSound() { 
+	if (isAvailableSound()) { 
+		if ( EATING_SOUND_LOOPING ) { 
+			EATING_SOUND.unloop();
+			EATING_SOUND_LOOPING = false;
+		}
+	}
+}
+
+function playExtraLifeSound() { 
+	if (isAvailableSound()) { 
+		EXTRA_LIFE_SOUND.play();
+	}
+}
+
+function playEatFruitSound() { 
+	if (isAvailableSound()) { 
+		EAT_FRUIT_SOUND.play();
+	}
+}
+function playEatPillSound() { 
+	if (isAvailableSound()) { 
+		EAT_PILL_SOUND.play();
+	}
+}
+function playEatGhostSound() { 
+	if (isAvailableSound()) { 
+		EAT_GHOST_SOUND.play();
+	}
+}
+
+function playWazaSound() { 
+	if (isAvailableSound()) { 
+		stopSirenSound();
+		stopEatSound();
+		WAZA_SOUND.loop();
+		WAZA_SOUND.play();
+	}
+}
+function stopWazaSound() { 
+	if (isAvailableSound()) { 
+		WAZA_SOUND.stop();
+	}
+}
+
+function playGhostEatenSound() { 
+	if (isAvailableSound()) { 
+		stopSirenSound();
+		stopWazaSound();
+		GHOST_EATEN_SOUND.play();
+		GHOST_EATEN_SOUND.loop();
+	}
+}
+function stopEatSound() { 
+	if (isAvailableSound()) { 
+		GHOST_EATEN_SOUND.stop();
+	}
+}
+
+function playSirenSound() { 
+	if (isAvailableSound()) { 
+		stopWazaSound();
+		stopEatSound();
+		SIREN_SOUND.loop();
+		SIREN_SOUND.play();
+	}
+}
+function stopSirenSound() { 
+	if (isAvailableSound()) { 
+		SIREN_SOUND.stop();
+	}
+}
+
+function playReadySound() { 
+	if (isAvailableSound()) { 
+		READY_SOUND.play();
+	}
+}
+
+function playDieSound() { 
+	if (isAvailableSound()) { 
+		GROUP_SOUND.stop();
+		DIE_SOUND.play();
+	}
+}
+
+function stopAllSound() { 
+	if (isAvailableSound()) { 
+		GROUP_SOUND.stop();
+	}
+}
\ No newline at end of file
diff --git a/sound/die.mp3 b/sound/die.mp3
new file mode 100644
index 0000000..57e32c9
Binary files /dev/null and b/sound/die.mp3 differ
diff --git a/sound/die.ogg b/sound/die.ogg
new file mode 100644
index 0000000..3ffd959
Binary files /dev/null and b/sound/die.ogg differ
diff --git a/sound/eat-fruit.mp3 b/sound/eat-fruit.mp3
new file mode 100644
index 0000000..8cc8b01
Binary files /dev/null and b/sound/eat-fruit.mp3 differ
diff --git a/sound/eat-fruit.ogg b/sound/eat-fruit.ogg
new file mode 100644
index 0000000..b65c4cf
Binary files /dev/null and b/sound/eat-fruit.ogg differ
diff --git a/sound/eat-ghost.mp3 b/sound/eat-ghost.mp3
new file mode 100644
index 0000000..0bccf3b
Binary files /dev/null and b/sound/eat-ghost.mp3 differ
diff --git a/sound/eat-ghost.ogg b/sound/eat-ghost.ogg
new file mode 100644
index 0000000..59a60e2
Binary files /dev/null and b/sound/eat-ghost.ogg differ
diff --git a/sound/eat-pill.mp3 b/sound/eat-pill.mp3
new file mode 100644
index 0000000..8cc8b01
Binary files /dev/null and b/sound/eat-pill.mp3 differ
diff --git a/sound/eat-pill.ogg b/sound/eat-pill.ogg
new file mode 100644
index 0000000..b65c4cf
Binary files /dev/null and b/sound/eat-pill.ogg differ
diff --git a/sound/eating.mp3 b/sound/eating.mp3
new file mode 100644
index 0000000..240607b
Binary files /dev/null and b/sound/eating.mp3 differ
diff --git a/sound/eating.ogg b/sound/eating.ogg
new file mode 100644
index 0000000..3269383
Binary files /dev/null and b/sound/eating.ogg differ
diff --git a/sound/extra-life.mp3 b/sound/extra-life.mp3
new file mode 100644
index 0000000..ce57655
Binary files /dev/null and b/sound/extra-life.mp3 differ
diff --git a/sound/extra-life.ogg b/sound/extra-life.ogg
new file mode 100644
index 0000000..a64153c
Binary files /dev/null and b/sound/extra-life.ogg differ
diff --git a/sound/ghost-eaten.mp3 b/sound/ghost-eaten.mp3
new file mode 100644
index 0000000..3c29995
Binary files /dev/null and b/sound/ghost-eaten.mp3 differ
diff --git a/sound/ghost-eaten.ogg b/sound/ghost-eaten.ogg
new file mode 100644
index 0000000..daf395f
Binary files /dev/null and b/sound/ghost-eaten.ogg differ
diff --git a/sound/ready.mp3 b/sound/ready.mp3
new file mode 100644
index 0000000..f295eb3
Binary files /dev/null and b/sound/ready.mp3 differ
diff --git a/sound/ready.ogg b/sound/ready.ogg
new file mode 100644
index 0000000..ac62f8a
Binary files /dev/null and b/sound/ready.ogg differ
diff --git a/sound/siren.mp3 b/sound/siren.mp3
new file mode 100644
index 0000000..061fcc7
Binary files /dev/null and b/sound/siren.mp3 differ
diff --git a/sound/siren.ogg b/sound/siren.ogg
new file mode 100644
index 0000000..0fe60aa
Binary files /dev/null and b/sound/siren.ogg differ
diff --git a/sound/waza.mp3 b/sound/waza.mp3
new file mode 100644
index 0000000..3a5a9b4
Binary files /dev/null and b/sound/waza.mp3 differ
diff --git a/sound/waza.ogg b/sound/waza.ogg
new file mode 100644
index 0000000..55a2647
Binary files /dev/null and b/sound/waza.ogg differ
