diff --git a/data/components/enemies.py b/data/components/enemies.py
index 742e785f927c7430fa8cf1c45786f0913b0147ee..a737a2439592daecb2b9228fa3eadc43c3cb6828 100644
--- a/data/components/enemies.py
+++ b/data/components/enemies.py
@@ -14,7 +14,10 @@ class Enemy(pg.sprite.Sprite):
 
     def setup_enemy(self, x, y, direction, name, setup_frames):
         """Sets up various values for enemy"""
-        self.sprite_sheet = setup.GFX['smb_enemies_sheet']
+        if c.MODE == c.ENEMYMODE:
+            self.sprite_sheet = setup.GFX['smb_enemies_sheet_enemy']
+        else:
+            self.sprite_sheet = setup.GFX['smb_enemies_sheet']
         self.frames = []
         self.frame_index = 0
         self.animate_timer = 0
diff --git a/data/components/info.py b/data/components/info.py
index af11fc4f3d6b95feee0a3e7d2b3ecc6b31406bc2..0bbd7c8045eb4444ef95026cb3d8bb20713c98fc 100644
--- a/data/components/info.py
+++ b/data/components/info.py
@@ -187,9 +187,13 @@ class OverheadInfo(object):
         self.life_total_label = []
         self.create_label(self.life_total_label, str(self.total_lives),
                           450, 285)
+        #ADD HERE A CONDITION TO VERIFY WHAT MODE IS SELECTED
 
-        self.sprite_sheet = setup.GFX['mario_bros']
-        self.mario_image = self.get_image(178, 32, 12, 16)
+        #self.sprite_sheet = setup.GFX['mario_bros']
+        if c.MODE != c.DEJAVUMODE:
+            self.mario_image = self.get_image(178, 32, 12, 16)
+        else:
+            self.mario_image = self.get_image(177, 32, 16, 16) #Sprite position and size for Mario_Dejavu
         self.mario_rect = self.mario_image.get_rect(center=(320, 290))
 
 
@@ -216,16 +220,25 @@ class OverheadInfo(object):
         """Create labels for the MAIN MENU screen"""
         player_one_game = []
         player_two_game = []
+        player_three_game = []
+        player_four_game = []
+        player_five_game = []
+        player_six_game = []
         top = []
         top_score = []
 
-        self.create_label(player_one_game, '1 PLAYER GAME', 272, 360)
-        self.create_label(player_two_game, '2 PLAYER GAME', 272, 405)
-        self.create_label(top, 'TOP - ', 290, 465)
-        self.create_label(top_score, '000000', 400, 465)
-
-        self.main_menu_labels = [player_one_game, player_two_game,
-                                 top, top_score]
+        self.create_label(player_one_game, 'CLASSIC MODE', 272, 360)
+        self.create_label(player_two_game, 'DEJAVU MODE', 272, 390)
+        self.create_label(player_three_game, 'TALL MODE', 272, 420)
+        self.create_label(player_four_game, 'LUIGI MODE', 272, 450)
+        self.create_label(player_five_game, 'ENEMY MODE', 272, 480)
+        # self.create_label(player_six_game, 'HARD MODE', 272, 510)
+        #self.create_label(top, 'TOP - ', 290, 465)
+        #self.create_label(top_score, '000000', 400, 465)
+
+        self.main_menu_labels = [player_one_game, player_two_game,player_three_game,player_four_game,player_five_game]
+                                 #,player_six_game]
+                                 #top, top_score]
 
 
     def update(self, level_info, mario=None):
diff --git a/data/components/mario.py b/data/components/mario.py
index 0de0d390823ddab1c44ccd00a2bd4bf12c1e2aae..992fd3dea96021306305c485fe51e05142a27e63 100644
--- a/data/components/mario.py
+++ b/data/components/mario.py
@@ -9,7 +9,6 @@ from . import powerups
 class Mario(pg.sprite.Sprite):
     def __init__(self):
         pg.sprite.Sprite.__init__(self)
-        self.sprite_sheet = setup.GFX['mario_bros']
 
         self.setup_timers()
         self.setup_state_booleans()
@@ -17,6 +16,7 @@ class Mario(pg.sprite.Sprite):
         self.setup_counters()
         self.load_images_from_sheet()
 
+
         self.state = c.WALK
         self.image = self.right_frames[self.frame_index]
         self.rect = self.image.get_rect()
@@ -78,6 +78,17 @@ class Mario(pg.sprite.Sprite):
     def load_images_from_sheet(self):
         """Extracts Mario images from his sprite sheet and assigns
         them to appropriate lists"""
+        self.sprite_sheet = setup.GFX['mario_bros_dejavu']
+        if c.MODE == c.NORMALMODE:
+            self.sprite_sheet = setup.GFX['mario_bros']
+        elif c.MODE == c.LUIGIMODE:
+            self.sprite_sheet = setup.GFX['mario_bros_luigi']
+        elif c.MODE == c.TALLMODE:
+            self.sprite_sheet = setup.GFX['mario_bros_tall']
+        elif c.MODE == c.ENEMYMODE:
+            self.sprite_sheet = setup.GFX['mario_bros_enemy']
+        # elif c.MODE == c.HARDMODE:
+        #     self.sprite_sheet = setup.GFX['mario_bros']
         self.right_frames = []
         self.left_frames = []
 
@@ -104,45 +115,86 @@ class Mario(pg.sprite.Sprite):
 
 
         #Images for normal small mario#
