Merge branch 'animationrework'

Conflicts:
	MAFH2/BattleEngine.py

44 files changed, 1220 insertions, 343 deletions

diff --git a/MAFH2/BattleEngine.py b/MAFH2/BattleEngine.py
index 598bb03..e9ae66e 100644
--- a/MAFH2/BattleEngine.py
+++ b/MAFH2/BattleEngine.py
@@ -2,8 +2,11 @@ from fortuneengine.GameEngineElement import GameEngineElement
 from Enemy import get_enemy
 from BattleMenu import BattleMenuHolder
 from MagicMenu import MagicMenuHolder
-from AnimatedSprite import Spritesheet
+from Spritesheet import Spritesheet
 from Items import get_item
+from fortuneengine.DrawableObject import DrawableObject
+from fortuneengine.DynamicDrawableObject import DynamicDrawableObject
+from fortuneengine.Scene import Scene
 import pygame
 import time
 
@@ -14,6 +17,7 @@ import random
 
 PLAYER_WAIT = 1
 PLAYER_MULT = 2
+_dirtyList=[]
 
 class BattleEngine(GameEngineElement):
     def __init__(self, dgn):
@@ -39,15 +43,21 @@ class BattleEngine(GameEngineElement):
             e_index = self.current_room.get_enemy( i )
 
             if e_index != '0':
-                self.enemy_list.append( get_enemy( e_index ) )
+                curE = get_enemy( e_index )
+                self.enemy_list.append( curE )
+                self.game_engine.get_scene().addObject(curE.get_sprite())
 
         # Preload images
-        self.__images = {}
+        self.__drawableObjects = {}
         for i in ['arrow_select']:
-            self.__images[i] = pygame.image.load( HUD_PATH + i + ".gif" )
+            self.__drawableObjects[i] = DrawableObject([pygame.image.load( HUD_PATH + i + ".gif" )], '')
+            self.game_engine.get_scene().addObject(self.__drawableObjects[i])
 
-        self.__images['hp'] = Spritesheet( HUD_PATH + "hp.png" ).img_extract(11,1,100,100)
-        self.__images['bt'] = Spritesheet( HUD_PATH + "bt.png" ).img_extract(1,11,100,25)
+        self.__drawableObjects['hp'] = DrawableObject(Spritesheet( HUD_PATH + "hp.gif" ).img_extract(11,1,100,100,[255,0,255]), '')
+        self.__drawableObjects['bt'] = DrawableObject(Spritesheet( HUD_PATH + "bt.gif" ).img_extract(1,11,100,25), '', True)
+        self.__drawableObjects['hp'].setColorKey((255,0,255))
+        self.game_engine.get_scene().addObject(self.__drawableObjects['hp'])
+        self.game_engine.get_scene().addObject(self.__drawableObjects['bt'])
 
         self.add_to_engine()
         self.game_engine.add_object('battlemenu', BattleMenuHolder( self.menu_callback ) )
@@ -313,6 +323,7 @@ class BattleEngine(GameEngineElement):
             if enemy.HP <= 0:
                 enemy.alive = False
                 self.enemy_list.remove(enemy)
+                enemy.get_sprite().makeTransparent(True)
                 self.active_target = 1
             if enemy.alive:
                 random.seed()
@@ -354,9 +365,13 @@ class BattleEngine(GameEngineElement):
                 room.remove_item( i )
                 self.game_engine.get_object('mesg').add_line(_("%s dropped!")% item.name)
         room.has_enemy = False
+        
         #self terminate
         #print 'end battle called'
         self.remove_from_engine()
+        for key in self.__drawableObjects:
+            self.game_engine.get_scene().removeObject(self.__drawableObjects[key])
+            
         self.game_engine.get_object('battlemenu').remove_from_engine()
         self.game_engine.remove_object('battle')
         
@@ -399,28 +414,28 @@ class BattleEngine(GameEngineElement):
         x=250
         y=150
         i = 1
-
+        
         tick_time = pygame.time.get_ticks()
 
         # Draw Enemy and Item Selection
         for enemy in self.enemy_list:
-            if enemy.alive:
-                if self.active_target == i:
-                    screen.blit(self.__images['arrow_select'], (x+(i*200),y-25))
-                enemy.sprite.update( tick_time )
-                screen.blit(enemy.sprite.image, (x+(i*200),y))
-                i = i+1
+            if enemy.alive and self.active_target == i:
+                self.__drawableObjects['arrow_select'].setPosition(x+(i*200),y-25)
+            enemy.get_sprite().setPosition(x+(i*200),y)
+            i = i+1
 
         # Draw Hud
         profile = self.game_engine.get_object('profile')
 
         # Player Health
         health = 10 - profile.hero.healthLevel()
-        screen.blit(self.__images['hp'][health], (25,25))
+
+        self.__drawableObjects['hp'].goToFrame(health)
+        self.__drawableObjects['hp'].setPosition(25,25)
         
         #Battle Timer
         if(self.battleTimer > 0):
             tIndex = int(time.time() - self.battleTimer)
             if tIndex > 10:
                 tIndex = 10
-            screen.blit(self.__images['bt'][tIndex], (25,130))
+            #screen.blit(self.__images['bt'][tIndex], (25,130))
diff --git a/MAFH2/BattleMenu.py b/MAFH2/BattleMenu.py
index 179bf29..bdd0919 100644
--- a/MAFH2/BattleMenu.py
+++ b/MAFH2/BattleMenu.py
@@ -1,5 +1,7 @@
 import pygame
 from fortuneengine.GameEngineElement import GameEngineElement
+from fortuneengine.DrawableObject import DrawableObject
+from fortuneengine.DrawableFontObject import DrawableFontObject
 
 from constants import MENU_PATH
 from gettext import gettext as _
@@ -12,35 +14,38 @@ class BattleMenuHolder( GameEngineElement ):
         GameEngineElement.__init__(self, has_draw=True, has_event=False)
         self.menu = None
         self.callback = callback
-        self.background = pygame.image.load(MENU_PATH + "battleMenubackground.gif")
-        self.disp = ""
-        self.sec_des = ""
+        self.background = DrawableObject([pygame.image.load( MENU_PATH + "battleMenubackground.gif")], '')
         self.font = pygame.font.SysFont("cmr10",18,False,False)
+        self.disp = DrawableFontObject("", self.font)
+        self.sec_disp = DrawableFontObject("", self.font)
+        self.game_engine.get_scene().addObject(self.background)
+        self.game_engine.get_scene().addObject(self.disp)
+        self.game_engine.get_scene().addObject(self.sec_disp)
 
     def set_disp(self, msg):
-        self.disp = msg
+        self.disp.changeText(msg, (0,0,0))
 
     def set_sec_disp(self, msg):
-        self.sec_des = msg
+        self.sec_disp.changeText(msg, (0,0,0))
 
     def remove_from_engine(self):
         super( BattleMenuHolder, self ).remove_from_engine()
+        self.game_engine.get_scene().removeObject(self.background)
+        self.game_engine.get_scene().removeObject(self.disp)
+        self.game_engine.get_scene().removeObject(self.sec_disp)
         self.clear_menu()
 
     def draw(self,screen,time_delta):
-        screen.blit(self.background,(0,286,452,414))
-        ren = self.font.render(self.disp, 1, (0,0,0))
-        screen.blit(ren, (250, 340))
-
-        ren = self.font.render(self.sec_des, 1, (0,0,0))
-        screen.blit(ren, (237, 375))
-
+        self.background.setPosition(0,286)
+        self.disp.setPosition(250,340)
+        self.sec_disp.setPosition(237, 375)
 
     def menu_called(self, id):
         self.callback(id, self)
 
     def clear_menu(self):
         if self.menu:
+            self.menu.clear()
             self.menu.remove_from_engine()
             self.menu = None
 
@@ -76,8 +81,6 @@ class BattleMenuHolder( GameEngineElement ):
                         [_("C"), lambda: self.menu_called('clear'),44,1],
                         ['0', lambda: self.menu_called('0'),44,1],
                         [_("E"), lambda: self.menu_called('enter'),44,1],
-                        #[_("Clear"), lambda: self.menu_called('clear'),89,2],
-                        #[_("Enter"), lambda: self.menu_called('enter'),134,3],
             ]
 
         elif id == "special":
@@ -107,9 +110,8 @@ class BattleMenu(GameEngineElement):
     def __init__(self, game_menu, x, y, type=NORMAL_MENU):
         GameEngineElement.__init__(self, has_draw=True, has_event=True)
 
-        self.menu = Menu(game_menu, type )
+        self.menu = Menu(game_menu, type, self.game_engine.get_scene(), x, y )
 
-        self.menu.set_pos(x, y)
         self.add_to_engine()
 
     def event_handler(self, event):
@@ -117,15 +119,19 @@ class BattleMenu(GameEngineElement):
 
     def draw(self,screen,time_delta):
         self.menu.draw( screen )
+    
+    def clear(self):
+        self.menu.clear()
 
 class Menu(object):
-    def __init__(self, options, cols):
+    def __init__(self, options, cols, scene, x=237, y=375):
         """Initialize the EzMenu! options should be a sequence of lists in the
         format of [option_name, option_function]"""
 
         self.options = options
-        self.x = 0
-        self.y = 0
+        self.scene = scene
+        self.x = x
+        self.y = y
         self.cols = cols
         self.font = pygame.font.SysFont("cmr10",18,False,False)
         self.option = 0
@@ -133,30 +139,66 @@ class Menu(object):
         self.color = [0, 0, 0]
         self.hcolor = [255, 0, 0]
         self.height = len(self.options)*self.font.get_height()
+        self.font_list = []
+        self.rect_list = []
+        
+        for o in self.options:
+            self.font_list.append(DrawableFontObject(o[0], self.font))
+            ren = self.font.render(o[0], 1, [0,0,0])
+            if ren.get_width() > self.width:
+                self.width = ren.get_width()
+
+        i=0 # Row Spacing
+        h=0 # Selection Spacing
+        j=0 # Col Spacing
+        for o in self.options:
+            newX = self.x + 45 * j
+            newY = self.y + i * 45
+            
+            surf = pygame.Surface((o[2],44))
+            surf.fill((0, 74, 94))
+            tempDO = DrawableObject([surf], "")
+            tempDO.setPosition(newX,newY)
+            self.rect_list.append(tempDO)
+            
+            surf = pygame.Surface((o[2]-4, 40))
+            surf.fill((4, 119, 152))
+            tempDO = DrawableObject([surf], "")
+            tempDO.setPosition(newX+2, newY+2)
+            self.rect_list.append(tempDO)
+
+            j+=o[3]
+            h+=1
+            if j >= self.cols:
+                i+=1
+                j=0
+            
+        self.scene.addObjects(self.rect_list)
+        self.scene.addObjects(self.font_list)
 
     def draw(self, surface):
+        self.scene.drawEntireScene(surface)
         """Draw the menu to the surface."""
         i=0 # Row Spacing
         h=0 # Selection Spacing
         j=0 # Col Spacing
+        k=1 # Rect Counter
         for o in self.options:
             if h==self.option:
                 clr = self.hcolor
             else:
                 clr = self.color
             text = o[0]
-            ren = self.font.render(text, 1, clr)
-            if ren.get_width() > self.width:
-                self.width = ren.get_width()
+            self.font_list[h].changeText(text, clr)
 
             newX = self.x + 45 * j
-            newY = self.y + i * 45            
-            pygame.draw.rect(surface, (0, 74, 94), ( newX, newY, o[2], 44))
-            pygame.draw.rect(surface, (4, 119, 152), ( newX + 2, newY + 2, o[2]-4, 40))
-            surface.blit(ren, (newX + 15, newY + 12))
+            newY = self.y + i * 45
+            
+            self.font_list[h].setPosition(newX + 15, newY + 12)
 
             j+=o[3]
             h+=1