+        if c.MODE != c.DEJAVUMODE:
+         self.right_small_normal_frames.append(
+             self.get_image(178, 32, 12, 16))  # Right [0]
+         self.right_small_normal_frames.append(
+             self.get_image(80,  32, 15, 16))  # Right walking 1 [1]
+         self.right_small_normal_frames.append(
+             self.get_image(96,  32, 16, 16))  # Right walking 2 [2]
+         self.right_small_normal_frames.append(
+             self.get_image(112,  32, 16, 16))  # Right walking 3 [3]
+         self.right_small_normal_frames.append(
+             self.get_image(144, 32, 16, 16))  # Right jump [4]
+         self.right_small_normal_frames.append(
+             self.get_image(130, 32, 14, 16))  # Right skid [5]
+         self.right_small_normal_frames.append(
+             self.get_image(160, 32, 15, 16))  # Death frame [6]
+         self.right_small_normal_frames.append(
+             self.get_image(320, 8, 16, 24))  # Transition small to big [7]
+         self.right_small_normal_frames.append(
+             self.get_image(241, 33, 16, 16))  # Transition big to small [8]
+         self.right_small_normal_frames.append(
+             self.get_image(194, 32, 12, 16))  # Frame 1 of flag pole Slide [9]
+         self.right_small_normal_frames.append(
+             self.get_image(210, 33, 12, 16))  # Frame 2 of flag pole slide [10]
+
+        else:
+            self.right_small_normal_frames.append(
+                self.get_image(177, 32, 16, 16))  # Right [0]
+            self.right_small_normal_frames.append(
+                self.get_image(79, 33, 16, 16))  # Right walking 1 [1]
+            self.right_small_normal_frames.append(
+                self.get_image(96, 33, 16, 15))  # Right walking 2 [2]
+            self.right_small_normal_frames.append(
+                self.get_image(113, 32, 16, 16))  # Right walking 3 [3]
+            self.right_small_normal_frames.append(
+                self.get_image(144, 31, 16, 17))  # Right jump [4]
+            self.right_small_normal_frames.append(
+                self.get_image(130, 32, 13, 16))  # Right skid [5]
+            self.right_small_normal_frames.append(
+                self.get_image(160, 32, 15, 16))  # Death frame [6]
+            self.right_small_normal_frames.append(
+                self.get_image(320, 8, 16, 24))  # Transition small to big [7]
+            self.right_small_normal_frames.append(
+                self.get_image(241, 33, 16, 16))  # Transition big to small [8]
+            self.right_small_normal_frames.append(
+                self.get_image(194, 33, 16, 16))  # Frame 1 of flag pole Slide [9]
+            self.right_small_normal_frames.append(
+                self.get_image(211, 34, 16, 16))  # Frame 2 of flag pole slide [10]
 
-        self.right_small_normal_frames.append(
-            self.get_image(178, 32, 12, 16))  # Right [0]
-        self.right_small_normal_frames.append(
-            self.get_image(80,  32, 15, 16))  # Right walking 1 [1]
-        self.right_small_normal_frames.append(
-            self.get_image(96,  32, 16, 16))  # Right walking 2 [2]
-        self.right_small_normal_frames.append(
-            self.get_image(112,  32, 16, 16))  # Right walking 3 [3]
-        self.right_small_normal_frames.append(
-            self.get_image(144, 32, 16, 16))  # Right jump [4]
-        self.right_small_normal_frames.append(
-            self.get_image(130, 32, 14, 16))  # Right skid [5]
-        self.right_small_normal_frames.append(
-            self.get_image(160, 32, 15, 16))  # Death frame [6]
-        self.right_small_normal_frames.append(
-            self.get_image(320, 8, 16, 24))  # Transition small to big [7]
-        self.right_small_normal_frames.append(
-            self.get_image(241, 33, 16, 16))  # Transition big to small [8]
-        self.right_small_normal_frames.append(
-            self.get_image(194, 32, 12, 16))  # Frame 1 of flag pole Slide [9]
-        self.right_small_normal_frames.append(
-            self.get_image(210, 33, 12, 16))  # Frame 2 of flag pole slide [10]
 
 
         #Images for small green mario (for invincible animation)#
+        if c.MODE != c.DEJAVUMODE:
+            self.right_small_green_frames.append(
+                self.get_image(178, 224, 12, 16))  # Right standing [0]
+            self.right_small_green_frames.append(
+                self.get_image(80, 224, 15, 16))  # Right walking 1 [1]
+            self.right_small_green_frames.append(
+                self.get_image(96, 224, 16, 16))  # Right walking 2 [2]
+            self.right_small_green_frames.append(
+                self.get_image(112, 224, 15, 16))  # Right walking 3 [3]
+            self.right_small_green_frames.append(
+                 self.get_image(144, 224, 16, 16))  # Right jump [4]
+            self.right_small_green_frames.append(
+                self.get_image(130, 224, 14, 16))  # Right skid [5]
+
+        # Little_Mario_Dejavu stella
+        else:
+            self.right_small_green_frames.append(
+                self.get_image(177, 123, 16, 16))  # Right [0]
+            self.right_small_green_frames.append(
+                self.get_image(79, 124, 16, 16))  # Right walking 1 [1]
+            self.right_small_green_frames.append(
+                self.get_image(96, 124, 16, 15))  # Right walking 2 [2]
+            self.right_small_green_frames.append(
+                self.get_image(113, 123, 16, 16))  # Right walking 3 [3]
+            self.right_small_green_frames.append(
+                self.get_image(144, 122, 16, 17))  # Right jump [4]
+            self.right_small_green_frames.append(
+                self.get_image(130, 123, 13, 16))  # Right skid [5]
 
-        self.right_small_green_frames.append(
-            self.get_image(178, 224, 12, 16))  # Right standing [0]
-        self.right_small_green_frames.append(
-            self.get_image(80, 224, 15, 16))  # Right walking 1 [1]
-        self.right_small_green_frames.append(
-            self.get_image(96, 224, 16, 16))  # Right walking 2 [2]
-        self.right_small_green_frames.append(
-            self.get_image(112, 224, 15, 16))  # Right walking 3 [3]
-        self.right_small_green_frames.append(
-            self.get_image(144, 224, 16, 16))  # Right jump [4]
-        self.right_small_green_frames.append(
-            self.get_image(130, 224, 14, 16))  # Right skid [5]
 
         #Images for red mario (for invincible animation)#
 
@@ -175,49 +227,94 @@ class Mario(pg.sprite.Sprite):
             self.get_image(130, 176, 14, 16))  # Right skid [5]
 
 
-        #Images for normal big Mario
-
-        self.right_big_normal_frames.append(
-            self.get_image(176, 0, 16, 32))  # Right standing [0]
-        self.right_big_normal_frames.append(
-            self.get_image(81, 0, 16, 32))  # Right walking 1 [1]
-        self.right_big_normal_frames.append(
-            self.get_image(97, 0, 15, 32))  # Right walking 2 [2]
-        self.right_big_normal_frames.append(
-            self.get_image(113, 0, 15, 32))  # Right walking 3 [3]
-        self.right_big_normal_frames.append(
-            self.get_image(144, 0, 16, 32))  # Right jump [4]
-        self.right_big_normal_frames.append(
-            self.get_image(128, 0, 16, 32))  # Right skid [5]
-        self.right_big_normal_frames.append(
-            self.get_image(336, 0, 16, 32))  # Right throwing [6]
-        self.right_big_normal_frames.append(
-            self.get_image(160, 10, 16, 22))  # Right crouching [7]
-        self.right_big_normal_frames.append(
-            self.get_image(272, 2, 16, 29))  # Transition big to small [8]
-        self.right_big_normal_frames.append(
-            self.get_image(193, 2, 16, 30))  # Frame 1 of flag pole slide [9]
-        self.right_big_normal_frames.append(
-            self.get_image(209, 2, 16, 29))  # Frame 2 of flag pole slide [10]
+        #Big Mario Dejavu normale -> right_big_normal_frames
+        if c.MODE == c.DEJAVUMODE:
+            self.right_big_normal_frames.append(
+              self.get_image(197, 1, 24, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(79, 1, 24, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(104, 1, 24, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(129, 0, 24, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(172, 0, 24, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(154, 1, 17, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(336, 0, 16, 32))
+            self.right_big_normal_frames.append(
+              self.get_image(252, 1, 24, 14))
+            self.right_big_normal_frames.append(
+              self.get_image(272, 2, 16, 29))
+            self.right_big_normal_frames.append(
+              self.get_image(222, 1, 14, 24))
+            self.right_big_normal_frames.append(
+              self.get_image(237, 1, 14, 24))
 
-        #Images for green big Mario#
+        else:
+            self.right_big_normal_frames.append(
+                self.get_image(176, 0, 16, 32))  # Right standing [0]
+            self.right_big_normal_frames.append(
+                self.get_image(81, 0, 16, 32))  # Right walking 1 [1]
+            self.right_big_normal_frames.append(
+                self.get_image(97, 0, 15, 32))  # Right walking 2 [2]
+            self.right_big_normal_frames.append(
+                self.get_image(113, 0, 15, 32))  # Right walking 3 [3]
+            self.right_big_normal_frames.append(
+                self.get_image(144, 0, 16, 32))  # Right jump [4]
+            self.right_big_normal_frames.append(
+                self.get_image(128, 0, 16, 32))  # Right skid [5]
+            self.right_big_normal_frames.append(
+                self.get_image(336, 0, 16, 32))  # Right throwing [6]
+            self.right_big_normal_frames.append(
+                self.get_image(160, 10, 16, 22))  # Right crouching [7]
+            self.right_big_normal_frames.append(
+                self.get_image(272, 2, 16, 29))  # Transition big to small [8]
+            self.right_big_normal_frames.append(
+                self.get_image(193, 2, 16, 30))  # Frame 1 of flag pole slide [9]
+            self.right_big_normal_frames.append(
+                 self.get_image(209, 2, 16, 29))  # Frame 2 of flag pole slide [10]
 
-        self.right_big_green_frames.append(
-            self.get_image(176, 192, 16, 32))  # Right standing [0]
-        self.right_big_green_frames.append(
-            self.get_image(81, 192, 16, 32))  # Right walking 1 [1]
-        self.right_big_green_frames.append(
-            self.get_image(97, 192, 15, 32))  # Right walking 2 [2]
-        self.right_big_green_frames.append(
-            self.get_image(113, 192, 15, 32))  # Right walking 3 [3]
-        self.right_big_green_frames.append(
-            self.get_image(144, 192, 16, 32))  # Right jump [4]
-        self.right_big_green_frames.append(
-            self.get_image(128, 192, 16, 32))  # Right skid [5]
-        self.right_big_green_frames.append(
-            self.get_image(336, 192, 16, 32))  # Right throwing [6]
-        self.right_big_green_frames.append(
-            self.get_image(160, 202, 16, 22))  # Right Crouching [7]
+
+
+        #Images for green big Mario#
+        if c.MODE != c.DEJAVUMODE:
+            self.right_big_green_frames.append(
+                self.get_image(176, 192, 16, 32))  # Right standing [0]
+            self.right_big_green_frames.append(
+                self.get_image(81, 192, 16, 32))  # Right walking 1 [1]
+            self.right_big_green_frames.append(
+                self.get_image(97, 192, 15, 32))  # Right walking 2 [2]
+            self.right_big_green_frames.append(
+                self.get_image(113, 192, 15, 32))  # Right walking 3 [3]
+            self.right_big_green_frames.append(
+                self.get_image(144, 192, 16, 32))  # Right jump [4]
+            self.right_big_green_frames.append(
+                self.get_image(128, 192, 16, 32))  # Right skid [5]
+            self.right_big_green_frames.append(
+                self.get_image(336, 192, 16, 32))  # Right throwing [6]
+            self.right_big_green_frames.append(
+                self.get_image(160, 202, 16, 22))  # Right Crouching [7]
+
+        #Big_Mario_dejavu stella -> right_big_green_frames
+        else:
+            self.right_big_green_frames.append(
+                self.get_image(197, 97, 24, 14))
+            self.right_big_green_frames.append(
+                self.get_image(79, 97, 24, 14))
+            self.right_big_green_frames.append(
+                self.get_image(104, 97, 24, 14))
+            self.right_big_green_frames.append(
+                self.get_image(129, 96, 24, 14))
+            self.right_big_green_frames.append(
+                self.get_image(172, 96, 24, 14))
+            self.right_big_green_frames.append(
+                self.get_image(154, 97, 17, 14))
+            self.right_big_green_frames.append(
+                self.get_image(197, 97, 24, 14))
+            self.right_big_green_frames.append(
+                self.get_image(252, 97, 24, 14))
 
         #Images for red big Mario#
 
@@ -259,29 +356,54 @@ class Mario(pg.sprite.Sprite):
 
 
         #Images for Fire Mario#
-
-        self.right_fire_frames.append(
-            self.get_image(176, 48, 16, 32))  # Right standing [0]
-        self.right_fire_frames.append(
-            self.get_image(81, 48, 16, 32))  # Right walking 1 [1]
-        self.right_fire_frames.append(
-            self.get_image(97, 48, 15, 32))  # Right walking 2 [2]
-        self.right_fire_frames.append(
-            self.get_image(113, 48, 15, 32))  # Right walking 3 [3]
-        self.right_fire_frames.append(
-            self.get_image(144, 48, 16, 32))  # Right jump [4]
-        self.right_fire_frames.append(
-            self.get_image(128, 48, 16, 32))  # Right skid [5]
-        self.right_fire_frames.append(
-            self.get_image(336, 48, 16, 32))  # Right throwing [6]
-        self.right_fire_frames.append(
-            self.get_image(160, 58, 16, 22))  # Right crouching [7]
-        self.right_fire_frames.append(
-            self.get_image(0, 0, 0, 0))  # Place holder [8]
-        self.right_fire_frames.append(
-            self.get_image(193, 50, 16, 29))  # Frame 1 of flag pole slide [9]
-        self.right_fire_frames.append(
-            self.get_image(209, 50, 16, 29))  # Frame 2 of flag pole slide [10]
+        if c.MODE != c.DEJAVUMODE:
+            self.right_fire_frames.append(
+                self.get_image(176, 48, 16, 32))  # Right standing [0]
+            self.right_fire_frames.append(
+                self.get_image(81, 48, 16, 32))  # Right walking 1 [1]
+            self.right_fire_frames.append(
+                self.get_image(97, 48, 15, 32))  # Right walking 2 [2]
+            self.right_fire_frames.append(
+                self.get_image(113, 48, 15, 32))  # Right walking 3 [3]
+            self.right_fire_frames.append(
+                self.get_image(144, 48, 16, 32))  # Right jump [4]
+            self.right_fire_frames.append(
+                self.get_image(128, 48, 16, 32))  # Right skid [5]
+            self.right_fire_frames.append(
+                self.get_image(336, 48, 16, 32))  # Right throwing [6]
+            self.right_fire_frames.append(
+                self.get_image(160, 58, 16, 22))  # Right crouching [7]
+            self.right_fire_frames.append(
+                self.get_image(0, 0, 0, 0))  # Place holder [8]
+            self.right_fire_frames.append(
+                self.get_image(193, 50, 16, 29))  # Frame 1 of flag pole slide [9]
+            self.right_fire_frames.append(
+                self.get_image(209, 50, 16, 29))  # Frame 2 of flag pole slide [10]
+
+        #Images for fire Mario Dejavu
+        else:
+            self.right_fire_frames.append(
+                self.get_image(197, 51, 24, 14))
+            self.right_fire_frames.append(
+                self.get_image(79, 51, 24, 14))
+            self.right_fire_frames.append(
+                self.get_image(104, 51, 24, 14))
+            self.right_fire_frames.append(
+                self.get_image(129, 50, 24, 14))
+            self.right_fire_frames.append(
+                self.get_image(172, 50, 24, 14))
+            self.right_fire_frames.append(
+                self.get_image(154, 51, 17, 14))
+            self.right_fire_frames.append(
+                self.get_image(336, 50, 16, 32))
+            self.right_fire_frames.append(
+                self.get_image(252, 51, 24, 14))
+            self.right_fire_frames.append(
+                self.get_image(272, 52, 16, 29))
+            self.right_fire_frames.append(
+                self.get_image(222, 51, 14, 24))
+            self.right_fire_frames.append(
+                self.get_image(237, 51, 14, 24))
 
 
         #The left image frames are numbered the same as the right
@@ -336,10 +458,14 @@ class Mario(pg.sprite.Sprite):
         self.black_small_frames = [self.right_small_black_frames,
                              self.left_small_black_frames]
 
+        # self.invincible_small_frames_list = [self.normal_small_frames,
+        #                                   self.green_small_frames,
+        #                                   self.red_small_frames,
+        #                                   self.black_small_frames]
         self.invincible_small_frames_list = [self.normal_small_frames,
-                                          self.green_small_frames,
-                                          self.red_small_frames,
-                                          self.black_small_frames]
+                                             self.green_small_frames,
+                                             self.normal_small_frames,
+                                             self.green_small_frames]
 
         self.normal_big_frames = [self.right_big_normal_frames,
                                   self.left_big_normal_frames]
@@ -356,10 +482,14 @@ class Mario(pg.sprite.Sprite):
         self.fire_frames = [self.right_fire_frames,
                             self.left_fire_frames]
 
+        # self.invincible_big_frames_list = [self.normal_big_frames,
+        #                                    self.green_big_frames,
+        #                                    self.red_big_frames,
+        #                                    self.black_big_frames]
         self.invincible_big_frames_list = [self.normal_big_frames,
                                            self.green_big_frames,
-                                           self.red_big_frames,
-                                           self.black_big_frames]
+                                           self.normal_big_frames,
+                                           self.green_big_frames]
 
         self.all_images = [self.right_big_normal_frames,
                            self.right_big_black_frames,
@@ -509,7 +639,8 @@ class Mario(pg.sprite.Sprite):
                     powerups.FireBall(self.rect.right, self.rect.y, self.facing_right))
                 self.last_fireball_time = self.current_time
 
-                self.frame_index = 6
+                #self.frame_index = 6
+                self.frame_index = 0
                 if self.facing_right:
                     self.image = self.right_frames[self.frame_index]
                 else:
@@ -802,13 +933,13 @@ class Mario(pg.sprite.Sprite):
         if self.facing_right:
             frames = [self.right_fire_frames[3],
                       self.right_big_green_frames[3],
-                      self.right_big_red_frames[3],
-                      self.right_big_black_frames[3]]
+                      self.right_fire_frames[3],
+                      self.right_big_normal_frames[3]]
         else:
             frames = [self.left_fire_frames[3],
                       self.left_big_green_frames[3],
-                      self.left_big_red_frames[3],
-                      self.left_big_black_frames[3]]
+                      self.left_fire_frames[3],
+                      self.left_big_normal_frames[3]]
 
         if self.fire_transition_timer == 0:
             self.fire_transition_timer = self.current_time
@@ -856,14 +987,14 @@ class Mario(pg.sprite.Sprite):
         self.state = c.BIG_TO_SMALL
 
         if self.facing_right:
-            frames = [self.right_big_normal_frames[4],
-                      self.right_big_normal_frames[8],
-                      self.right_small_normal_frames[8]
+            frames = [self.right_big_normal_frames[0],
+                      self.right_big_normal_frames[0],
+                      self.right_small_normal_frames[0]
                       ]
         else:
-            frames = [self.left_big_normal_frames[4],
-                      self.left_big_normal_frames[8],
-                      self.left_small_normal_frames[8]
+            frames = [self.left_big_normal_frames[0],
+                      self.left_big_normal_frames[0],
+                      self.left_small_normal_frames[0]
                      ]
 
         if self.transition_timer == 0:
@@ -1034,7 +1165,7 @@ class Mario(pg.sprite.Sprite):
         if self.invincible:
             if ((self.current_time - self.invincible_start_timer) < 10000):
                 self.losing_invincibility = False
-                self.change_frame_list(30)
+                self.change_frame_list(60)
             elif ((self.current_time - self.invincible_start_timer) < 12000):
                 self.losing_invincibility = True
                 self.change_frame_list(100)
diff --git a/data/constants.py b/data/constants.py
index 2a01f93097b73b71a78d882d229ee23dd50305fd..c0ae07682efb44d311631ed0683c61cddeffb534 100644
--- a/data/constants.py
+++ b/data/constants.py
@@ -133,8 +133,12 @@ BOTTOM_OF_POLE = 'bottom of pole'
 ONEUP = '379'
 
 #MAIN MENU CURSOR STATES
-PLAYER1 = '1 player'
-PLAYER2 = '2 player'
+NORMALMODE = 'normal'
+DEJAVUMODE = 'dejavu'
+TALLMODE = 'tall'
+LUIGIMODE = 'luigi'
+ENEMYMODE = 'enemy'
+HARDMODE = 'hard'
 
 #OVERHEAD INFO STATES
 MAIN_MENU = 'main menu'
@@ -170,7 +174,14 @@ TIME_WARNING = 'time warning'
 SPED_UP_NORMAL = 'sped up normal'
 MARIO_INVINCIBLE = 'mario invincible'
 
-
+#MODE CONSTANTS
+MODE='normal'
+# NORMAL_MODE = 'normal mode'
+# ENEMY_MODE = 'enemy mode'
+# DEJAVU_MODE = 'dejavu mode'
+# LUIGI_MODE = 'luigi mode'
+# TALL_MODE = 'tall mode'
+# HARD_MODE = 'hard mode'
 
 
 
diff --git a/data/game_sound.py b/data/game_sound.py
index 857680e5839e1e646834b8fbd4d31116b24ec6df..cbd5a5b79ac7b2d804c56f8602c7d83346a18795 100644
--- a/data/game_sound.py
+++ b/data/game_sound.py
@@ -19,7 +19,12 @@ class Sound(object):
     def set_music_mixer(self):
         """Sets music for level"""
         if self.overhead_info.state == c.LEVEL:
-            pg.mixer.music.load(self.music_dict['main_theme'])
+            if c.MODE == c.DEJAVUMODE:
+                pg.mixer.music.load(self.music_dict['dejavu']) #main_theme
+            elif c.MODE == c.ENEMYMODE:
+                pg.mixer.music.load(self.music_dict['bowser_main_theme_woahnumberone'])
+            else:
+                pg.mixer.music.load(self.music_dict['main_theme'])
             pg.mixer.music.play()
             self.state = c.NORMAL
         elif self.overhead_info.state == c.GAME_OVER:
@@ -38,12 +43,27 @@ class Sound(object):
         """Handles the state of the soundn object"""
         if self.state == c.NORMAL:
             if self.mario.dead:
-                self.play_music('death', c.MARIO_DEAD)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('death_son_of_bitch', c.MARIO_DEAD)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('death_bowser_noooo', c.MARIO_DEAD)
+                else:
+                    self.play_music('death', c.MARIO_DEAD)
             elif self.mario.invincible \
                     and self.mario.losing_invincibility == False:
-                self.play_music('invincible', c.MARIO_INVINCIBLE)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('running_in_the_90', c.MARIO_INVINCIBLE)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('bowser_spedup_theme', c.MARIO_INVINCIBLE)
+                else:
+                    self.play_music('invincible', c.MARIO_INVINCIBLE)
             elif self.mario.state == c.FLAGPOLE:
-                self.play_music('flagpole', c.FLAGPOLE)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('victory_theme_cena', c.FLAGPOLE)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('victory_bowser_yeahboy', c.FLAGPOLE)
+                else:
+                    self.play_music('flagpole', c.FLAGPOLE)
             elif self.overhead_info.time == 100:
                 self.play_music('out_of_time', c.TIME_WARNING)
 
@@ -64,21 +84,50 @@ class Sound(object):
 
         elif self.state == c. TIME_WARNING:
             if pg.mixer.music.get_busy() == 0:
-                self.play_music('main_theme_sped_up', c.SPED_UP_NORMAL)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('gasgasgas', c.SPED_UP_NORMAL) #main_theme_sped_up
+                else:
+                    self.play_music('main_theme_sped_up', c.SPED_UP_NORMAL)
             elif self.mario.dead:
-                self.play_music('death', c.MARIO_DEAD)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('death_son_of_bitch', c.MARIO_DEAD)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('death_bowser_noooo', c.MARIO_DEAD)
+                else:
+                    self.play_music('death', c.MARIO_DEAD)
 
         elif self.state == c.SPED_UP_NORMAL:
             if self.mario.dead:
-                self.play_music('death', c.MARIO_DEAD)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('death_son_of_bitch', c.MARIO_DEAD)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('death_bowser_noooo', c.MARIO_DEAD)
+                else:
+                    self.play_music('death', c.MARIO_DEAD)
             elif self.mario.state == c.FLAGPOLE:
-                self.play_music('flagpole', c.FLAGPOLE)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('victory_theme_cena', c.FLAGPOLE)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('victory_bowser_yeahboy', c.FLAGPOLE)
+                else:
+                    self.play_music('flagpole', c.FLAGPOLE)
 
         elif self.state == c.MARIO_INVINCIBLE:
             if (self.mario.current_time - self.mario.invincible_start_timer) > 11000:
-                self.play_music('main_theme', c.NORMAL)
+                #self.play_music('main_theme', c.NORMAL)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('dejavu', c.NORMAL)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('bowser_main_theme_woahnumberone', c.NORMAL)
+                else:
+                    self.play_music('main_theme', c.NORMAL)
             elif self.mario.dead:
-                self.play_music('death', c.MARIO_DEAD)
+                if c.MODE == c.DEJAVUMODE:
+                    self.play_music('death_son_of_bitch', c.MARIO_DEAD)
+                elif c.MODE == c.ENEMYMODE:
+                    self.play_music('death_bowser_noooo', c.MARIO_DEAD)
+                else:
+                    self.play_music('death', c.MARIO_DEAD)
 
 
         elif self.state == c.WORLD_CLEAR:
diff --git a/data/states/level1.py b/data/states/level1.py
index 6e56a5158f07f35692c954e21c1d08cd54b2b11d..dff43f0374fef42ec3e0ea0bacf9ab44c366ae12 100644
--- a/data/states/level1.py
+++ b/data/states/level1.py
@@ -21,6 +21,7 @@ class Level1(tools._State):
     def __init__(self):
         tools._State.__init__(self)
 
+
     def startup(self, current_time, persist):
         """Called when the State object is created"""
         self.game_info = persist
@@ -50,7 +51,7 @@ class Level1(tools._State):
         self.setup_mario()
         self.setup_checkpoints()
         self.setup_spritegroups()
-
+        self.mario.load_images_from_sheet()
 
     def setup_background(self):
         """Sets the background image, rect and scales it to the correct
@@ -309,6 +310,7 @@ class Level1(tools._State):
     def setup_mario(self):
         """Places Mario at the beginning of the level"""
         self.mario = mario.Mario()
+        self.mario.load_images_from_sheet()
         self.mario.rect.x = self.viewport.x + 110
         self.mario.rect.bottom = c.GROUND_HEIGHT
 
diff --git a/data/states/main_menu.py b/data/states/main_menu.py
index 51dc34028c121cc9f377cd77570fb1d363aade11..0bdcf6ece1dc8d9cbc8c52bfafcf08a7e9d7c7df 100644
--- a/data/states/main_menu.py
+++ b/data/states/main_menu.py
@@ -1,3 +1,5 @@
+import time
+
 __author__ = 'justinarmstrong'
 
 import pygame as pg
@@ -40,7 +42,7 @@ class Menu(tools._State):
         dest = (220, 358)
         self.cursor.image, self.cursor.rect = self.get_image(
             24, 160, 8, 8, dest, setup.GFX['item_objects'])
-        self.cursor.state = c.PLAYER1
+        self.cursor.state = c.NORMALMODE
 
 
     def setup_mario(self):
@@ -106,19 +108,84 @@ class Menu(tools._State):
     def update_cursor(self, keys):
         """Update the position of the cursor"""
         input_list = [pg.K_RETURN, pg.K_a, pg.K_s]
-
-        if self.cursor.state == c.PLAYER1:
+        self.cursor.rect.y = 358
+        # self.cursor.state = c.NORMALMODE;
+        # for input in input_list:
+        #      if keys[input]:
+        #          self.reset_game_info()
+        #          self.done = True
+
+        if self.cursor.state == c.NORMALMODE:
             self.cursor.rect.y = 358
+            c.MODE = c.NORMALMODE;
+            if keys[pg.K_DOWN]:
+                self.cursor.state = c.DEJAVUMODE
+            time.sleep(0.1)
+            for input in input_list:
+                if keys[input]:
+                    self.reset_game_info()
+                    self.done = True
+        elif self.cursor.state == c.DEJAVUMODE:
+            self.cursor.rect.y = 388
+            c.MODE = c.DEJAVUMODE
+            if keys[pg.K_UP]:
+                self.cursor.state = c.NORMALMODE
+            if keys[pg.K_DOWN]:
+                self.cursor.state = c.TALLMODE
+            time.sleep(0.1)
+            for input in input_list:
+                if keys[input]:
+                    self.reset_game_info()
+                    self.done = True
+        elif self.cursor.state == c.TALLMODE:
+                self.cursor.rect.y = 418
+                c.MODE = c.TALLMODE
+                if keys[pg.K_UP]:
+                    self.cursor.state = c.DEJAVUMODE
+                if keys[pg.K_DOWN]:
+                    self.cursor.state = c.LUIGIMODE
+                time.sleep(0.1)
+                for input in input_list:
+                    if keys[input]:
+                        self.reset_game_info()
+                        self.done = True
+        elif self.cursor.state == c.LUIGIMODE:
+            self.cursor.rect.y = 448
+            c.MODE = c.LUIGIMODE
+            if keys[pg.K_UP]:
+                self.cursor.state = c.TALLMODE
             if keys[pg.K_DOWN]:
-                self.cursor.state = c.PLAYER2
+                self.cursor.state = c.ENEMYMODE
+            time.sleep(0.1)
             for input in input_list:
                 if keys[input]:
                     self.reset_game_info()
                     self.done = True
-        elif self.cursor.state == c.PLAYER2:
-            self.cursor.rect.y = 403
+        elif self.cursor.state == c.ENEMYMODE:
+            self.cursor.rect.y = 478
+            c.MODE = c.ENEMYMODE;
             if keys[pg.K_UP]:
-                self.cursor.state = c.PLAYER1
+                self.cursor.state = c.LUIGIMODE
+            # if keys[pg.K_DOWN]:
+            #     self.cursor.state = c.HARDMODE
+            time.sleep(0.1)
+            for input in input_list:
+                if keys[input]:
+                    self.reset_game_info()
+                    self.done = True
+        # elif self.cursor.state == c.HARDMODE:
+        #     self.cursor.rect.y = 508
+        #     c.MODE = c.HARDMODE;
+        #     if keys[pg.K_UP]:
+        #         self.cursor.state = c.ENEMYMODE
+        #     time.sleep(0.1)
+        #     for input in input_list:
+        #         if keys[input]:
+        #             self.reset_game_info()
+        #             self.done = True
+
+
+        #CLASSIC - DEJAVU - TALL - LUIGI - ENEMY - HARD
 
 
     def reset_game_info(self):
@@ -128,7 +195,7 @@ class Menu(tools._State):
         self.game_info[c.LIVES] = 3
         self.game_info[c.CURRENT_TIME] = 0.0
         self.game_info[c.LEVEL_STATE] = None
-
+        self.setup_mario()
         self.persist = self.game_info
 
 
diff --git a/data/tools.py b/data/tools.py
index 5f26b5bc8dd8af071f0ace11dbcc2a3d2d9dbd3d..d56ab3371520f5238f65154c9fbf9a01bb376ad7 100644
--- a/data/tools.py
+++ b/data/tools.py
@@ -8,7 +8,7 @@ keybinding = {
     'jump':pg.K_a,
     'left':pg.K_LEFT,
     'right':pg.K_RIGHT,
-    'down':pg.K_DOWN
+    'down':pg.K_DOWN,
 }
 
 class Control(object):
@@ -107,7 +107,7 @@ class _State(object):
 
 
 
-def load_all_gfx(directory, colorkey=(255,0,255), accept=('.png', 'jpg', 'bmp')):
+def load_all_gfx(directory, colorkey=(255,255,255), accept=('.png', 'jpg', 'bmp')):
     graphics = {}
     for pic in os.listdir(directory):
         name, ext = os.path.splitext(pic)
diff --git a/requirements.txt b/requirements.txt
index 93b47d3635bf9f6b46629e8cfbecb021898f369f..d9b86b58dc3902bf7679435303716102d1f648bd 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1 +1 @@
-pygame==1.9.1release
+pygame==1.9.4
diff --git a/resources/graphics/mario_bros_dejavu.png b/resources/graphics/mario_bros_dejavu.png
new file mode 100644
index 0000000000000000000000000000000000000000..671f95b1064acbee9b7abe4ebe03249b7b163e2a
Binary files /dev/null and b/resources/graphics/mario_bros_dejavu.png differ
diff --git a/resources/graphics/mario_bros_enemy.png b/resources/graphics/mario_bros_enemy.png
new file mode 100644
index 0000000000000000000000000000000000000000..b475a9eb468516c04bdad4ee5de473dde451d6b5
Binary files /dev/null and b/resources/graphics/mario_bros_enemy.png differ
diff --git a/resources/graphics/mario_bros_luigi.png b/resources/graphics/mario_bros_luigi.png
new file mode 100644
index 0000000000000000000000000000000000000000..5ce434e243ae4385159eb885de234cce77875a43
Binary files /dev/null and b/resources/graphics/mario_bros_luigi.png differ
diff --git a/resources/graphics/mario_bros_new_color.png b/resources/graphics/mario_bros_new_color.png
new file mode 100644
index 0000000000000000000000000000000000000000..d10742ee279fe9032fb538b45f2d2f21445445b7
Binary files /dev/null and b/resources/graphics/mario_bros_new_color.png differ
diff --git a/resources/graphics/mario_bros_tall.png b/resources/graphics/mario_bros_tall.png
new file mode 100644
index 0000000000000000000000000000000000000000..f8c2a952feb1b3ac8c86acff1301da85355e999d
Binary files /dev/null and b/resources/graphics/mario_bros_tall.png differ
diff --git a/resources/graphics/smb_enemies_sheet_enemy.png b/resources/graphics/smb_enemies_sheet_enemy.png
new file mode 100644
index 0000000000000000000000000000000000000000..c8a0695f3add0b3512fe74e4a0a7759d236bbd0a
Binary files /dev/null and b/resources/graphics/smb_enemies_sheet_enemy.png differ
diff --git a/resources/music/bowser_main_theme_woahnumberone.mp3 b/resources/music/bowser_main_theme_woahnumberone.mp3
new file mode 100644
index 0000000000000000000000000000000000000000..4020adafd83a97e20088f809b283c5ec6d840965
Binary files /dev/null and b/resources/music/bowser_main_theme_woahnumberone.mp3 differ
diff --git a/resources/music/bowser_spedup_theme.mp3 b/resources/music/bowser_spedup_theme.mp3
new file mode 100644
index 0000000000000000000000000000000000000000..b79bb327eaaa99e6852ccb9429880f9611c6a538
Binary files /dev/null and b/resources/music/bowser_spedup_theme.mp3 differ
diff --git a/resources/music/death_bowser_noooo.mp3 b/resources/music/death_bowser_noooo.mp3
new file mode 100644
index 0000000000000000000000000000000000000000..86ddec279da5894b75409795b747b9e4161f314f
Binary files /dev/null and b/resources/music/death_bowser_noooo.mp3 differ
diff --git a/resources/music/death_dio.wav b/resources/music/death_dio.wav
new file mode 100644
index 0000000000000000000000000000000000000000..4365defc0740eec02ce734015cd3c9f2753be9bc
Binary files /dev/null and b/resources/music/death_dio.wav differ
diff --git a/resources/music/death_son_of_bitch.wav b/resources/music/death_son_of_bitch.wav
new file mode 100644
index 0000000000000000000000000000000000000000..14270b6f6307dd7ea927813cc46df1ad25f71eb0
Binary files /dev/null and b/resources/music/death_son_of_bitch.wav differ
diff --git a/resources/music/dejavu.mp3 b/resources/music/dejavu.mp3
new file mode 100644
index 0000000000000000000000000000000000000000..c368c2e20c231f81feb390726d50b676a1392f37
Binary files /dev/null and b/resources/music/dejavu.mp3 differ
diff --git a/resources/music/gasgasgas.wav b/resources/music/gasgasgas.wav
new file mode 100644
index 0000000000000000000000000000000000000000..8a450a6e2168e535c0f6f1b440306874c715f0b9
Binary files /dev/null and b/resources/music/gasgasgas.wav differ
diff --git a/resources/music/running_in_the_90.wav b/resources/music/running_in_the_90.wav
new file mode 100644
index 0000000000000000000000000000000000000000..30660c028fbfa97914c264b605388c7ff6737437
Binary files /dev/null and b/resources/music/running_in_the_90.wav differ
diff --git a/resources/music/victory_bowser_yeahboy.mp3 b/resources/music/victory_bowser_yeahboy.mp3
new file mode 100644
index 0000000000000000000000000000000000000000..e3c4cb933f49251c0416ac40d749255a06ca30b0
Binary files /dev/null and b/resources/music/victory_bowser_yeahboy.mp3 differ
diff --git a/resources/music/victory_theme_cena.ogg b/resources/music/victory_theme_cena.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..0e72835b75ec205ad3c22fd9459af433726f90ca
Binary files /dev/null and b/resources/music/victory_theme_cena.ogg differ