+            k+=2
             if j >= self.cols:
                 i+=1
                 j=0
@@ -196,6 +238,12 @@ class Menu(object):
 
         return return_val
 
+    def clear(self):
+        for text in self.font_list:
+            self.scene.removeObject(text)
+        for rect in self.rect_list:
+            self.scene.removeObject(rect)
+
     def set_pos(self, x, y):
         """Set the topleft of the menu at x,y"""
         self.x = x
diff --git a/MAFH2/Dungeon.py b/MAFH2/Dungeon.py
index 3b7f39c..8791157 100644
--- a/MAFH2/Dungeon.py
+++ b/MAFH2/Dungeon.py
@@ -15,6 +15,9 @@ from constants import (
         ENTRANCE_DOOR, EXIT_DOOR
         )
 from JournalIntegration import do_load, load_dungeon_by_id
+from fortuneengine.DrawableObject import DrawableObject
+from fortuneengine.DynamicDrawableObject import DynamicDrawableObject
+from fortuneengine.Scene import Scene
 
 SEARCH_TIME = 2
 COLOR_DELTA = 255/SEARCH_TIME
@@ -34,6 +37,32 @@ class Dungeon(GameEngineElement):
             x,y = self.start
             profile.move_to( x, y )
 
+        
+
+        self.doorsList = []
+
+        self.game_engine.get_scene().addObject(DrawableObject([self.__images['Room']], ''))
+        self.doorsList.append(DrawableObject([self.__images['L']], '', True, 0 ,0))
+        self.doorsList.append(DrawableObject([self.__images['F']], '', True, 360 ,0))
+        self.doorsList.append(DrawableObject([pygame.transform.flip(self.__images['L'], True, False)], '', True, 990 ,0))
+        
+        #for door in self.doorsList: door.makeTransparent(True)
+
+        self.game_engine.get_scene().addObjects(self.doorsList)
+        
+        self.itemsList = []
+       
+        for i in range(4):
+            surf = pygame.Surface((10,10))
+            surf.fill((0,0,0))
+            tempItem = DrawableObject([surf],"", True)
+            self.itemsList.append(tempItem)
+            
+        self.itemsList[0].setPosition(self.game_engine.art_scale(270, 1200, True), self.game_engine.art_scale(330, 900, False))
+        self.itemsList[1].setPosition(self.game_engine.art_scale(100, 1200, True),self.game_engine.art_scale(600, 900, False))
+        self.itemsList[2].setPosition(self.game_engine.art_scale(1100, 1200, True),self.game_engine.art_scale(600, 900, False))
+        self.itemsList[3].setPosition(self.game_engine.art_scale(900, 1200, True),self.game_engine.art_scale(330, 900, False))
+        self.game_engine.get_scene().addObjects(self.itemsList)
         self.add_to_engine()
 
     def add_to_engine(self):
@@ -87,11 +116,11 @@ class Dungeon(GameEngineElement):
             img = pygame.image.load(LVL_PATH+img_key+".png").convert()
             img.set_colorkey((255,0,255))
             width,height = img.get_size()
-
+            
             img = pygame.transform.scale(img, (self.game_engine.art_scale(width, 1200, True), self.game_engine.art_scale(height, 900, False)))
 
             self.__images[img_key] = img
-
+            
     def get_current_room(self):
         profile = self.game_engine.get_object('profile')
         return self.rooms[profile.position]
@@ -277,28 +306,35 @@ class Dungeon(GameEngineElement):
         elif dir == WEST:
             return 'S', 'W', 'N'
 
+#-------------------------------------------------------------------------------------------------------------------------------------------------------
+# \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/
+#
     def draw(self,screen,time_delta):
         profile = self.game_engine.get_object('profile')
         dir = profile.playerFacing
         current_room = self.rooms[profile.position]
 
-        # Draw Room Background
-        screen.blit(self.__images['Room'],(0,0))
-
         # Draw Room Doors
         left, front, right = self.normalize_dir()
         if current_room.get_door( left ) != '0':
-            screen.blit(self.__images['L'],(0,0))
+            self.doorsList[0].makeTransparent(False)
+        else:
+            self.doorsList[0].makeTransparent(True)
 
         if current_room.get_door( front ) != '0':
-            screen.blit(self.__images['F'],( self.game_engine.art_scale(360, 1200, True),0))
+            self.doorsList[1].makeTransparent(False)
+        else:
+            self.doorsList[1].makeTransparent(True)
 
         if current_room.get_door( right ) != '0':
-            screen.blit(pygame.transform.flip(self.__images['L'], True, False),(self.game_engine.art_scale(990, 1200, True),0))
+            self.doorsList[2].makeTransparent(False)
+        else:
+            self.doorsList[2].makeTransparent(True)
 
         # Draw Items
         img_list = []
 
+        cnt = 0
         for i in range( dir, (dir + 4) ):
             #imod for room rotation
             imod = i % 4
@@ -306,30 +342,28 @@ class Dungeon(GameEngineElement):
             item_key = current_room.get_item( imod )
 
             if item_key[0] == '0' or item_key[1] != 'v':
-                path = "noItem.gif"
+                self.itemsList[cnt].makeTransparent(True)
             else:
-                path = get_item( item_key[0] ).path
-
-            if not self.__images.has_key( path ):
-                img = pygame.image.load(ITEM_PATH + path).convert()
-                width,height = img.get_size()
-                img = pygame.transform.scale(img, (self.game_engine.art_scale(width, 1200, True), self.game_engine.art_scale(height, 900, False)))
-                self.__images[path] = img
+                self.itemsList[cnt].repopulateImages([pygame.image.load(ITEM_PATH + get_item( item_key[0] ).path)])
+                self.itemsList[cnt].makeTransparent(False)
+                
+            cnt += 1
 
-            img_list.append( self.__images[path] )
+            #if not self.__images.has_key( path ):
+                #img = pygame.image.load(ITEM_PATH + path).convert()
+                #width,height = img.get_size()
+                #img = pygame.transform.scale(img, (self.game_engine.art_scale(width, 1200, True), self.game_engine.art_scale(height, 900, False)))
+                #self.__images[path] = img
 
-        screen.blit(img_list[0],(self.game_engine.art_scale(270, 1200, True),self.game_engine.art_scale(330, 900, False)))
-        screen.blit(img_list[1],(self.game_engine.art_scale(100, 1200, True),self.game_engine.art_scale(600, 900, False)))
-        screen.blit(img_list[2],(self.game_engine.art_scale(1100, 1200, True),self.game_engine.art_scale(600, 900, False)))
-        screen.blit(img_list[3],(self.game_engine.art_scale(900, 1200, True),self.game_engine.art_scale(330, 900, False)))
+            #img_list.append( self.__images[path] )
 
         #Amulet Search Function
-        if hasattr(self, 'pickup_time'):
-            elp = time() - self.pickup_time
-            color_a = int(elp*COLOR_DELTA)
-            if color_a > 255:
-                color_a = 255
-                self.game_engine.stop_event_timer(self.search_timer_handler)
-            surf1 = pygame.Surface((self.game_engine.width,self.game_engine.height), pygame.SRCALPHA)
-            pygame.draw.rect(surf1, (255, 255, 255, color_a), (0, 0, self.game_engine.width, self.game_engine.height))
-            screen.blit( surf1, (0, 0) )
+        # if hasattr(self, 'pickup_time'):
+#             elp = time() - self.pickup_time
+#             color_a = int(elp*COLOR_DELTA)
+#             if color_a > 255:
+#                 color_a = 255
+#                 self.game_engine.stop_event_timer(self.search_timer_handler)
+#             surf1 = pygame.Surface((self.game_engine.width,self.game_engine.height), pygame.SRCALPHA)
+#             pygame.draw.rect(surf1, (255, 255, 255, color_a), (0, 0, self.game_engine.width, self.game_engine.height))
+#             screen.blit( surf1, (0, 0) )
diff --git a/MAFH2/Enemy.py b/MAFH2/Enemy.py
index 0c9f8c0..477fef9 100644
--- a/MAFH2/Enemy.py
+++ b/MAFH2/Enemy.py
@@ -1,21 +1,23 @@
 from gettext import gettext as _
 from constants import CHAR_PATH
+#from drawableobject.DrawableObject import DrawableObject
+from fortuneengine.DynamicDrawableObject import DynamicDrawableObject
 class InvalidEnemyException(Exception): pass
 
 import pygame
 from Actor import Actor
-from AnimatedSprite import Spritesheet, AnimatedSprite
+from drawableobject.Spritesheet import Spritesheet
 ENEMY = {
-    '1':{'name':_('Wizard Adept'),'img':"anim_test.gif",'hp':20,'att':2,'weak':'special', 'sprite':(3,2, 156,166)}, #concept_wizard.png , (1,1, 181,365)
-    '2':{'name':_('Goblin'),'img':"dog~.png",'hp':40,'att':3,'weak':'fire','sprite':(2,1, 58/2,39)},                #concept_goblin.png , (1,1, 217,317)
-    '3':{'name':_('Orc'),'img':"concept_orc.png",'hp':50,'att':5,'weak':'lightning','sprite':(1,1, 264,338)},
-    '4':{'name':_('Stone Golem'),'img':"concept_orc.png",'hp':10,'att':6,'weak':'missile','sprite':(1,1, 264,338)},
-    '5':{'name':_('Serratula'),'img':"Crab.png",'hp':125,'att':12,'weak':'crit','sprite':(1,1,400,400)},
-    '6':{'name':_('Feren'),'img':"faren.png",'hp':1500,'att':10,'weak':'special','sprite':(1,1,250,250)},
-    '7':{'name':_('Cave Crab'),'img':"Crab.png",'hp':50,'att':7,'weak':'missile','sprite':(1,1,400,400)},
-    '8':{'name':_('Frost Giant'),'img':"frost_giant.png",'hp':45,'att':9,'weak':'fire','sprite':(1,1,250,250)},
+    '1':{'name':_('Wizard Adept'),'img':"anim_test.gif",'hp':20,'att':2,'weak':'special', 'sprite':(3,2, 156,166)}, #concept_wizard.gif , (1,1, 181,365)
+    '2':{'name':_('Goblin'),'img':"dragon.gif",'hp':40,'att':3,'weak':'fire','sprite':(10,8, 75,70)},                #concept_goblin.gif , (1,1, 217,317)
+    '3':{'name':_('Orc'),'img':"concept_orc.gif",'hp':50,'att':5,'weak':'lightning','sprite':(1,1, 264,338)},
+    '4':{'name':_('Stone Golem'),'img':"concept_orc.gif",'hp':10,'att':6,'weak':'missile','sprite':(1,1, 264,338)},
+    '5':{'name':_('Serratula'),'img':"Crab.gif",'hp':125,'att':12,'weak':'crit','sprite':(1,1,400,400)},
+    '6':{'name':_('Feren'),'img':"faren.gif",'hp':1500,'att':10,'weak':'special','sprite':(1,1,250,250)},
+    '7':{'name':_('Cave Crab'),'img':"Crab.gif",'hp':50,'att':7,'weak':'missile','sprite':(1,1,400,400)},
+    '8':{'name':_('Frost Giant'),'img':"frost_giant.gif",'hp':45,'att':9,'weak':'fire','sprite':(1,1,250,250)},
     #UPDATE BONESPROUT VALUES
-    '9':{'name':_('Bonesprout'),'img':"bonesprout.png",'hp':45,'att':8,'weak':'fire','sprite':(1,1,250,250)},
+    '9':{'name':_('Bonesprout'),'img':"bonesprout.gif",'hp':45,'att':8,'weak':'fire','sprite':(1,1,250,250)},
     'a':{'name':_('anim_test'),'img':"anim_test.gif",'hp':45,'att':9,'weak':'fire','sprite':(3,2, 156,166)},
 }
 
@@ -30,7 +32,7 @@ class Enemy(Actor):
         self.inv_Ar = []
         self.attacks_Ar = []
         col,row,width,height = ENEMY[id]['sprite']
-        self.sprite=AnimatedSprite(Spritesheet(CHAR_PATH + ENEMY[id]['img']).img_extract(col,row,width,height))
+        self.sprite = DynamicDrawableObject( Spritesheet(CHAR_PATH + ENEMY[id]['img'] ).img_extract(col,row,width,height) , "", 30)
         self.place=0
         self.alive = True
 
@@ -50,11 +52,14 @@ class Enemy(Actor):
             return int((self.ATT+self.BAE) * 1.5)
         elif name=="special":
             return int((self.ATT+self.BAE) * 1.3)
-
+    
+    def get_sprite(self):
+        return self.sprite
 
 def get_enemy(key):
     if key in ENEMY:
         return Enemy( key )
     else:
         raise InvalidEnemyException()
+        
 
diff --git a/MAFH2/MafhActivity.py b/MAFH2/MafhActivity.py
index f8cfee5..584d83d 100755
--- a/MAFH2/MafhActivity.py
+++ b/MAFH2/MafhActivity.py
@@ -1,14 +1,13 @@
 #!/usr/bin/env python
 from fortuneengine.GameEngine import GameEngine
 from MafhGameMenu import GameMenuHolder
-
 from constants import MENU_PATH, FMC_PATH, TOUR_PATH
 
 from Comic import Comic
 from Profile import Profile
 from MafhGameManager import MafhGameManager
 
-ge = GameEngine(width=1200, height=900, always_draw=True)
+ge = GameEngine(width=1200, height=900, always_draw=True, fps_cap=15)
 
 def start_game():
     ge.add_object('manager', MafhGameManager() )
diff --git a/MAFH2/MafhGameMenu.py b/MAFH2/MafhGameMenu.py
index a7c5abe..959ad29 100644
--- a/MAFH2/MafhGameMenu.py
+++ b/MAFH2/MafhGameMenu.py
@@ -1,23 +1,26 @@
 import pygame, ezmenu
 from fortuneengine.GameEngineElement import GameEngineElement
+from fortuneengine.DrawableObject import DrawableObject
 
 class GameMenuHolder( GameEngineElement ):
     def __init__(self, callback, background=None, width=1200, height=900):
         GameEngineElement.__init__(self, has_draw=True, has_event=False)
         self.menu = None
         self.callback = callback
-        bg = pygame.image.load(background).convert()
-        self.background = pygame.transform.scale(bg, (width, height))
+        self.background = DrawableObject([pygame.image.load(background).convert()], '')
+        self.background.scale(width, height)
+        self.game_engine.get_scene().addObject(self.background)
         self.width = width
         self.height = height
 
     def remove_from_engine(self):
+        self.game_engine.get_scene().removeObject(self.background)
         super( GameMenuHolder, self ).remove_from_engine()
         self.clear_menu()
 
     def draw(self,screen,time_delta):
         if self.background:
-            screen.blit(self.background,(0,0))
+            self.background.setPosition(0,0)
         else:
             screen.fill((0, 0, 255))
 
@@ -26,6 +29,7 @@ class GameMenuHolder( GameEngineElement ):
 
     def clear_menu(self):
         if self.menu:
+            self.menu.clear_menu()
             self.menu.remove_from_engine()
             self.menu = None
 
@@ -104,7 +108,7 @@ class GameMenuHolder( GameEngineElement ):
 class GameMenu(GameEngineElement):
     def __init__(self, game_menu, width=800, height=400):
         GameEngineElement.__init__(self, has_draw=True, has_event=True)
-        self.menu = ezmenu.EzMenu(game_menu)
+        self.menu = ezmenu.EzMenu(game_menu, self.game_engine.get_scene())
         self.menu.center_at(width - (width/3), height/2)
         self.menu.help_text_at( 0, height-(height/10))
         self.menu.set_font(pygame.font.SysFont("Arial", 20))
@@ -115,5 +119,8 @@ class GameMenu(GameEngineElement):
     def event_handler(self, event):
         return self.menu.update(event)
 
+    def clear_menu(self):
+        self.menu.clear_menu()
+        
     def draw(self,screen,time_delta):
         self.menu.draw( screen )
diff --git a/MAFH2/MagicMenu.py b/MAFH2/MagicMenu.py
index 42d4bd9..8e4ea56 100644
--- a/MAFH2/MagicMenu.py
+++ b/MAFH2/MagicMenu.py
@@ -1,6 +1,8 @@
 import pygame
 import random
 from fortuneengine.GameEngineElement import GameEngineElement
+from fortuneengine.DrawableObject import DrawableObject
+from fortuneengine.DynamicDrawableObject import DynamicDrawableObject
 from AnimatedSprite import Spritesheet
 
 from constants import MENU_PATH, PUZZLE_PATH
@@ -12,20 +14,24 @@ class MagicMenuHolder( GameEngineElement ):
         GameEngineElement.__init__(self, has_draw=True, has_event=False)
         self.menu = None
         self.callback = callback
-        self.background = pygame.image.load(MENU_PATH + "battleMenubackground.gif")
+        self.background = DrawableObject([pygame.image.load( MENU_PATH + "battleMenubackground.gif")], '')
+        self.background.setPosition(0,286)
+        self.game_engine.get_scene().addObject(self.background)
 
     def remove_from_engine(self):
+        self.game_engine.get_scene().removeObject(self.background)
         super( MagicMenuHolder, self ).remove_from_engine()
         self.clear_menu()
         
     def draw(self,screen,time_delta):
-        screen.blit(self.background,(0,286,452,414))
+        pass
 
     def menu_called(self, id):
         self.callback(id, self)
 
     def clear_menu(self):
         if self.menu:
+            self.menu.clear()
             self.menu.remove_from_engine()
             self.menu = None
             
@@ -89,9 +95,7 @@ class MagicMenu(GameEngineElement):
     def __init__(self, menu_options, x, y, spell_type):
         GameEngineElement.__init__(self, has_draw=True, has_event=True)
         magic_list = self.game_engine.get_object('battle').magic_list
-        self.menu = Menu(menu_options, spell_type, magic_list)
-        
-
+        self.menu = Menu(menu_options, spell_type, magic_list, self.game_engine.get_scene())
         self.menu.set_pos(x, y)
         self.add_to_engine()
 
@@ -100,12 +104,16 @@ class MagicMenu(GameEngineElement):
 
     def draw(self,screen,time_delta):
         self.menu.draw( screen )
+    
+    def clear(self):
+        self.menu.clear()
 
 class Menu(object):
-    def __init__(self, options, spelltype, magic_list):
+    def __init__(self, options, spelltype, magic_list, scene):
         """Initialize the EzMenu! options should be a sequence of lists in the
         format of [option_name, option_function]"""
         
+        self.scene = scene
         self.buttons = []
         self.options = options
         self.x = 0
@@ -115,6 +123,7 @@ class Menu(object):
         self.width = 2
         self.spelltype = spelltype
         self.magic_list = magic_list
+        self.reference = []
         
         lightning = []
         fire = []
@@ -130,56 +139,56 @@ class Menu(object):
         if(spelltype == 0):
             #fire attack
             for i in range(4):
-                self.buttons.append(pygame.transform.scale(fire[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(fire[i] , (60,60))], ""))
             #filler buttons
             for i in range(0,2):
-                self.buttons.append(pygame.transform.scale(lightning[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(lightning[i] , (60,60))], ""))
             random.seed()
-            self.buttons.append(pygame.transform.scale(heal[random.randint(0,3)] , (60,60)))
-            self.buttons.append(pygame.transform.scale(missile[random.randint(0,3)] , (60,60)))
+            self.buttons.append(DrawableObject([pygame.transform.scale(heal[random.randint(0,3)] , (60,60))], ""))
+            self.buttons.append(DrawableObject([pygame.transform.scale(missile[random.randint(0,3)] , (60,60))], ""))
             
-            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "FireGlyph.gif").convert()
+            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "FireGlyph.gif").convert_alpha()
             self.glyphs = fire
             
         elif(spelltype == 1):
             #lightning attack
             for i in range(4):
-                self.buttons.append(pygame.transform.scale(lightning[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(lightning[i] , (60,60))], ""))
             #filler buttons
             for i in range(0,2):
-                self.buttons.append(pygame.transform.scale(fire[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(fire[i] , (60,60))], ""))
             random.seed()
-            self.buttons.append(pygame.transform.scale(heal[random.randint(0,3)] , (60,60)))
-            self.buttons.append(pygame.transform.scale(missile[random.randint(0,3)] , (60,60)))
+            self.buttons.append(DrawableObject([pygame.transform.scale(heal[random.randint(0,3)] , (60,60))], ""))
+            self.buttons.append(DrawableObject([pygame.transform.scale(missile[random.randint(0,3)] , (60,60))], ""))
             
-            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "LightningGlyph.gif").convert()
+            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "LightningGlyph.gif").convert_alpha()
             self.glyphs = lightning
             
         elif(spelltype == 2):
             #missile attack
             for i in range(4):
-                self.buttons.append(pygame.transform.scale(missile[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(missile[i] , (60,60))], ""))
             #filler buttons
             for i in range(0,2):
-                self.buttons.append(pygame.transform.scale(lightning[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(lightning[i] , (60,60))], ""))
             random.seed()
-            self.buttons.append(pygame.transform.scale(heal[random.randint(0,3)] , (60,60)))
-            self.buttons.append(pygame.transform.scale(fire[random.randint(0,3)] , (60,60)))
+            self.buttons.append(DrawableObject([pygame.transform.scale(heal[random.randint(0,3)] , (60,60))], ""))
+            self.buttons.append(DrawableObject([pygame.transform.scale(fire[random.randint(0,3)] , (60,60))], ""))
             
-            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "MissileGlyph.gif").convert()
+            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "MissileGlyph.gif").convert_alpha()
             self.glyphs = missile
         elif(spelltype == 3):
             #heal
             for i in range(4):
-                self.buttons.append(pygame.transform.scale(heal[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(heal[i] , (60,60))], ""))
             #filler buttons
             for i in range(0,2):
-                self.buttons.append(pygame.transform.scale(lightning[i] , (60,60)))
+                self.buttons.append(DrawableObject([pygame.transform.scale(lightning[i] , (60,60))], ""))
             random.seed()
-            self.buttons.append(pygame.transform.scale(missile[random.randint(0,3)] , (60,60)))
-            self.buttons.append(pygame.transform.scale(fire[random.randint(0,3)] , (60,60)))
+            self.buttons.append(DrawableObject([pygame.transform.scale(missile[random.randint(0,3)] , (60,60))], ""))
+            self.buttons.append(DrawableObject([pygame.transform.scale(fire[random.randint(0,3)] , (60,60))], ""))
             
-            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "HealGlyph.gif").convert()
+            self.mainGlyph = pygame.image.load(PUZZLE_PATH + "HealGlyph.gif").convert_alpha()
             self.glyphs = heal
         
         deck = [0,1,2,3,4,5,6,7]
@@ -194,7 +203,25 @@ class Menu(object):
         self.buttons = tButtons
         self.options = tOptions
         
-        self.height = (len(self.options)*self.buttons[1].get_height()) / self.cols
+        surf = pygame.Surface((60,60))
+        surf.fill((4, 119, 152))
+        self.selectRect = DynamicDrawableObject([surf],"")
+        self.selectRect.setPosition(297, 435)
+        self.scene.addObject(self.selectRect)
+        self.scene.addObjects(self.buttons)
+        
+        self.mainGlyph.set_colorkey((255,0,255), pygame.RLEACCEL)
+        self.mainGlyphDO = DrawableObject([self.mainGlyph],"")
+        self.mainGlyphDO.setPosition(485,350)
+        
+        for image in self.glyphs:
+            tempDO = DrawableObject([image],"",True)
+            #tempDO.makeTransparent(True)
+            self.reference.append(tempDO)
+        self.scene.addObjects(self.reference)
+        self.scene.addObject(self.mainGlyphDO)
+        
+        self.height = (len(self.options)*self.buttons[1].getYSize()) / self.cols
 
     def draw(self, surface):
         """Draw the menu to the surface."""
@@ -202,8 +229,8 @@ class Menu(object):
         h=0 # Selection Spacing
         j=0 # Col Spacing
         index=0 #current spot in buttons list
-        height = self.buttons[0].get_height()
-        width = self.buttons[0].get_width()
+        height = 60
+        width = 60
         
         for o in self.options:
 
@@ -211,8 +238,9 @@ class Menu(object):
             newY = self.y + i * height
             
             if h==self.option:
-                pygame.draw.rect(surface, (4, 119, 152), ( newX, newY, height, width))
-            surface.blit(self.buttons[index], (newX, newY) )
+                self.selectRect.setPosition(newX, newY)
+            self.buttons[index].setPosition(newX, newY)
+            #surface.blit(self.buttons[index], (newX, newY) )
 
             j+=1
             h+=1
@@ -221,14 +249,12 @@ class Menu(object):
                 i+=1
                 j=0
                 
-        self.mainGlyph.set_colorkey((255,0,255), pygame.RLEACCEL)
-        surface.blit(self.mainGlyph, (485,350))
-        
-        
         # Draw reference glyphs
         for i in range(4):
             if i in self.magic_list:
-                surface.blit(self.glyphs[i], (800+((i%2) * 150), 350+(i/2 * 150)))
+                #surface.blit(self.glyphs[i], (800+((i%2) * 150), 350+(i/2 * 150)))
+                self.reference[i].makeTransparent(False)
+                self.reference[i].setPosition(800+((i%2) * 150), 350+(i/2 * 150))
                 
     def update(self, event):
         """Update the menu and get input for the menu."""
@@ -262,6 +288,14 @@ class Menu(object):
 
         return return_val
 
+    def clear(self):
+        for object in self.buttons:
+            self.scene.removeObject(object)
+        for object in self.reference:
+            self.scene.removeObject(object)
+        self.scene.removeObject(self.mainGlyphDO)
+        self.scene.removeObject(self.selectRect)
+
     def set_pos(self, x, y):
         """Set the topleft of the menu at x,y"""
         self.x = x
diff --git a/MAFH2/Map.py b/MAFH2/Map.py
index 36f4b28..b882433 100644
--- a/MAFH2/Map.py
+++ b/MAFH2/Map.py
@@ -1,162 +1,178 @@
-import pygame
-import math
-
-from constants import (
-    NORTH, EAST, WEST, SOUTH,UNLOCKED_DOOR, LOCKED_DOOR, PUZZLE_DOOR,
-    LOCKED_PUZZLE_DOOR, ENTRANCE_DOOR, EXIT_DOOR
-)
-from fortuneengine.GameEngineElement import GameEngineElement
-
-from gettext import gettext as _
-
-class Map(GameEngineElement):
-    def __init__(self, dgn):
-        GameEngineElement.__init__(self, has_draw=True, has_event=True)
-
-        self.draw_macro_set = False
-        self.sizeX=dgn.sizeX
-        self.sizeY=dgn.sizeY
-        self.rectSizeX=38
-        self.rectSizeY=38
-        self.rects={}
-        self.fullRooms={}
-        self.totalSurface=pygame.Surface((self.sizeX*40,self.sizeY*40))
-
-        for y in range(self.sizeY):
-            for x in range(self.sizeX):
-                curRect=pygame.Rect(x*40,y*40,self.rectSizeX,self.rectSizeX)
-                self.rects[(x,y)]=curRect
-                if dgn.rooms.get((x,y)).get_door('N') != '0':
-                    self.fullRooms[(x,y)]=True
-                    self.totalSurface.fill((255,255,255),curRect,0)
-
-                elif dgn.rooms.get((x,y)).get_door('S') != '0':
-                    self.fullRooms[(x,y)]=True
-                    self.totalSurface.fill((255,255,255),curRect,0)
-
-                elif dgn.rooms.get((x,y)).get_door('E') != '0':
-                    self.fullRooms[(x,y)]=True
-                    self.totalSurface.fill((255,255,255),curRect,0)
-
-                elif dgn.rooms.get((x,y)).get_door('W') != '0':
-                    self.fullRooms[(x,y)]=True
-                    self.totalSurface.fill((255,255,255),curRect,0)
-
-        self.add_to_engine()
-
-    def event_handler(self, event):
-        if event.type == pygame.KEYDOWN:
-            newKey=pygame.key.name(event.key)
-
-            if newKey=='m' or newKey=='[7]':
-                self.draw_macro_set = not self.draw_macro_set
-                return True
-
-        #Disable other events if macro-map set
-        if self.draw_macro_set:
-            return True
-
-    def draw(self,screen,time_delta):
-        profile = self.game_engine.get_object('profile')
-        x, y = profile.position
-        playerFacing = profile.playerFacing
-
-        mapView=pygame.transform.chop(self.totalSurface,(0,0,0,0))
-        mapView.fill((255,0,0),( x * 40, y * 40,38,38))
-
-        angle = 0
-
-        if playerFacing==NORTH:
-            angle=0
-            mapView=pygame.transform.rotate(mapView,angle)
-            angle=90
-        elif playerFacing==SOUTH:
-            angle=180
-            mapView=pygame.transform.rotate(mapView,angle)
-            angle=270
-        elif playerFacing==EAST:
-            angle=90
-            mapView=pygame.transform.rotate(mapView,angle)
-            angle=0
-        elif playerFacing==WEST:
-            angle=270
-            mapView=pygame.transform.rotate(mapView,angle)
-            angle=180
-
-        sideDifference=self.sizeX-self.sizeY
-        angle=angle*(math.pi/180)
-        curSect=pygame.Rect(0,0,200,200)
-        curSect.top+=((x*40-81)*math.cos(angle))-((y*40-81)*math.sin(angle))
-        curSect.left-=((x*40-81)*math.sin(angle))+((y*40-81)*math.cos(angle))
-
-        if playerFacing==EAST:
-            curSect.top+=sideDifference*(40-81)
-
-        elif playerFacing==SOUTH:
-            curSect.left+=sideDifference*(40-81)
-
-        map_area = (0,700,200,350)
-
-        mini_map = pygame.Surface( (200,200) )
-        mini_map.blit( mapView, curSect )
-        screen.fill(0,map_area,0)
-        screen.blit(mini_map, map_area)
-
-        if self.draw_macro_set:
-            self.draw_macro(self, screen)
-
-
-    def draw_macro(self,player,screen):
-        #DRAW LEGEND
-        font=pygame.font.SysFont("cmr10",24,False,False)
-
-        macroMap=pygame.transform.scale(self.totalSurface,(self.sizeX*100,self.sizeY*100))
-        screen.fill((0,0,0),(200,0,800,700))
-        legend=pygame.Surface((200,300))
-        legend.fill((255,0,0),(0,0,40,15))
-        legend.blit(font.render(_("LOCKED"),True,(255,0,0)),(45,0,30,5))
-        legend.fill((150,255,150),(0,25,40,15))
-        legend.blit(font.render(_("OPEN"),True,(150,255,150)),(45,25,30,5))
-        legend.fill((255,0,255),(0,50,40,15))
-        legend.blit(font.render(_("PUZZLE"),True,(255,0,255)),(45,50,30,5))
-        legend.fill((255,255,255),(0,75,40,15))
-        legend.blit(font.render(_("EXIT"),True,(255,255,255)),(45,75,30,5))
-        legend.fill((50,50,50),(0,100,40,15))
-        legend.blit(font.render(_("ENTRANCE"),True,(50,50,50)),(45,100,30,5))
-        screen.blit(legend,(800,0,300,300))
-        screen.blit(macroMap,(200,0,800,700))
-
-    def update_macro(self):
-        profile = self.game_engine.get_object('profile')
-        x, y = profile.position
-        playerFacing = profile.playerFacing
-
-        self.totalSurface.fill((0,255,0),( x * 40, y * 40,38,38))
-
-        current_room = self.game_engine.get_object('dungeon').rooms[profile.position]
-
-        map_filler = [
-                        ('N',(x * 40+5, y * 40,30,5) ),
-                        ('S',(x * 40+5, y * 40+35,30,5) ),
-                        ('E',(x * 40+35, y * 40+5,5,30) ),
-                        ('W',(x * 40, y * 40+5,5,30) )
-                     ]
-
-        for dir, filldata in map_filler:
-
-            door_flag = current_room.get_door( dir )
-
-            if door_flag == LOCKED_DOOR or door_flag == LOCKED_PUZZLE_DOOR:
-                self.totalSurface.fill( (255,0,0), filldata)
-
-            elif door_flag == UNLOCKED_DOOR:
-                self.totalSurface.fill((150,255,150), filldata)
-
-            elif door_flag == PUZZLE_DOOR:
-                self.totalSurface.fill((255,0,255), filldata)
-
-            elif door_flag == EXIT_DOOR:
-                self.totalSurface.fill((255,255,255), filldata)
-
-            elif door_flag == ENTRANCE_DOOR:
-                self.totalSurface.fill((0,0,0), filldata)
+import pygame

+import math

+

+from constants import (

+    NORTH, EAST, WEST, SOUTH,UNLOCKED_DOOR, LOCKED_DOOR, PUZZLE_DOOR,

+    LOCKED_PUZZLE_DOOR, ENTRANCE_DOOR, EXIT_DOOR

+)

+from fortuneengine.GameEngineElement import GameEngineElement

+from fortuneengine.DrawableObject import DrawableObject

+from fortuneengine.DynamicDrawableObject import DynamicDrawableObject

+from fortuneengine.Scene import Scene

+

+from gettext import gettext as _

+

+class Map(GameEngineElement):

+    def __init__(self, dgn):

+        GameEngineElement.__init__(self, has_draw=True, has_event=True)

+

+        self.draw_macro_set = False #A boolean value to determine whether the large map should draw

+        self.sizeX=dgn.sizeX #A variable that represents the number of rooms wide the dungeon is

+        self.sizeY=dgn.sizeY #A variable that represents the number of rooms tall the dungeon is

+        self.rectSizeX=38 #A variable representing the X size of a given room on the mini map

+        self.rectSizeY=38 #A variable representing the Y size of a given room on the mini map

+        self.rects={} #A dictionary of rectangles that represent the rooms on the map

+        self.fullRooms={} #A dictionary representing nothing?

+        self.totalSurface=pygame.Surface((self.sizeX*40,self.sizeY*40)) #A rect representing the size of the map as a whole

+

+        #A Two dimensional For Loop that goes through all of the positions on the map.

+        for y in range(self.sizeY):

+            for x in range(self.sizeX):

+                curRect=pygame.Rect(x*40,y*40,self.rectSizeX,self.rectSizeX) #Creating a rectangle for the current position on the map.

+                self.rects[(x,y)]=curRect #Adds the rectangle associated with the current position to the dictionary using the position on the map as the key.

+                #Each 'if' tests whether there is a door in a given direction at the current position.

+                #If there is a door in the given direction, it fills the square associated with themeans that the position has a room and fills it accordingly.

+                if dgn.rooms.get((x,y)).get_door('N') != '0':

+                    self.fullRooms[(x,y)]=True

+                    self.totalSurface.fill((255,255,255),curRect,0)

+

+                elif dgn.rooms.get((x,y)).get_door('S') != '0':

+                    self.fullRooms[(x,y)]=True

+                    self.totalSurface.fill((255,255,255),curRect,0)

+

+                elif dgn.rooms.get((x,y)).get_door('E') != '0':

+                    self.fullRooms[(x,y)]=True

+                    self.totalSurface.fill((255,255,255),curRect,0)

+

+                elif dgn.rooms.get((x,y)).get_door('W') != '0':

+                    self.fullRooms[(x,y)]=True

+                    self.totalSurface.fill((255,255,255),curRect,0)

+

+        self.add_to_engine() #Adds itself and all callbacks to the engine

+        

+        self.myDrawableObject = DrawableObject([pygame.Surface((0,0))], '')

+        self.game_engine.get_scene().addObject(self.myDrawableObject)

+

+    def event_handler(self, event):

+        if event.type == pygame.KEYDOWN:

+            newKey=pygame.key.name(event.key)

+

+            if newKey=='m' or newKey=='[7]':

+                self.draw_macro_set = not self.draw_macro_set

+                return True

+

+        #Disable other events if macro-map set

+        if self.draw_macro_set:

+            return True

+

+    def draw(self,screen,time_delta):

+        profile = self.game_engine.get_object('profile') #Creates a copy of the profile object

+        x, y = profile.position #Grabs the position of the player from the profiler

+        playerFacing = profile.playerFacing #Grabs the direction the player is facing from the profiler

+

+        mapView=pygame.transform.chop(self.totalSurface,(0,0,0,0))

+        mapView.fill((255,0,0),( x * 40, y * 40,38,38))

+

+        angle = 0

+

+        if playerFacing==NORTH:

+            angle=0

+            mapView=pygame.transform.rotate(mapView,angle)

+            angle=90

+        elif playerFacing==SOUTH:

+            angle=180

+            mapView=pygame.transform.rotate(mapView,angle)

+            angle=270

+        elif playerFacing==EAST:

+            angle=90

+            mapView=pygame.transform.rotate(mapView,angle)

+            angle=0

+        elif playerFacing==WEST:

+            angle=270

+            mapView=pygame.transform.rotate(mapView,angle)

+            angle=180

+

+        sideDifference=self.sizeX-self.sizeY #Getting the difference between the height and width of the dungeon

+        angle=angle*(math.pi/180) #Getting the angle the dungeon is rotated to

+        curSect=pygame.Rect(0,0,200,200) #Creating the rectangle for the mini-map

+        #Sets the position of the mini-map rectangle

+        curSect.top+=((x*40-81)*math.cos(angle))-((y*40-81)*math.sin(angle))

+        curSect.left-=((x*40-81)*math.sin(angle))+((y*40-81)*math.cos(angle))

+

+        if playerFacing==EAST:

+            curSect.top+=sideDifference*(40-81)

+

+        elif playerFacing==SOUTH:

+            curSect.left+=sideDifference*(40-81)

+

+        map_area = (0,700,200,350)

+

+        mini_map = pygame.Surface( (200,200) )

+        mini_map.blit( mapView, curSect )

+        

+        self.myDrawableObject.repopulateImages([mini_map])

+        self.myDrawableObject.setPosition(0,700)

+        screen.fill(0,map_area,0)

+        if self.draw_macro_set:

+            self.draw_macro(self, screen)

+

+

+    def draw_macro(self,player,screen):

+        #DRAW LEGEND

+        font=pygame.font.SysFont("cmr10",24,False,False)

+

+        macroMap=pygame.transform.scale(self.totalSurface,(self.sizeX*100,self.sizeY*100))

+        tempScreen = pygame.Surface((800,700))

+        tempScreen.fill((0,0,0))

+        #screen.fill((0,0,0),(200,0,800,700))

+        legend=pygame.Surface((200,300))

+        legend.fill((255,0,0),(0,0,40,15))

+        legend.blit(font.render(_("LOCKED"),True,(255,0,0)),(45,0,30,5))

+        legend.fill((150,255,150),(0,25,40,15))

+        legend.blit(font.render(_("OPEN"),True,(150,255,150)),(45,25,30,5))

+        legend.fill((255,0,255),(0,50,40,15))

+        legend.blit(font.render(_("PUZZLE"),True,(255,0,255)),(45,50,30,5))

+        legend.fill((255,255,255),(0,75,40,15))

+        legend.blit(font.render(_("EXIT"),True,(255,255,255)),(45,75,30,5))

+        legend.fill((50,50,50),(0,100,40,15))

+        legend.blit(font.render(_("ENTRANCE"),True,(50,50,50)),(45,100,30,5))

+        tempScreen.blit(macroMap, (0,0))

+        tempScreen.blit(legend, (600,0))

+        self.myDrawableObject.repopulateImages([tempScreen])

+        self.myDrawableObject.setPosition(200,0)

+        

+

+    def update_macro(self):

+        profile = self.game_engine.get_object('profile')

+        x, y = profile.position

+        playerFacing = profile.playerFacing

+

+        self.totalSurface.fill((0,255,0),( x * 40, y * 40,38,38))

+

+        current_room = self.game_engine.get_object('dungeon').rooms[profile.position]

+

+        map_filler = [

+                        ('N',(x * 40+5, y * 40,30,5) ),

+                        ('S',(x * 40+5, y * 40+35,30,5) ),

+                        ('E',(x * 40+35, y * 40+5,5,30) ),

+                        ('W',(x * 40, y * 40+5,5,30) )

+                     ]

+

+        for dir, filldata in map_filler:

+

+            door_flag = current_room.get_door( dir )

+

+            if door_flag == LOCKED_DOOR or door_flag == LOCKED_PUZZLE_DOOR:

+                self.totalSurface.fill( (255,0,0), filldata)

+

+            elif door_flag == UNLOCKED_DOOR:

+                self.totalSurface.fill((150,255,150), filldata)

+

+            elif door_flag == PUZZLE_DOOR:

+                self.totalSurface.fill((255,0,255), filldata)

+

+            elif door_flag == EXIT_DOOR:

+                self.totalSurface.fill((255,255,255), filldata)

+

+            elif door_flag == ENTRANCE_DOOR:

+                self.totalSurface.fill((0,0,0), filldata)

diff --git a/MAFH2/Profile.py b/MAFH2/Profile.py
index 10ed89c..0680118 100644
--- a/MAFH2/Profile.py
+++ b/MAFH2/Profile.py
@@ -1,6 +1,8 @@
 import pygame
 
 from fortuneengine.GameEngineElement import GameEngineElement
+from fortuneengine.DrawableFontObject import DrawableFontObject
+from fortuneengine.DrawableObject import DrawableObject
 from constants import MENU_PATH, NORTH, RIGHT, LEFT
 from Hero import Hero
 from Dungeon import Dungeon
@@ -31,6 +33,27 @@ class Profile(GameEngineElement):
         self.puzzlesSolved=0
         self.inventory = []
 
+        bg = pygame.image.load(MENU_PATH+"mafh_splash.gif").convert()
+        self.background = DrawableObject([bg], '')
+        self.background.scale(self.game_engine.width, self.game_engine.height)
+        self.game_engine.get_scene().addObject(self.background)
+
+        #create background rect
+        draw_width = self.game_engine.width/4
+        draw_height = self.game_engine.height/4
+        surf = pygame.Surface((draw_width+60,draw_height+60))
+        surf.fill((150,150,255))
+        self.blueRect = DrawableObject([surf],"")
+        self.game_engine.get_scene().addObject(self.blueRect)
+        
+        font = pygame.font.Font(None, 16)
+        self.text_list = []
+        self.text_list.append(DrawableFontObject("1", font))
+        self.text_list.append(DrawableFontObject("2", font))
+        self.text_list.append(DrawableFontObject("name",font))
+        self.game_engine.get_scene().addObjects(self.text_list)
+        
+        
         if recall_string:
             self.load_from_json_string( recall_string )
 
@@ -87,14 +110,16 @@ class Profile(GameEngineElement):
         self.inventory = new_inv
 
     def add_to_engine(self):
-        bg = pygame.image.load(MENU_PATH+"mafh_splash.gif").convert()
-        self.background_img = pygame.transform.scale(bg, (self.game_engine.width, self.game_engine.height))
         super( Profile, self).add_to_engine()
 
     def remove_from_engine(self):
         super( Profile, self).remove_from_engine()
-        del self.background_img
-
+        self.game_engine.get_scene().removeObject(self.background)
+        self.game_engine.get_scene().removeObject(self.blueRect)
+        
+        for dfo in self.text_list:
+            self.game_engine.get_scene().removeObject(dfo)
+            
     def event_handler(self, event):
         """
         Handles user input (used only for name entry)
@@ -120,13 +145,18 @@ class Profile(GameEngineElement):
 
         draw_width = width/4
         draw_height = height/4
-
-        font = pygame.font.Font(None, 16)
-        text=font.render(self.name,True,(0,0,0))
-        textRect=(draw_width+60,draw_height+60,text.get_width(),text.get_height())
-        screen.blit(self.background_img,(0,0,width,height))
-        screen.fill((150,150,255),(draw_width,draw_height,2*draw_width,2*draw_height))
-        screen.blit(font.render(_("Enter name:"),True,(0,0,0)),(draw_width,draw_height))
-        screen.blit(font.render(_("Return to continue"),True,(0,0,0)),(draw_width+20,draw_height+20,20,20))
-        screen.blit(text, textRect)
+        
+        self.background.setPosition(0,0)
+        self.blueRect.setPosition(draw_width, draw_height)
+        
+        #name
+        self.text_list[0].changeText(self.name,(0,0,0))
+        self.text_list[0].setPosition(draw_width+60, draw_height+60)
+        #text1
+        self.text_list[1].changeText(_("Enter Name:"), (0,0,0))
+        self.text_list[1].setPosition(draw_width,draw_height)
+        #text2
+        self.text_list[2].changeText(_("Return to continue"), (0,0,0))
+        self.text_list[2].setPosition(draw_width+20,draw_height+20)
+        
 
diff --git a/MAFH2/Spritesheet.py b/MAFH2/Spritesheet.py
new file mode 100644
index 0000000..ddb18a8
--- /dev/null
+++ b/MAFH2/Spritesheet.py
@@ -0,0 +1,31 @@
+import pygame

+

+class Spritesheet:

+    """

+    Class from http://www.scriptedfun.com/transcript-2-using-sprite-sheets-and-drawing-the-background/

+

+    This class can be used to seporate images from the sprite sheet

+    """

+    def __init__(self, filename):

+        self.sheet = pygame.image.load(filename).convert()

+

+    def imgat(self, rect, myColorKey = None):

+        rect = pygame.Rect(rect)

+        image = pygame.Surface(rect.size).convert()

+        if myColorKey == None: myColorKey = image.get_at((0,0))

+        image.set_colorkey(myColorKey)

+        image.blit(self.sheet, (0, 0), rect)

+        return image

+

+    def imgsat(self, rects, myColorKey = None):

+        imgs = []

+        for rect in rects:

+            imgs.append(self.imgat(rect, myColorKey))

+        return imgs

+

+    def img_extract( self, cols, rows, width, height, myColorKey = None):

+        rect_list = []

+        for y in range(0, rows):

+            for x in range(0, cols):

+                rect_list.append( (width*x, height*y, width, height,) )

+        return self.imgsat( rect_list, myColorKey)
\ No newline at end of file
diff --git a/MAFH2/TermBox.py b/MAFH2/TermBox.py
index a273bb5..bb6660b 100644
--- a/MAFH2/TermBox.py
+++ b/MAFH2/TermBox.py
@@ -1,5 +1,7 @@
 import pygame
 from fortuneengine.GameEngineElement import GameEngineElement
+from fortuneengine.DrawableFontObject import DrawableFontObject
+from fortuneengine.DrawableObject import DrawableObject
 class TermBox(GameEngineElement):
     def __init__(self, x,y,width,height,lines):
         GameEngineElement.__init__(self, has_draw=True, has_event=False)
@@ -7,22 +9,27 @@ class TermBox(GameEngineElement):
         self.max_lines = lines
         self.x = x
         self.y = y
-        self.width = width
-        self.height = height
-        self.font = pygame.font.Font(None, 20)
+        surf = pygame.Surface((int(width),int(height)))
+        surf.fill([0,0,0])
+        self.box = DrawableObject([surf],"")
+        self.box.setPosition(int(x),int(y))
+        self.font = pygame.font.Font(None, 28)
         self.__lines = []
-
+        for i in range(lines):
+            self.__lines.append(DrawableFontObject('', self.font))
+        self.game_engine.get_scene().addObject(self.box)
+        self.game_engine.get_scene().addObjects(self.__lines)
         self.add_to_engine()
 
     def add_line(self, line):
-        self.__lines.append( line )
-        if len( self.__lines ) > self.max_lines:
-            self.__lines.pop(0)
+        for i in range(0, self.max_lines, 1):
+            if i == self.max_lines-1:
+                self.__lines[i].changeText(line, [255,255,255])
+            else:
+                self.__lines[i].changeText(self.__lines[i+1].getText(), [255,255,255])
 
     def draw(self,screen,time_delta):
-        pygame.draw.rect(screen, [0, 0, 0], (self.x, self.y, self.width, self.height))
         i=0
         for line in self.__lines:
-            ren = self.font.render(line, 1, [255, 255, 255])
-            screen.blit(ren, (self.x, self.y + i*self.font.get_height()))
+            line.setPosition(int(self.x), int(self.y + i*self.font.get_height()))
             i+=1
diff --git a/MAFH2/assets/image/character/Crab.gif b/MAFH2/assets/image/character/Crab.gif
new file mode 100644
index 0000000..d20a7d6
--- /dev/null
+++ b/MAFH2/assets/image/character/Crab.gif
diff --git a/MAFH2/assets/image/character/anim_test.gif b/MAFH2/assets/image/character/anim_test.gif
index 6693e7a..0addeeb 100755
--- a/MAFH2/assets/image/character/anim_test.gif
+++ b/MAFH2/assets/image/character/anim_test.gif
diff --git a/MAFH2/assets/image/character/anim_test.psd b/MAFH2/assets/image/character/anim_test.psd
new file mode 100644
index 0000000..1b4fe08
--- /dev/null
+++ b/MAFH2/assets/image/character/anim_test.psd
diff --git a/MAFH2/assets/image/character/bonesprout.gif b/MAFH2/assets/image/character/bonesprout.gif
new file mode 100644
index 0000000..810d61a
--- /dev/null
+++ b/MAFH2/assets/image/character/bonesprout.gif
diff --git a/MAFH2/assets/image/character/concept_goblin.gif b/MAFH2/assets/image/character/concept_goblin.gif
new file mode 100644
index 0000000..603ac02
--- /dev/null
+++ b/MAFH2/assets/image/character/concept_goblin.gif
diff --git a/MAFH2/assets/image/character/concept_goblin.png b/MAFH2/assets/image/character/concept_goblin.png
index 3393810..6bdca0f 100644
--- a/MAFH2/assets/image/character/concept_goblin.png
+++ b/MAFH2/assets/image/character/concept_goblin.png
diff --git a/MAFH2/assets/image/character/concept_orc.gif b/MAFH2/assets/image/character/concept_orc.gif
new file mode 100644
index 0000000..1eaa5b0
--- /dev/null
+++ b/MAFH2/assets/image/character/concept_orc.gif
diff --git a/MAFH2/assets/image/character/concept_wizard.gif b/MAFH2/assets/image/character/concept_wizard.gif
new file mode 100644
index 0000000..c6df6c4
--- /dev/null
+++ b/MAFH2/assets/image/character/concept_wizard.gif
diff --git a/MAFH2/assets/image/character/dog~.gif b/MAFH2/assets/image/character/dog~.gif
new file mode 100644
index 0000000..b4bb3b4
--- /dev/null
+++ b/MAFH2/assets/image/character/dog~.gif
diff --git a/MAFH2/assets/image/character/dragon.gif b/MAFH2/assets/image/character/dragon.gif
new file mode 100644
index 0000000..528d447
--- /dev/null
+++ b/MAFH2/assets/image/character/dragon.gif
diff --git a/MAFH2/assets/image/character/dragon.psd b/MAFH2/assets/image/character/dragon.psd
new file mode 100644
index 0000000..b2ca16b
--- /dev/null
+++ b/MAFH2/assets/image/character/dragon.psd
diff --git a/MAFH2/assets/image/character/faren.gif b/MAFH2/assets/image/character/faren.gif
new file mode 100644
index 0000000..be9671b
--- /dev/null
+++ b/MAFH2/assets/image/character/faren.gif
diff --git a/MAFH2/assets/image/character/frost_giant.gif b/MAFH2/assets/image/character/frost_giant.gif
new file mode 100644
index 0000000..6301b78
--- /dev/null
+++ b/MAFH2/assets/image/character/frost_giant.gif
diff --git a/MAFH2/assets/image/character/merchant.gif b/MAFH2/assets/image/character/merchant.gif
new file mode 100644
index 0000000..71bbb8f
--- /dev/null
+++ b/MAFH2/assets/image/character/merchant.gif
diff --git a/MAFH2/assets/image/environment/celestial/F.gif b/MAFH2/assets/image/environment/celestial/F.gif
new file mode 100644
index 0000000..6e1c7b2
--- /dev/null
+++ b/MAFH2/assets/image/environment/celestial/F.gif
diff --git a/MAFH2/assets/image/environment/celestial/L.gif b/MAFH2/assets/image/environment/celestial/L.gif
new file mode 100644
index 0000000..5d4c4f5
--- /dev/null
+++ b/MAFH2/assets/image/environment/celestial/L.gif
diff --git a/MAFH2/assets/image/environment/celestial/Room.gif b/MAFH2/assets/image/environment/celestial/Room.gif
new file mode 100644
index 0000000..e2ddcc9
--- /dev/null
+++ b/MAFH2/assets/image/environment/celestial/Room.gif
diff --git a/MAFH2/assets/image/environment/ice/F.gif b/MAFH2/assets/image/environment/ice/F.gif
new file mode 100644
index 0000000..205db6e
--- /dev/null
+++ b/MAFH2/assets/image/environment/ice/F.gif
diff --git a/MAFH2/assets/image/environment/ice/L.gif b/MAFH2/assets/image/environment/ice/L.gif
new file mode 100644
index 0000000..35a7503
--- /dev/null
+++ b/MAFH2/assets/image/environment/ice/L.gif
diff --git a/MAFH2/assets/image/environment/ice/Room.gif b/MAFH2/assets/image/environment/ice/Room.gif
new file mode 100644
index 0000000..0b36e7b
--- /dev/null
+++ b/MAFH2/assets/image/environment/ice/Room.gif
diff --git a/MAFH2/assets/image/environment/pyramid/F.gif b/MAFH2/assets/image/environment/pyramid/F.gif
new file mode 100644
index 0000000..a8d8435
--- /dev/null
+++ b/MAFH2/assets/image/environment/pyramid/F.gif
diff --git a/MAFH2/assets/image/environment/pyramid/L.gif b/MAFH2/assets/image/environment/pyramid/L.gif
new file mode 100644
index 0000000..10f80ba
--- /dev/null
+++ b/MAFH2/assets/image/environment/pyramid/L.gif
diff --git a/MAFH2/assets/image/environment/pyramid/Room.gif b/MAFH2/assets/image/environment/pyramid/Room.gif
new file mode 100644
index 0000000..798ebf1
--- /dev/null
+++ b/MAFH2/assets/image/environment/pyramid/Room.gif
diff --git a/MAFH2/assets/image/hud/bt.gif b/MAFH2/assets/image/hud/bt.gif
new file mode 100644
index 0000000..aaee374
--- /dev/null
+++ b/MAFH2/assets/image/hud/bt.gif
diff --git a/MAFH2/assets/image/hud/hp.gif b/MAFH2/assets/image/hud/hp.gif
new file mode 100644
index 0000000..809f842
--- /dev/null
+++ b/MAFH2/assets/image/hud/hp.gif
diff --git a/MAFH2/drawableobject/DrawableObject.py b/MAFH2/drawableobject/DrawableObject.py
new file mode 100755
index 0000000..449741c
--- /dev/null
+++ b/MAFH2/drawableobject/DrawableObject.py
@@ -0,0 +1,161 @@
+import pygame

+

+class DrawableObject(pygame.sprite.Sprite):

+

+    def __init__(self,images,textfileName,fps = 2, x = 0, y = 0, xVelocity = 0, yVelocity = 0):

+        pygame.sprite.Sprite.__init__(self)

+        cnt = 0

+        

+        #self._originals = images

+        #self._images = images

+        self._images = []

+        self._origImages = []

+        while cnt < len(images):

+            self._images.append(images[cnt].convert())

+            self._origImages.append(images[cnt].convert())

+            cnt += 1

+        self.image = self._images[0]

+        self._start = pygame.time.get_ticks()

+        self._delay = 1000 / fps

+        self._last_update = 0

+        self._frame = 0

+        self.animations = {}

+        self._current_anim = ""

+        self.xPos = x

+        self.yPos = y

+        self.xSpeed = xVelocity

+        self.ySpeed = yVelocity

+        self.myAngle = 0

+        self.xSize = 40

+        self.ySize = 40

+        

+        if textfileName != '':

+

+           f = open(textfileName, 'r')

+           currentLine = f.readline()

+           while currentLine != '':

+

+             animValues = currentLine.split(",")

+             self.animations[animValues[0]] =  [int(animValues[1]), int(animValues[2])]

+             currentLine = f.readline()

+

+

+    def addImages(self, images):

+

+        self._images.extend(images)

+        #self._originals.extend(images)

+        

+    def goToAnim(self, animName):

+

+        cnt = 0

+        while cnt < len(animations):

+           

+           if animations[cnt] == animName:

+             self._current_anim = animName

+             self._frame = self.animations[animName][0]

+             self.image = self._images[self._frame]

+             cnt = len(animations)

+           cnt += 1

+           

+    def goToFrame(self, frame):

+

+        self._frame = frame

+        self.image = self._images[self._frame]

+

+    def move(self):

+

+        self.xPos += self.xSpeed

+        self.yPos += self.ySpeed

+

+        self.image[0].get_rect().move(self.xPos,self.yPos)

+

+    def nudge(self, xNudge = 0, yNudge = 0):

+

+        self.xPos += xNudge

+        self.yPos += yNudge

+

+        self.image[0].get_rect().move(self.xPos,self.yPos)

+

+    def scale(self, newXSize = None, newYSize = None):

+

+        if newXSize != None: self.xSize = newXSize

+        if newYSize != None: self.ySize = newYSize

+

+        cnt = 0

+        while  cnt < len(self._images):

+            

+            self._origImages[cnt] = pygame.transform.scale(self._origImages[cnt], (self.xSize, self.ySize))

+            self._images[cnt] = self._origImages[cnt]

+            cnt += 1

+            

+    def getXSize(self):

+    

+       return self.xSize

+

+    def getYSize(self):

+

+       return self.ySize

+

+    def rotate(self,angle):

+

+        cnt = 0

+

+        self.myAngle += angle

+        while  cnt < len(self._images):

+

+            self._images[cnt] = pygame.transform.rotate(self._origImages[cnt], self.myAngle)

+            cnt += 1

+

+    def getRotation(self):

+

+       return self.myAngle

+    

+    def setPosition(self, x = None, y = None):

+    

+       if x != None and x >= 0:  self.xPos = x

+       if y != None and y >= 0:  self.yPos = y

+

+    def getXPos(self):

+

+       return self.xPos

+

+    def getYPos(self):

+

+       return self.yPos

+

+    def setSpeed(self, xVelocity = None, yVelocity = None):

+

+       if xVelocity != None:  self.xSpeed = xVelocity

+       if yVelocity != None:  self.ySpeed = yVelocity

+

+    def getXSpeed(self):

+    

+       return self.xSpeed

+

+    def getYSpeed(self):

+

+       return self.ySpeed

+       

+    def calcColorKey(self):

+    

+       myColorKey = images[0].get_at((0,0))

+       setColorKey(myColorKey)

+

+    def setColorKey(self, aColor):

+

+       cnt = 0

+       while cnt < len(self._images):

+          self._images[cnt].set_colorkey(aColor)

+          cnt += 1

+

+    def update(self, t):

+       pass

+

+    def updateCurrnetAnimation(self, t):

+       pass

+

+    def nextFrame(self):

+       pass

+

+    def nextCurrentAnimFrame(self):

+       pass

diff --git a/MAFH2/drawableobject/Spritesheet.py b/MAFH2/drawableobject/Spritesheet.py
new file mode 100755
index 0000000..bce2db5
--- /dev/null
+++ b/MAFH2/drawableobject/Spritesheet.py
@@ -0,0 +1,33 @@
+import pygame

+

+class Spritesheet:

+    """

+    Class from http://www.scriptedfun.com/transcript-2-using-sprite-sheets-and-drawing-the-background/

+

+    This class can be used to seperate images from the sprite sheet

+    """

+    def __init__(self, filename):

+        self.sheet = pygame.image.load(filename).convert_alpha()

+        self.sheet = self.imgat(self.sheet.get_rect())

+

+    def imgat(self, rect, myColorKey = None):

+        rect = pygame.Rect(rect)

+        image = pygame.Surface(rect.size).convert_alpha()

+        if myColorKey == None:

+            myColorKey = (255,0,255)

+        image.set_colorkey(myColorKey)

+        image.blit(self.sheet, (0, 0), rect)

+        return image

+

+    def imgsat(self, rects, myColorKey = None):

+        imgs = []

+        for rect in rects:

+            imgs.append(self.imgat(rect, myColorKey))

+        return imgs

+

+    def img_extract( self, cols, rows, width, height, myColorKey = None):

+        rect_list = []

+        for y in range(0, rows):

+            for x in range(0, cols):

+                rect_list.append((width*x, height*y, width, height))

+        return self.imgsat( rect_list, myColorKey)

diff --git a/MAFH2/ezmenu.py b/MAFH2/ezmenu.py
index 4de6603..77a6d07 100644
--- a/MAFH2/ezmenu.py
+++ b/MAFH2/ezmenu.py
@@ -1,21 +1,23 @@
 #! /usr/bin/env python
 
-############################################################
-#EzMeNu - A simple module to quickly make menus with PyGame#
-############################################################
-#Licensed under the GNU Lesser General Public License      #
-#Created by PyMike <pymike93@gmail.com>                    #
-#Some edits by Justin Lewis <jtl1728@rit.edu               #
-############################################################
+#############################################################
+#EzMeNu - A simple module to quickly make menus with PyGame #
+#############################################################
+#Licensed under the GNU Lesser General Public License       #
+#Created by PyMike <pymike93@gmail.com>                     #
+#Some edits by Justin Lewis <jtl1728@rit.edu>               #
+#Some edits by Kevin Hockey <kdh7733@rit.edu>               #
+#############################################################
 
 import pygame
+from fortuneengine.DrawableFontObject import DrawableFontObject
 
-class EzMenu:
+class EzMenu():
 
-    def __init__(self, options):
+    def __init__(self, options, scene):
         """Initialise the EzMenu! options should be a sequence of lists in the
         format of [option_name, option_function]"""
-
+        self.scene = scene
         self.options = options
         self.x = 0
         self.y = 0
@@ -29,11 +31,19 @@ class EzMenu:
         self.color = [0, 0, 0]
         self.hcolor = [255, 0, 0]
         self.height = len(self.options)*self.font.get_height()
+        self.font.set_italic( True )
+        self.help_text = DrawableFontObject("", self.font)
+        self.font.set_italic( False )
+        self.font_list = []
+        self.scene.addObject(self.help_text)
 
         for o in self.options:
             ren = self.font.render( o[0], 1, self.color)
+            self.font_list.append(DrawableFontObject(o[0], self.font))
             if self.width < ren.get_width():
                 self.width = ren.get_width()
+                
+        self.scene.addObjects(self.font_list)
 
     def draw(self, surface):
         """Draw the menu to the surface."""
@@ -46,21 +56,15 @@ class EzMenu:
             else:
                 clr = self.color
             text = o[0]
-            ren = self.font.render(text, True, clr)
-
-            surface.blit(ren, (self.x, self.y + i*self.font.get_height()))
+            #ren = self.font.render(text, True, clr)
+            self.font_list[i].changeText(text, clr)
+            self.font_list[i].setPosition( self.x, self.y + i*self.font.get_height() )
+            #surface.blit(ren, (self.x, self.y + i*self.font.get_height()))
             i+=1
 
-        # Help Test
-        self.font.set_italic( True )
-        ren = self.font.render( help_txt, 1, self.color )
-        self.font.set_italic( False )
-
-        #surf1 = pygame.Surface((self.width+20,self.font.get_height()+20), pygame.SRCALPHA)
-        #pygame.draw.rect(surf1, (255, 255, 255, 70), (0, 0, self.width + 20, self.font.get_height()))
-
-        #surface.blit( surf1, (self.hx, self.hy) )
-        surface.blit( ren, (self.hx+5, self.hy) )
+        # Help Text
+        self.help_text.changeText(help_txt, self.color)
+        self.help_text.setPosition(self.hx+5, self.hy)
 
     def update(self, event):
         """Update the menu and get input for the menu."""
@@ -110,3 +114,8 @@ class EzMenu:
     def help_text_at(self, x, y):
         self.hx = x
         self.hy = y
+        
+    def clear_menu(self):
+        for dfo in self.font_list:
+            self.scene.removeObject(dfo)
+        self.scene.removeObject(self.help_text)
diff --git a/MAFH2/fortuneengine/DrawableFontObject.py b/MAFH2/fortuneengine/DrawableFontObject.py
new file mode 100644
index 0000000..92f641f
--- /dev/null
+++ b/MAFH2/fortuneengine/DrawableFontObject.py
@@ -0,0 +1,19 @@
+import pygame

+from DrawableObject import DrawableObject

+

+class DrawableFontObject(DrawableObject, pygame.sprite.Sprite):

+

+    def __init__(self,text,font, x = 0, y = 0):

+

+        self.font = font

+        self.textImage = font.render(text, 1, (255,255,255))

+        self.text = text

+        DrawableObject.__init__(self, [self.textImage], '')

+

+    def changeText(self, newText, color=(0,0,0)):

+        self.text = newText

+        self._images[0] = self.font.render(str(newText), True, color)

+        self.image = self._images[0]

+    

+    def getText(self):

+        return str(self.text)

diff --git a/MAFH2/fortuneengine/DrawableObject.py b/MAFH2/fortuneengine/DrawableObject.py
new file mode 100644
index 0000000..96bb8ef
--- /dev/null
+++ b/MAFH2/fortuneengine/DrawableObject.py
@@ -0,0 +1,157 @@
+import pygame

+

+class DrawableObject(pygame.sprite.Sprite):

+

+    def __init__(self, images, textfileName, transparent = False, x = 0, y = 0):

+        pygame.sprite.Sprite.__init__(self)

+        

+        self._images = []

+        self._origImages = []

+        for i in range(len(images)):

+            self._images.append(images[i].convert_alpha())

+            self._origImages.append(images[i].convert_alpha())

+            

+        blank = pygame.Surface((0,0))

+        

+        if(transparent):

+            for i in range(len(images)):

+                self._images[i] = blank

+

+        self._start = pygame.time.get_ticks()

+        self.image = self._images[0]

+        self._last_update = 0

+        self._frame = 0

+        self.animations = {}

+        self._current_anim = ""

+        self.rect = self.image.get_rect()

+        self.xPos = x

+        self.yPos = y

+        self.myAngle = 0

+        self.xSize = self.image.get_width()

+        self.ySize = self.image.get_height()

+        self.rect.topleft = (x,y)

+

+        if textfileName != '':

+

+           f = open(textfileName, 'r')

+           currentLine = f.readline()

+           while currentLine != '':

+

+             animValues = currentLine.split(",")

+             self.animations[animValues[0]] =  [int(animValues[1]), int(animValues[2])]

+             currentLine = f.readline()

+

+        else:

+        

+            self.animations["anim1"] = [0, len(self._images)]

+            self.goToAnim("anim1")

+

+        self.makeTransparent(transparent)

+

+    def repopulateImages(self, newImages):

+    

+        self._images = []

+        self._origImages = []

+        for i in range(len(newImages)):

+            self._images.append(newImages[i].convert_alpha())

+            self._origImages.append(newImages[i].convert_alpha())

+        

+        self.image = self._images[0]

+        self._frame = 0

+        self.xSize = self.image.get_width()

+        self.ySize = self.image.get_height()

+

+    def addImages(self, images):

+        self._images.extend(images)

+        self._origImages.extend(images)

+

+    def goToAnim(self, animName):

+      if self.animations.get(animName, 0) != 0:

+         self._current_anim = animName

+         self._frame = self.animations[animName][0]

+         self.image = self._images[self._frame]

+         

+    def goToFrame(self, frame):

+

+        if frame <= len(self._images):

+           self._frame = frame

+           self.image = self._images[self._frame]

+

+    def nudge(self, x, y):

+        self.xPos += x

+        self.yPos += y

+        self.rect.right += x

+        self.rect.top += y

+

+    def scale(self, x=None, y=None):

+        if type(x).__name__=='int': self.xSize = x

+        if type(y).__name__=='int': self.ySize = y

+            

+        for i in range(len(self._images)):

+            self._origImages[i] = pygame.transform.scale(self._origImages[i], (self.xSize, self.ySize))

+            self._images[i] = self._origImages[i]

+

+    def fill(self, color):

+        for i in range(len(self._images)):

+            #print "filling with ", color

+            self._origImages[i].fill(color)

+            self._images[i].fill(color)

+            

+    def getXSize(self):

+       return self.xSize

+

+    def getYSize(self):

+       return self.ySize

+

+    def rotate(self,angle):

+        self.myAngle += angle

+        for i in range(len(self._images)):

+            self._images[i] = pygame.transform.rotate(self._origImages[i], self.myAngle)

+

+    def getRotation(self):

+       return self.myAngle

+

+    def setPosition(self, x = None, y = None):

+        if type(x).__name__=='int': self.xPos = x

+        if type(y).__name__=='int': self.yPos = y

+        self.rect.topleft = (self.xPos, self.yPos)

+

+    def getXPos(self):

+       return self.xPos

+

+    def getYPos(self):

+       return self.yPos

+

+    def calcColorKey(self, x=0, y=0):

+       myColorKey = images[0].get_at((x,y))

+       setColorKey(myColorKey)

+       

+    def makeTransparent(self, bool = True):

+       if bool == True:

+            surf = pygame.Surface((0,0))

+            for i in range(len(self._images)):

+                self._images[i] = surf

+       else:

+            for i in range(len(self._images)):

+                self._images[i] = self._origImages[i]

+            self.image = self._images[self._frame]

+

+    def setColorKey(self, aColor):

+       for i in range(len(self._images)):

+          self._images[i].set_colorkey(aColor)

+

+    def update(self, t=None):

+        timePassed = t + self._last_update

+

+        if (timePassed) > 200:

+

+            self.image = self._images[self._frame]

+            self._last_update = timePassed%1000

+        else:   

+            self._last_update = timePassed

+

+    def nextFrame(self):

+       pass

+

+    def nextCurrentAnimFrame(self):

+       pass

diff --git a/MAFH2/fortuneengine/DynamicDrawableObject.py b/MAFH2/fortuneengine/DynamicDrawableObject.py
new file mode 100644
index 0000000..0d8136d
--- /dev/null
+++ b/MAFH2/fortuneengine/DynamicDrawableObject.py
@@ -0,0 +1,75 @@
+import pygame

+from DrawableObject import DrawableObject

+

+class DynamicDrawableObject(DrawableObject, pygame.sprite.Sprite):

+

+    def __init__(self,images,textfileName,fps = 10, x = 0, y = 0, xVelocity = 0, yVelocity = 0):

+

+        self._delay = 1000/fps

+        DrawableObject.__init__(self, images, textfileName, x, y)

+

+    def addImages(self, images):

+

+        self._images.extend(images)

+

+    def setSpeed(self, xVelocity = None, yVelocity = None):

+

+       if xVelocity != None:  self.xSpeed = xVelocity

+       if yVelocity != None:  self.ySpeed = yVelocity

+

+    def getXSpeed(self):

+

+       return self.xSpeed

+

+    def getYSpeed(self):

+

+       return self.ySpeed

+

+    def move(self):

+        self.xPos += self.xSpeed

+        self.yPos += self.ySpeed

+        self.rect.right += self.xSpeed

+        self.rect.top += self.ySpeed

+

+    def update(self, t):

+

+        timePassed = t + self._last_update

+

+        if (timePassed) > self._delay:

+            if self._frame < self.animations.get(self._current_anim)[0] or self._frame > self.animations.get(self._current_anim)[1]:

+                self._frame = self.animations.get(self._current_anim)[0] - 1

+

+            self._frame += timePassed/self._delay

+

+            while self._frame >= self.animations.get(self._current_anim)[1]:

+                framesPast = self._frame - self.animations.get(self._current_anim)[1]

+                self._frame = framesPast - 1 + self.animations.get(self._current_anim)[0]

+

+            self.image = self._images[self._frame]

+            self._last_update = timePassed%self._delay

+        else:   

+            self._last_update = timePassed

+

+    def nextFrame(self):

+        self._frame += 1

+        if self._frame >= len(self._images):

+            framesPast = self._frame - len(self._images)

+            self._frame = framesPast

+

+        self.image = self._images[self._frame]

+

+    def nextCurrentAnimFrame(self):

+

+        for cnt in range(len(animations)):

+

+            if animations[cnt] == self._current_anim:

+                if self._frame < self.animations[self._current_anim][0] or self._frame > self.animations[self._current_anim][1]:

+                    self._frame = self.animations[self._current_anim][0]

+

+                else: self._frame += 1

+

+                if self._frame > self.animations[self._current_anim][1]:

+                    framesPast = self._frame - self.animations[self._current_anim][1]

+                    self._frame = framesPast - 1 + self.animations[self._current_anim][0]

+                  

+                self.image = self._images[self._frame]

diff --git a/MAFH2/fortuneengine/GameEngine.py b/MAFH2/fortuneengine/GameEngine.py
index a4f9e42..1832089 100644
--- a/MAFH2/fortuneengine/GameEngine.py
+++ b/MAFH2/fortuneengine/GameEngine.py
@@ -17,6 +17,10 @@ import pygame
 from time import time
 from GameEngineConsole import GameEngineConsole
 from GameInspect import GameInspect
+from DrawableObject import DrawableObject
+from DynamicDrawableObject import DynamicDrawableObject
+from DrawableFontObject import DrawableFontObject
+from Scene import Scene
 
 
 class GameEngine(object):
@@ -49,6 +53,8 @@ class GameEngine(object):
         self.height = height
         size = width, height
         self.screen = pygame.display.set_mode(size)
+        self.__fps = DrawableFontObject("", pygame.font.Font(None, 17))
+        self.__scene = Scene(self.__fps)
 
         # Engine Internal Variables
         self.__fps_cap = fps_cap
@@ -62,6 +68,7 @@ class GameEngine(object):
         self.__event_cb = []
         self.__draw_lst = []
         self.__object_hold = {}
+        self.__dirtyList=[]
 
         # Game Timers
         self.__active_event_timers = []
@@ -95,6 +102,10 @@ class GameEngine(object):
         it enters the draw flag.
         """
         self.__dirty = True
+        
+    def get_scene(self):
+    
+       return self.__scene
 
     def start_event_timer(self, function_cb, time):
         """
@@ -201,18 +212,18 @@ class GameEngine(object):
 
         else:
             for fnc in self.__draw_lst:
-                start = time()
-                fnc(screen, tick_time)
-                self.__draw_time[str(fnc)] += time() - start
-                self.__draw_calls[str(fnc)] += 1
-
+                 start = time()
+                 fnc(screen, tick_time)
+                 self.__draw_time[str(fnc)] += time() - start
+                 self.__draw_calls[str(fnc)] += 1
             # Print Frame Rate
             if self.__showfps:
-                text = self.__font.render('FPS: %d' % self.clock.get_fps(),
-                       False, (255, 255, 255), (159, 182, 205))
-                screen.blit(text, (0, 0))
-
-            pygame.display.flip()
+                self.__fps.changeText('FPS: %d' % self.clock.get_fps(), (255,255,255))
+                self.__fps.setPosition(0,0)
+            else:
+                self.__fps.changeText('')
+            self.__scene.update(tick_time)
+            pygame.display.update(self.__scene.draw(screen))
 
     def _event_loop(self):
         """
diff --git a/MAFH2/fortuneengine/Scene.py b/MAFH2/fortuneengine/Scene.py
new file mode 100644
index 0000000..d2e50a9
--- /dev/null
+++ b/MAFH2/fortuneengine/Scene.py
@@ -0,0 +1,186 @@
+import pygame

+from pygame.sprite import RenderUpdates

+

+class Scene(pygame.sprite.RenderUpdates):

+

+    def __init__(self, sprites):

+

+       self._spritelist = [[sprites, sprites.getXPos(), sprites.getYPos()]]

+       #self._spritelist.append([sprites, sprites.getXPos(), sprites.getYPos()])

+       RenderUpdates.__init__(self, sprites)

+

+       self.xPos = 0

+       self.yPos = 0

+       self.xSize = 0

+       self.ySize = 0

+       

+       self.calcPosition()

+       self.calcSize()

+       self.setRelativePositions()

+

+    def calcPosition(self):

+    

+       lowestX = 9000

+       lowestY = 9000

+

+       for i in range(len(self._spritelist)):

+           if self._spritelist[i][0].getXPos() < lowestX: lowestX = self._spritelist[i][0].getXPos()

+           if self._spritelist[i][0].getYPos() < lowestY: lowestY = self._spritelist[i][0].getYPos()

+

+       self.xPos = lowestX

+       self.yPos = lowestY

+

+    def calcSize(self):

+    

+       highestX = 0

+       highestY = 0

+       

+       for i in range(len(self._spritelist)):

+           if (self._spritelist[i][0].getXPos() + self._spritelist[i][0].getXSize()) > highestX: highestX = self._spritelist[i][0].getXPos() + self._spritelist[i][0].getXSize()

+           if (self._spritelist[i][0].getYPos() + self._spritelist[i][0].getYSize()) > highestY: highestY = self._spritelist[i][0].getYPos() + self._spritelist[i][0].getYSize()

+

+       self.xSize = highestX - self.xPos

+       self.ySize = highestY - self.yPos

+

+    def addObject(self, newDrawableObject):

+        RenderUpdates.add_internal(self, newDrawableObject)

+        self._spritelist.insert(len(self._spritelist) - 1, [newDrawableObject, newDrawableObject.getXPos(), newDrawableObject.getYPos()])

+

+    def addObjects(self, newDrawableObjects):

+        for sprite in newDrawableObjects:

+           RenderUpdates.add_internal(self, sprite)

+           self._spritelist.insert(len(self._spritelist) - 1, [sprite, sprite.getXPos(), sprite.getYPos()])

+

+    def setRelativePositions(self):

+

+       for i in range(len(self._spritelist)):

+           self._spritelist[i][1] = self._spritelist[i][0].getXPos() - self.xPos

+           self._spritelist[i][2] = self._spritelist[i][0].getYPos() - self.yPos

+

+    def removeObject(self, sprite):

+

+       for i in self._spritelist:

+           if i[0] == sprite:

+               self._spritelist.remove(i)

+               break

+       RenderUpdates.remove_internal(self, sprite)

+

+    def getObject(self, index):

+

+       if index < len(self._spritelist):

+          return  self._spritelist[index][0]

+

+    def getListSize(self):

+

+       return len(self._spritelist)

+

+    def getList(self):

+

+       return list(self._spritelist)

+

+    def moveObjects(self):

+

+       for i in range(len(self._spritelist)):

+          self._spritelist[i][0].move()

+

+       self.calcPosition()

+       self.calcSize()

+       self.setRelativePositions()

+

+    def moveScene(self, xNudge = 0, yNudge = 0):

+

+       

+       for i in range(len(self._spritelist)):

+

+          self._spritelist[i][0].nudge(xNudge, yNudge)

+          

+

+       self.calcPosition()

+

+    def setPosition(self, newXPos = None, newYPos = None):

+

+       if newXPos != None: self.xPos = newXPos

+       if newYPos != None: self.yPos = newYPos

+

+       for i in range(len(self._spritelist)):

+

+          self._spritelist[i][0].setPosition(self.xPos + self._spritelist[i][1], self.yPos + self._spritelist[i][2])

+

+    def getXPos(self):

+       return self.xPos

+

+    def getYPos(self):

+       return self.yPos

+

+    def getXSize(self):

+       return self.xSize

+

+    def getYSize(self):

+       return self.ySize

+

+    def scaleObjects(self, newXSize = None, newYSize = None):

+

+       

+       for i in range(len(self._spritelist)):

+           self._spritelist[i][0].scale(newXSize, newYSize)

+

+    def scaleScene(self, newXSize = None, newYSize = None):

+

+       self.calcPosition()

+       self.calcSize()

+

+       xScale = 1

+       yScale = 1

+

+       if newXSize != None: xScale = (newXSize * 1.0)/self.xSize

+       if newYSize != None: yScale = (newYSize * 1.0)/self.ySize

+       

+       for i in range(len(self._spritelist)):

+           self._spritelist[i][0].scale(xScale * self._spritelist[iaw][0].getXSize(), yScale * self._spritelist[i][0].getYSize())

+           self._spritelist[i][1] = xScale * self._spritelist[i][1]

+           self._spritelist[i][2] = yScale * self._spritelist[i][2]

+

+       self.calcPosition()

+       self.calcSize()

+       self.setPosition()

+

+    def update(self, t):

+    

+       for s in self._spritelist: s[0].update(t);

+

+    def draw(self, surface):

+       spritedict = self.spritedict

+       surface_blit = surface.blit

+       dirty = self.lostsprites

+       self.lostsprites = []

+       dirty_append = dirty.append

+       for s in self._spritelist:

+           r = spritedict[s[0]]

+           newrect = surface_blit(s[0].image, s[0].rect)

+           if r is 0:

+               dirty_append(newrect)

+           else:

+               if newrect.colliderect(r):

+                   dirty_append(newrect.union(r))

+               else:

+                   dirty_append(newrect)

+                   dirty_append(r)

+           spritedict[s[0]] = newrect

+       return dirty

+       

+    def drawEntireScene(self, surface):

+       spritedict = self.spritedict

+       surface_blit = surface.blit

+       dirty = self.lostsprites

+       self.lostsprites = []

+       dirty_append = dirty.append

+       for s in self._spritelist:

+           dirty_append(spritedict[s[0]])

+           dirty_append(surface_blit(s[0].image, s[0].rect))

+       return dirty

+

+    def nextFrame(self):

+

+       for i in range(len(self._spritelist)):

+

+          self._spritelist[i][0].nextFrame()