committed files that were ignored during last commit (lose condition)

3 files changed, 867 insertions, 848 deletions

diff --git a/MAFH2/BattleEngine.py b/MAFH2/BattleEngine.py
index eb27f30..43d6fd1 100644
--- a/MAFH2/BattleEngine.py
+++ b/MAFH2/BattleEngine.py
@@ -1,444 +1,455 @@
-from fortuneengine.GameEngineElement import GameEngineElement
-from Enemy import get_enemy
-from BattleMenu import BattleMenuHolder
-from MagicMenu import MagicMenuHolder
-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
-
-from constants import CHAR_PATH, HUD_PATH
-
-from gettext import gettext as _
-import random
-
-PLAYER_WAIT = 1
-PLAYER_MULT = 2
-_dirtyList=[]
-
-class BattleEngine(GameEngineElement):
-    def __init__(self, dgn):
-        GameEngineElement.__init__(self, has_draw=True, has_event=True)
-
-        self.dgn = dgn
-        self.current_room = dgn.get_current_room()
-
-        self.font = pygame.font.SysFont("cmr10",18,False,False)
-
-        self.enemy_list = []
-        self.magic_list = []
-
-        self.spellType = 0  #0 = non, 1-4 are spells in order, 5 is special
-        self.isMagic = False
-        self.correct = False
-        self.state = PLAYER_WAIT
-        self.player_input = '0'
-        self.active_target = 1
-        self.battleTimer = -1.0
-
-        for i in range(0,4):
-            e_index = self.current_room.get_enemy( i )
-
-            if e_index != '0':
-                curE = get_enemy( e_index )
-                self.enemy_list.append( curE )
-                self.add_to_scene([curE.get_sprite()])
-
-        # Preload images
-        self.__drawableObjects = {}
-        for i in ['arrow_select']:
-            self.__drawableObjects[i] = DrawableObject([pygame.image.load( HUD_PATH + i + ".gif" )], '')
-            self.add_to_scene([self.__drawableObjects[i]])
-
-        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, [255,0,255]), '', True)
-        self.__drawableObjects['hp'].setColorKey((255,0,255))
-        self.__drawableObjects['bt'].setColorKey((255,0,255))
-        self.add_to_scene([self.__drawableObjects['hp']])
-        self.add_to_scene([self.__drawableObjects['bt']])
-
-        self.add_to_engine()
-        self.game_engine.add_object('battlemenu', BattleMenuHolder( self.menu_callback ) )
-        self.game_engine.get_object('battlemenu').show_menu('selection')
-        self.game_engine.get_object('mesg').add_line( _('Enemies present, prepare to fight!') )
-
-    def menu_callback(self, selection, menu):
-        if selection == 'attack_show':
-            menu.set_sec_disp('')
-            self.player_input = ''
-            self.isMagic = False
-            random.seed()
-            isCrit = random.randint(0,100)
-            if( isCrit > 90 ):
-                #Show problem
-                menu.show_menu('attack')
-                tempR1 = random.randint(0,10)
-                tempR2 = random.randint(0,10)
-                self.critAns = tempR1 * tempR2
-                menu.set_disp('%d x %d' %(tempR1, tempR2))
-                self.battleTimer = time.time()
-                self.state = PLAYER_MULT
-            else:
-                #Do Attack
-                #print "Non Crit"
-                menu.show_menu('selection')
-                menu.set_sec_disp('')
-                self.__attack_phase(menu)
-            
-        
-        elif self.state == PLAYER_MULT:
-            self.isMagic = False
-            if selection == 'enter':
-                #figure out damage for crit attack
-                if self.player_input == '':
-                    self.player_input = '0'
-                if int(self.player_input) == (self.critAns):
-                    menu.set_disp('Correct!')
-                    self.correct = True
-                else:
-                    menu.set_disp('Incorrect')
-                    self.correct = False
-                
-                menu.set_sec_disp('')
-                self.player_input = ''
-                self.__attack_phase(menu)
-
-            elif selection == 'clear':
-                self.player_input = ''
-                menu.set_sec_disp('')
-                               
-            else:
-                self.player_input = self.player_input + selection
-                menu.set_sec_disp( self.player_input )
-            
-        elif selection == 'fire':
-            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )
-            self.game_engine.get_object('magicmenu').show_menu('fire')
-            self.spellType = 1
-            self.isMagic = True
-            self.magicWin = False
-            self.battleTimer = time.time()
-        elif selection == 'lightning':
-            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )
-            self.game_engine.get_object('magicmenu').show_menu('lightning')
-            self.spellType = 2
-            self.isMagic = True
-            self.magicWin = False
-            self.battleTimer = time.time()
-        elif selection == 'missile':
-            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )
-            self.game_engine.get_object('magicmenu').show_menu('missile')
-            self.spellType = 3
-            self.isMagic = True
-            self.magicWin = False
-            self.battleTimer = time.time()
-        elif selection == 'heal':
-            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )
-            self.game_engine.get_object('magicmenu').show_menu('heal')
-            self.spellType = 4
-            self.isMagic = True
-            self.magicWin = False
-            self.battleTimer = time.time()
-        elif selection == 'scan':
-            menu.set_disp('Enemy Scanned!')
-            self.isMagic = False
-            self.__attack_phase(menu)
-                
-        elif selection == 'fire1':
-            if(0 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(0)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'fire2':
-            if(1 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(1)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'fire3':
-            if(2 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(2)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'fire4':
-            if(3 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(3)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'lig1':
-            if(0 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(0)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'lig2':
-            if(1 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(1)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'lig3':
-            if(2 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(2)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'lig4':
-            if(3 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(3)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'miss1':
-            if(0 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(0)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'miss2':
-            if(1 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(1)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'miss3':
-            if(2 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(2)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'miss4':
-            if(3 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(3)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'heal1':
-            if(0 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(0)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'heal2':
-            if(1 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(1)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'heal3':
-            if(2 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(2)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'heal4':
-            if(3 in self.magic_list):
-                self.__attack_phase(menu)
-            else:
-                self.magic_list.append(3)
-                if(len(self.magic_list) > 3):
-                    self.magicWin = True
-                    self.__attack_phase(menu)
-        elif selection == 'wrongchoice':
-            self.__attack_phase(menu)
-
-    def __attack_phase(self, menu):
-        #do the correct damage to correct enemy
-        hero = self.game_engine.get_object('profile').hero
-        damage = 0
-        curTarget = self.active_target - 1
-        timeRatio = time.time() - self.battleTimer
-        self.battleTimer = -1.0
-        if timeRatio < 10:
-            timeRatio = timeRatio / 10.0
-        else:
-            timeRatio = 1.0
-        tbonus = 1.0 - timeRatio
-        tbonus += 1.3
-        if self.isMagic:
-            weakness = self.enemy_list[curTarget]
-            spellTypes = ['none', 'fire', 'lightning', 'missile', 'heal', 'special']
-            bonus = 0
-            if spellTypes[self.spellType] == weakness:
-                bonus = 60
-                damage += bonus
-            if self.magicWin and not(self.spellType == 4):
-                damage += hero.attackPower(spellTypes[self.spellType])
-                damage *= tbonus
-                self.enemy_list[curTarget].HP -= int(damage)
-                self.player_input = spellTypes[self.spellType] + ' cast!'
-            elif self.spellType == 4:
-                hero.giveHealth(int(hero.attackPower('heal') * tbonus))
-            else:
-                self.player_input = 'Spell fizzles'
-        elif self.state == PLAYER_MULT:
-            if self.correct:
-                damage = hero.attackPower("critical")
-                damage = damage * tbonus
-                self.enemy_list[curTarget].HP -= int(damage)
-                self.player_input = "Your attack crits for " + str(int(damage)) + " damage"
-        else:
-            damage = hero.attackPower('basic')
-            self.enemy_list[curTarget].HP -= damage
-            self.player_input = "You attack for " + str(int(damage)) + " damage"
-                
-        
-        #generate enemy attack
-        for enemy in self.enemy_list[:]:
-            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()
-                enemyAttack = random.randint(0,100)
-                if enemyAttack > 90:
-                    hero.defendAttack(enemy.attackPower('special'))
-                elif enemyAttack < 6:
-                    hero.defendAttack(enemy.attackPower('critical'))
-                else:
-                    hero.defendAttack(enemy.attackPower('basic'))
-            if hero.healthPoints() <= 0:
-                self.__youDied()
-        
-        self.game_engine.get_object('profile').hero = hero
-        self.state = PLAYER_WAIT
-        self.magic_list = []
-        if (self.isMagic):
-            self.game_engine.get_object('magicmenu').remove_from_engine()
-            self.game_engine.remove_object('magicmenu')
-        else:
-            menu.show_menu('selection')
-            
-        self.game_engine.get_object('battlemenu').set_disp(self.player_input)
-
-        #Are enemies dead?
-        if not self.enemy_list:
-            self.__end_battle(menu)
-
-    def __end_battle(self, menu):
-        #Give items if any
-        room = self.game_engine.get_object('dungeon').get_current_room()
-            
-        for i in range( 0, 4 ):
-            item_key = room.get_item( i )
-            # If visible, remove from room and place in players inventory
-            if item_key[0] != '0' and item_key[1] == 'b':
-                item = get_item( item_key[0] )
-                self.game_engine.get_object('profile').give_item( item )
-                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()
-            
-        self.game_engine.get_object('battlemenu').remove_from_engine()
-        self.game_engine.remove_object('battle')
-        
-    def __youDied(self):
-        #self.remove_from_engine()
-        #self.game_engine.get_object('battlemenu').remove_from_engine()
-        #self.game_engine.get_object('battle').remove_from_engine()
-        #self.game_engine.get_object('dungeon').remove_from_engine()
-        #self.game_engine.get_object('manager').remove_from_engine()
-        #self.game_engine.get_object('mesg').remove_from_engine()
-        #self.game_engine.get_object('map').remove_from_engine()
-        #self.game_engine.get_object('term
-        pass
-        
-    def event_handler(self, event):
-        if event.type == pygame.KEYDOWN:
-
-            newKey=pygame.key.name(event.key)
-
-            if newKey=='[4]' or newKey=='left':
-                self.active_target -= 1
-                if self.active_target < 1:
-                    self.active_target = len(self.enemy_list)
-                return True
-            elif newKey=='[6]' or newKey=='right':
-                self.active_target += 1
-                if self.active_target > len(self.enemy_list):
-                    self.active_target = 1
-                return True
-            
-            elif newKey=='return':
-                self.enemy = self.active_target
-                return True
-
-
-        # We don't want to allow other things to run during battle
-        return True
-
-    def draw(self):
-        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 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()
-
-        self.__drawableObjects['hp'].goToFrame(health)
-        self.__drawableObjects['hp'].setPosition(25,25)
-        
-        #Battle Timer
-        if(self.battleTimer > 0):
-            self.__drawableObjects['bt'].makeTransparent(False)
-            self.__drawableObjects['bt'].setPosition(25,130)
-            tIndex = int(time.time() - self.battleTimer)
-            if tIndex > 10:
-                tIndex = 10
-            self.__drawableObjects['bt'].goToFrame(tIndex)
-        else:
-            self.__drawableObjects['bt'].makeTransparent(True)
+from fortuneengine.GameEngineElement import GameEngineElement

+from Enemy import get_enemy

+from BattleMenu import BattleMenuHolder

+from MagicMenu import MagicMenuHolder

+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

+

+from constants import CHAR_PATH, HUD_PATH

+

+from gettext import gettext as _

+import random

+

+PLAYER_WAIT = 1

+PLAYER_MULT = 2

+_dirtyList=[]

+

+class BattleEngine(GameEngineElement):

+    def __init__(self, dgn):

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

+

+        self.dgn = dgn

+        self.current_room = dgn.get_current_room()

+

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

+

+        self.enemy_list = []

+        self.magic_list = []

+

+        self.spellType = 0  #0 = non, 1-4 are spells in order, 5 is special

+        self.isMagic = False

+        self.correct = False

+        self.state = PLAYER_WAIT

+        self.player_input = '0'

+        self.active_target = 1

+        self.battleTimer = -1.0

+

+        for i in range(0,4):

+            e_index = self.current_room.get_enemy( i )

+

+            if e_index != '0':

+                curE = get_enemy( e_index )

+                self.enemy_list.append( curE )

+                self.add_to_scene([curE.get_sprite()])

+

+        # Preload images

+        self.__drawableObjects = {}

+        for i in ['arrow_select']:

+            self.__drawableObjects[i] = DrawableObject([pygame.image.load( HUD_PATH + i + ".gif" )], '')

+            self.add_to_scene([self.__drawableObjects[i]])

+

+        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, [255,0,255]), '', True)

+        self.__drawableObjects['hp'].setColorKey((255,0,255))

+        self.__drawableObjects['bt'].setColorKey((255,0,255))

+        self.add_to_scene([self.__drawableObjects['hp']])

+        self.add_to_scene([self.__drawableObjects['bt']])

+

+        self.add_to_engine()

+        self.game_engine.add_object('battlemenu', BattleMenuHolder( self.menu_callback ) )

+        self.game_engine.get_object('battlemenu').show_menu('selection')

+        self.game_engine.get_object('mesg').add_line( _('Enemies present, prepare to fight!') )

+

+    def menu_callback(self, selection, menu):

+        if selection == 'attack_show':

+            menu.set_sec_disp('')

+            self.player_input = ''

+            self.isMagic = False

+            random.seed()

+            isCrit = random.randint(0,100)

+            if( isCrit > 90 ):

+                #Show problem

+                menu.show_menu('attack')

+                tempR1 = random.randint(0,10)

+                tempR2 = random.randint(0,10)

+                self.critAns = tempR1 * tempR2

+                menu.set_disp('%d x %d' %(tempR1, tempR2))

+                self.battleTimer = time.time()

+                self.state = PLAYER_MULT

+            else:

+                #Do Attack

+                #print "Non Crit"

+                menu.show_menu('selection')

+                menu.set_sec_disp('')

+                self.__attack_phase(menu)

+            

+        

+        elif self.state == PLAYER_MULT:

+            self.isMagic = False

+            if selection == 'enter':

+                #figure out damage for crit attack

+                if self.player_input == '':

+                    self.player_input = '0'

+                if int(self.player_input) == (self.critAns):

+                    menu.set_disp('Correct!')

+                    self.correct = True

+                else:

+                    menu.set_disp('Incorrect')

+                    self.correct = False

+                

+                menu.set_sec_disp('')

+                self.player_input = ''

+                self.__attack_phase(menu)

+

+            elif selection == 'clear':

+                self.player_input = ''

+                menu.set_sec_disp('')

+                               

+            else:

+                self.player_input = self.player_input + selection

+                menu.set_sec_disp( self.player_input )

+            

+        elif selection == 'fire':

+            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )

+            self.game_engine.get_object('magicmenu').show_menu('fire')

+            self.spellType = 1

+            self.isMagic = True

+            self.magicWin = False

+            self.battleTimer = time.time()

+        elif selection == 'lightning':

+            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )

+            self.game_engine.get_object('magicmenu').show_menu('lightning')

+            self.spellType = 2

+            self.isMagic = True

+            self.magicWin = False

+            self.battleTimer = time.time()

+        elif selection == 'missile':

+            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )

+            self.game_engine.get_object('magicmenu').show_menu('missile')

+            self.spellType = 3

+            self.isMagic = True

+            self.magicWin = False

+            self.battleTimer = time.time()

+        elif selection == 'heal':

+            self.game_engine.add_object('magicmenu', MagicMenuHolder( self.menu_callback ) )

+            self.game_engine.get_object('magicmenu').show_menu('heal')

+            self.spellType = 4

+            self.isMagic = True

+            self.magicWin = False

+            self.battleTimer = time.time()

+        elif selection == 'scan':

+            menu.set_disp('Enemy Scanned!')

+            self.isMagic = False

+            self.__attack_phase(menu)

+                

+        elif selection == 'fire1':

+            if(0 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(0)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'fire2':

+            if(1 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(1)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'fire3':

+            if(2 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(2)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'fire4':

+            if(3 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(3)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'lig1':

+            if(0 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(0)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'lig2':

+            if(1 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(1)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'lig3':

+            if(2 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(2)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'lig4':

+            if(3 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(3)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'miss1':

+            if(0 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(0)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'miss2':

+            if(1 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(1)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'miss3':

+            if(2 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(2)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'miss4':

+            if(3 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(3)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'heal1':

+            if(0 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(0)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'heal2':

+            if(1 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(1)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'heal3':

+            if(2 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(2)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'heal4':

+            if(3 in self.magic_list):

+                self.__attack_phase(menu)

+            else:

+                self.magic_list.append(3)

+                if(len(self.magic_list) > 3):

+                    self.magicWin = True

+                    self.__attack_phase(menu)

+        elif selection == 'wrongchoice':

+            self.__attack_phase(menu)

+

+    def __attack_phase(self, menu):

+        #do the correct damage to correct enemy

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

+        damage = 0

+        curTarget = self.active_target - 1

+        timeRatio = time.time() - self.battleTimer

+        self.battleTimer = -1.0

+        if timeRatio < 10:

+            timeRatio = timeRatio / 10.0

+        else:

+            timeRatio = 1.0

+        tbonus = 1.0 - timeRatio

+        tbonus += 1.3

+        if self.isMagic:

+            weakness = self.enemy_list[curTarget]

+            spellTypes = ['none', 'fire', 'lightning', 'missile', 'heal', 'special']

+            bonus = 0

+            if spellTypes[self.spellType] == weakness:

+                bonus = 60

+                damage += bonus

+            if self.magicWin and not(self.spellType == 4):

+                damage += hero.attackPower(spellTypes[self.spellType])

+                damage *= tbonus

+                self.enemy_list[curTarget].HP -= int(damage)

+                self.player_input = spellTypes[self.spellType] + ' cast!'

+            elif self.spellType == 4:

+                hero.giveHealth(int(hero.attackPower('heal') * tbonus))

+            else:

+                self.player_input = 'Spell fizzles'

+        elif self.state == PLAYER_MULT:

+            if self.correct:

+                damage = hero.attackPower("critical")

+                damage = damage * tbonus

+                self.enemy_list[curTarget].HP -= int(damage)

+                self.player_input = "Your attack crits for " + str(int(damage)) + " damage"

+        else:

+            damage = hero.attackPower('basic')

+            self.enemy_list[curTarget].HP -= damage

+            self.player_input = "You attack for " + str(int(damage)) + " damage"

+                

+        

+        #generate enemy attack

+        for enemy in self.enemy_list[:]:

+            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()

+                enemyAttack = random.randint(0,100)

+                if enemyAttack > 90:

+                    hero.defendAttack(enemy.attackPower('special'))

+                elif enemyAttack < 6:

+                    hero.defendAttack(enemy.attackPower('critical'))

+                else:

+                    hero.defendAttack(enemy.attackPower('basic'))

+            if hero.healthPoints() <= 0:

+                self.__youDied()

+                return

+        

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

+        self.state = PLAYER_WAIT

+        self.magic_list = []

+        if (self.isMagic):

+            self.game_engine.get_object('magicmenu').remove_from_engine()

+            self.game_engine.remove_object('magicmenu')

+        else:

+            menu.show_menu('selection')

+            

+        self.game_engine.get_object('battlemenu').set_disp(self.player_input)

+

+        #Are enemies dead?

+        if not self.enemy_list:

+            self.__end_battle(menu)

+

+    def __end_battle(self, menu):

+        #Give items if any

+        room = self.game_engine.get_object('dungeon').get_current_room()

+            

+        for i in range( 0, 4 ):

+            item_key = room.get_item( i )

+            # If visible, remove from room and place in players inventory

+            if item_key[0] != '0' and item_key[1] == 'b':

+                item = get_item( item_key[0] )

+                self.game_engine.get_object('profile').give_item( item )

+                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()

+        

+        self.game_engine.get_object('battlemenu').remove_from_engine()

+        self.game_engine.remove_object('battlemenu')

+        self.game_engine.remove_object('battle')

+        

+    def __youDied(self):

+        self.remove_from_engine()

+        self.game_engine.get_object('battlemenu').remove_from_engine()

+        self.game_engine.remove_object('battlemenu')

+        self.game_engine.remove_object('battle')

+        

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

+

+        self.game_engine.get_object('mesg').add_line(

+                _("You have been defeated in battle and resurrected."))

+

+        #self.remove_from_engine()

+        #self.game_engine.get_object('battlemenu').remove_from_engine()

+        #self.game_engine.get_object('battle').remove_from_engine()

+        #self.game_engine.get_object('dungeon').remove_from_engine()

+        #self.game_engine.get_object('manager').remove_from_engine()

+        #self.game_engine.get_object('mesg').remove_from_engine()

+        #self.game_engine.get_object('map').remove_from_engine()

+        #self.game_engine.get_object('term

+        

+    def event_handler(self, event):

+        if event.type == pygame.KEYDOWN:

+

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

+

+            if newKey=='[4]' or newKey=='left':

+                self.active_target -= 1

+                if self.active_target < 1:

+                    self.active_target = len(self.enemy_list)

+                return True

+            elif newKey=='[6]' or newKey=='right':

+                self.active_target += 1

+                if self.active_target > len(self.enemy_list):

+                    self.active_target = 1

+                return True

+            

+            elif newKey=='return':

+                self.enemy = self.active_target

+                return True

+

+

+        # We don't want to allow other things to run during battle

+        return True

+

+    def draw(self):

+        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 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()

+

+        self.__drawableObjects['hp'].goToFrame(health)

+        self.__drawableObjects['hp'].setPosition(25,25)

+        

+        #Battle Timer

+        if(self.battleTimer > 0):

+            self.__drawableObjects['bt'].makeTransparent(False)

+            self.__drawableObjects['bt'].setPosition(25,130)

+            tIndex = int(time.time() - self.battleTimer)

+            if tIndex > 10:

+                tIndex = 10

+            self.__drawableObjects['bt'].goToFrame(tIndex)

+        else:

+            self.__drawableObjects['bt'].makeTransparent(True)

diff --git a/MAFH2/BattleMenu.py b/MAFH2/BattleMenu.py
index 2cf1aec..f4ef6c4 100644
--- a/MAFH2/BattleMenu.py
+++ b/MAFH2/BattleMenu.py
@@ -1,247 +1,247 @@
-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 _
-
-NORMAL_MENU = 1
-GRID_MENU = 3
-
-class BattleMenuHolder( GameEngineElement ):
-    def __init__(self, callback):
-        GameEngineElement.__init__(self, has_draw=True, has_event=False)
-        self.menu = None
-        self.callback = callback
-        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.add_to_scene([self.background])
-        self.add_to_scene([self.disp])
-        self.add_to_scene([self.sec_disp])
-
-    def set_disp(self, msg):
-        self.disp.changeText(msg, (0,0,0))
-
-    def set_sec_disp(self, msg):
-        self.sec_disp.changeText(msg, (0,0,0))
-
-    def remove_from_engine(self):
-        super( BattleMenuHolder, self ).remove_from_engine()
-        self.clear_menu()
-
-    def draw(self):
-        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
-
-    def show_menu(self,id):
-        if self.is_in_engine():
-            self.clear_menu()
-        else:
-            self.add_to_engine()
-
-        y_offset = 0
-        if id == "selection":
-            menu_type = NORMAL_MENU
-            menu_options = [
-                        [_("Attack"), lambda: self.menu_called("attack_show"), 140,1],
-                        [_('Special'), lambda: self.show_menu("special"), 140,1],
-                        [_('Magic'), lambda: self.show_menu("magic"), 140,1],
-                        [_('Scan'), lambda: self.menu_called("scan"), 140,1],
-            ]
-
-        elif id == "attack":
-            y_offset = 50
-            menu_type = GRID_MENU
-            menu_options = [
-                        ['1', lambda: self.menu_called('1'),44,1],
-                        ['2', lambda: self.menu_called('2'),44,1],
-                        ['3', lambda: self.menu_called('3'),44,1],
-                        ['4', lambda: self.menu_called('4'),44,1],
-                        ['5', lambda: self.menu_called('5'),44,1],
-                        ['6', lambda: self.menu_called('6'),44,1],
-                        ['7', lambda: self.menu_called('7'),44,1],
-                        ['8', lambda: self.menu_called('8'),44,1],
-                        ['9', lambda: self.menu_called('9'),44,1],
-                        [_("C"), lambda: self.menu_called('clear'),44,1],
-                        ['0', lambda: self.menu_called('0'),44,1],
-                        [_("E"), lambda: self.menu_called('enter'),44,1],
-            ]
-
-        elif id == "special":
-            menu_type = NORMAL_MENU
-            menu_options = [
-                        [_("Back"), lambda: self.show_menu("selection"),140,1]
-            ]
-
-        elif id == "magic":
-            menu_type = NORMAL_MENU
-            menu_options = [
-                        [_("Fire"),  lambda: self.menu_called("fire"), 140, 1],
-                        [_("Lightning"),  lambda: self.menu_called("lightning"), 140, 1],
-                        [_("Missile"), lambda: self.menu_called("missile"), 140, 1],
-                        [_("Heal"),  lambda: self.menu_called("heal"), 140, 1],
-                        [_("Back"), lambda: self.show_menu("selection"), 140, 1]
-            ]
-
-        else:
-            print "Invalid Menu", id
-            return
-
-        self.menu = BattleMenu(menu_options, 237, 375+y_offset, menu_type)
-
-
-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.game_engine.get_scene(), x, y )
-
-        self.add_to_engine()
-
-    def event_handler(self, event):
-        return self.menu.update(event)
-
-    def draw(self):
-        self.menu.draw()
-    
-    def clear(self):
-        self.menu.clear()
-
-class Menu(object):
-    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.scene = scene
-        self.x = x
-        self.y = y
-        self.cols = cols
-        self.font = pygame.font.SysFont("cmr10",18,False,False)
-        self.option = 0
-        self.width = 1
-        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):
-        #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]
-            self.font_list[h].changeText(text, clr)
-
-            newX = self.x + 45 * j
-            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
-
-
-    def update(self, event):
-        """Update the menu and get input for the menu."""
-        return_val = False
-        if event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_DOWN:
-                if self.cols != 1:
-                    self.option += self.cols
-                else:
-                    self.option += 1
-                return_val = True
-            elif event.key == pygame.K_UP:
-                if self.cols != 1:
-                    self.option -= self.cols
-                else:
-                    self.option -= 1
-                return_val = True
-            elif event.key == pygame.K_RIGHT:
-                if self.cols != 1:
-                    self.option += 1
-                    return_val = True
-            elif event.key == pygame.K_LEFT:
-                if self.cols != 1:
-                    self.option -= 1
-                    return_val = True
-            elif event.key == pygame.K_RETURN:
-                self.options[self.option][1]()
-                return_val = True
-
-            # This jumps for uniform size buttons
-            # TODO FIX ME: weird behavior when jumping over weird sized buttons.
-            self.option = self.option % len(self.options)
-
-        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
-        self.y = y
+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 _

+

+NORMAL_MENU = 1

+GRID_MENU = 3

+

+class BattleMenuHolder( GameEngineElement ):

+    def __init__(self, callback):

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

+        self.menu = None

+        self.callback = callback

+        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.add_to_scene([self.background])

+        self.add_to_scene([self.disp])

+        self.add_to_scene([self.sec_disp])

+

+    def set_disp(self, msg):

+        self.disp.changeText(msg, (0,0,0))

+

+    def set_sec_disp(self, msg):

+        self.sec_disp.changeText(msg, (0,0,0))

+

+    def remove_from_engine(self):

+        super( BattleMenuHolder, self ).remove_from_engine()

+        self.clear_menu()

+

+    def draw(self):

+        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

+

+    def show_menu(self,id):

+        if self.is_in_engine():

+            self.clear_menu()

+        else:

+            self.add_to_engine()

+

+        y_offset = 0

+        if id == "selection":

+            menu_type = NORMAL_MENU

+            menu_options = [

+                        [_("Attack"), lambda: self.menu_called("attack_show"), 140,1],

+                        [_('Special'), lambda: self.show_menu("special"), 140,1],

+                        [_('Magic'), lambda: self.show_menu("magic"), 140,1],

+                        [_('Scan'), lambda: self.menu_called("scan"), 140,1],

+            ]

+

+        elif id == "attack":

+            y_offset = 50

+            menu_type = GRID_MENU

+            menu_options = [

+                        ['1', lambda: self.menu_called('1'),44,1],

+                        ['2', lambda: self.menu_called('2'),44,1],

+                        ['3', lambda: self.menu_called('3'),44,1],

+                        ['4', lambda: self.menu_called('4'),44,1],

+                        ['5', lambda: self.menu_called('5'),44,1],

+                        ['6', lambda: self.menu_called('6'),44,1],

+                        ['7', lambda: self.menu_called('7'),44,1],

+                        ['8', lambda: self.menu_called('8'),44,1],

+                        ['9', lambda: self.menu_called('9'),44,1],

+                        [_("C"), lambda: self.menu_called('clear'),44,1],

+                        ['0', lambda: self.menu_called('0'),44,1],

+                        [_("E"), lambda: self.menu_called('enter'),44,1],

+            ]

+

+        elif id == "special":

+            menu_type = NORMAL_MENU

+            menu_options = [

+                        [_("Back"), lambda: self.show_menu("selection"),140,1]

+            ]

+

+        elif id == "magic":

+            menu_type = NORMAL_MENU

+            menu_options = [

+                        [_("Fire"),  lambda: self.menu_called("fire"), 140, 1],

+                        [_("Lightning"),  lambda: self.menu_called("lightning"), 140, 1],

+                        [_("Missile"), lambda: self.menu_called("missile"), 140, 1],

+                        [_("Heal"),  lambda: self.menu_called("heal"), 140, 1],

+                        [_("Back"), lambda: self.show_menu("selection"), 140, 1]

+            ]

+

+        else:

+            print "Invalid Menu", id

+            return

+

+        self.menu = BattleMenu(menu_options, 237, 375+y_offset, menu_type)

+

+

+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.game_engine.get_scene(), x, y )

+

+        self.add_to_engine()

+

+    def event_handler(self, event):

+        return self.menu.update(event)

+

+    def draw(self):

+        self.menu.draw()

+    

+    def clear(self):

+        self.menu.clear()

+

+class Menu(object):

+    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.scene = scene

+        self.x = x

+        self.y = y

+        self.cols = cols

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

+        self.option = 0

+        self.width = 1

+        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):

+        #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]

+            self.font_list[h].changeText(text, clr)

+

+            newX = self.x + 45 * j

+            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

+

+

+    def update(self, event):

+        """Update the menu and get input for the menu."""

+        return_val = False

+        if event.type == pygame.KEYDOWN:

+            if event.key == pygame.K_DOWN:

+                if self.cols != 1:

+                    self.option += self.cols

+                else:

+                    self.option += 1

+                return_val = True

+            elif event.key == pygame.K_UP:

+                if self.cols != 1:

+                    self.option -= self.cols

+                else:

+                    self.option -= 1

+                return_val = True

+            elif event.key == pygame.K_RIGHT:

+                if self.cols != 1:

+                    self.option += 1

+                    return_val = True

+            elif event.key == pygame.K_LEFT:

+                if self.cols != 1:

+                    self.option -= 1

+                    return_val = True

+            elif event.key == pygame.K_RETURN:

+                self.options[self.option][1]()

+                return_val = True

+

+            # This jumps for uniform size buttons

+            # TODO FIX ME: weird behavior when jumping over weird sized buttons.

+            self.option = self.option % len(self.options)

+

+        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

+        self.y = y

diff --git a/MAFH2/Profile.py b/MAFH2/Profile.py
index 2494695..c3feac6 100644
--- a/MAFH2/Profile.py
+++ b/MAFH2/Profile.py
@@ -1,157 +1,165 @@
-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
-from Items import Key
-from gettext import gettext as _
-
-class Profile(GameEngineElement):
-    def __init__(self, recall_string=None, name_entry_cb=None):
-        GameEngineElement.__init__(self)
-        self.name = ""
-        self.dungeon_id = "al1.txt"
-        self.position = (-1, -1)
-        self.playerFacing=NORTH
-        self.hero = Hero()
-
-        # 4 types of stats and difficulties
-        self.problem_stats = {}
-        self.difficulty = {}
-        for stat in ['mult', 'div', 'geo', 'shop']:
-
-            # Each type of stat has 3 "levels" easy, medium, hard
-            # Shop uses level for too much, too little, exact
-            self.problem_stats[stat] = [(0,0), (0,0), (0,0)]
-
-            #Difficulty: 1=Easy 2=Meduim(default) 3=Hard
-            self.difficulty[stat] = 2
-
-        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.add_to_scene([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.add_to_scene([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.add_to_scene(self.text_list)
-        
-        
-        if recall_string:
-            self.load_from_json_string( recall_string )
-
-        if self.name == "":
-            self.name_cb = name_entry_cb
-            self.add_to_engine()
-
-    def next_dungeon(self):
-        self.position = (-1, -1)
-        self.playerFacin = NORTH
-        
-        d = self.game_engine.get_object('dungeon')
-        self.dungeon_id = d.next
-        d.remove_from_engine()
-        self.game_engine.remove_object('dungeon')
-        self.game_engine.add_object('dungeon', Dungeon( self.dungeon_id ))
-        self.remove_keys()
-
-    def load_from_json_string( self, recall_string ):
-        print "TO BE IMPLEMENTED"
-
-    def dump_to_json_string( self ):
-        print "TO BE IMPLEMENTED"
-
-    def update_problem_stat( self, p_type, level, correct ):
-        assert( p_type in self.problem_stats )
-        assert( level >= 0 and level < len(self.problem_stats) - 1 )
-
-        correct, wrong = self.problem_stats[p_type][level]
-        if correct:
-            self.problem_stats[p_type][level] = (correct + 1, wrong)
-        else:
-            self.problem_stats[p_type][level] = (correct, wrong + 1)
-
-    def move_to(self, x, y):
-        self.position = (x, y)
-
-    def turn(self, dir):
-        if dir == RIGHT:
-            self.playerFacing = (self.playerFacing - 1) % 4
-
-        elif dir == LEFT:
-            self.playerFacing = (self.playerFacing + 1) % 4
-
-    def give_item(self, item):
-        self.inventory.append(item)
-
-    def remove_keys(self):
-        i = 0
-        new_inv = []
-        for item in self.inventory:
-            if not isinstance(item, Key):
-                new_inv.append(item)
-        self.inventory = new_inv
-
-    def add_to_engine(self):
-        super( Profile, self).add_to_engine()
-
-    def remove_from_engine(self):
-        super( Profile, self).remove_from_engine()
-            
-    def event_handler(self, event):
-        """
-        Handles user input (used only for name entry)
-        """
-        if event.type == pygame.KEYDOWN:
-            if pygame.key.name(event.key)=='backspace':
-                self.name = self.name[0:-1]
-                return True
-            elif pygame.key.name(event.key)=='return':
-                self.remove_from_engine()
-                self.name_cb()
-                return True
-            else:
-                self.name+=event.unicode
-                return True
-
-    def draw(self):
-        """
-        Draws user input for name to the screen
-        """
-        width = self.game_engine.width
-        height = self.game_engine.height
-
-        draw_width = width/4
-        draw_height = height/4
-        
-        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)
-        
-
+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

+from Items import Key

+from gettext import gettext as _

+

+class Profile(GameEngineElement):

+    def __init__(self, recall_string=None, name_entry_cb=None):

+        GameEngineElement.__init__(self)

+        self.name = ""

+        self.dungeon_id = "al1.txt"

+        self.position = (-1, -1)

+        self.playerFacing=NORTH

+        self.hero = Hero()

+

+        # 4 types of stats and difficulties

+        self.problem_stats = {}

+        self.difficulty = {}

+        for stat in ['mult', 'div', 'geo', 'shop']:

+

+            # Each type of stat has 3 "levels" easy, medium, hard

+            # Shop uses level for too much, too little, exact

+            self.problem_stats[stat] = [(0,0), (0,0), (0,0)]

+

+            #Difficulty: 1=Easy 2=Meduim(default) 3=Hard

+            self.difficulty[stat] = 2

+

+        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.add_to_scene([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.add_to_scene([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.add_to_scene(self.text_list)

+        

+        

+        if recall_string:

+            self.load_from_json_string( recall_string )

+

+        if self.name == "":

+            self.name_cb = name_entry_cb

+            self.add_to_engine()

+

+    def reload_dungeon(self):

+        self.__load_dungeon(self.game_engine.get_object('dungeon').id)

+        #restore HP

+        self.hero.setHealth(self.hero.maxHealthPoints())

+

+    def next_dungeon(self):

+        self.__load_dungeon(self.game_engine.get_object('dungeon').next)

+    

+    def __load_dungeon(self,id):

+        self.position = (-1, -1)

+        self.playerFacing = NORTH

+        

+        d = self.game_engine.get_object('dungeon')

+        self.dungeon_id = id

+        d.remove_from_engine()

+        self.game_engine.remove_object('dungeon')

+        self.game_engine.add_object('dungeon', Dungeon( self.dungeon_id ))

+        self.remove_keys()

+

+    def load_from_json_string( self, recall_string ):

+        print "TO BE IMPLEMENTED"

+

+    def dump_to_json_string( self ):

+        print "TO BE IMPLEMENTED"

+

+    def update_problem_stat( self, p_type, level, correct ):

+        assert( p_type in self.problem_stats )

+        assert( level >= 0 and level < len(self.problem_stats) - 1 )

+

+        correct, wrong = self.problem_stats[p_type][level]

+        if correct:

+            self.problem_stats[p_type][level] = (correct + 1, wrong)

+        else:

+            self.problem_stats[p_type][level] = (correct, wrong + 1)

+

+    def move_to(self, x, y):

+        self.position = (x, y)

+

+    def turn(self, dir):

+        if dir == RIGHT:

+            self.playerFacing = (self.playerFacing - 1) % 4

+

+        elif dir == LEFT:

+            self.playerFacing = (self.playerFacing + 1) % 4

+

+    def give_item(self, item):

+        self.inventory.append(item)

+

+    def remove_keys(self):

+        i = 0

+        new_inv = []

+        for item in self.inventory:

+            if not isinstance(item, Key):

+                new_inv.append(item)

+        self.inventory = new_inv

+

+    def add_to_engine(self):

+        super( Profile, self).add_to_engine()

+

+    def remove_from_engine(self):

+        super( Profile, self).remove_from_engine()

+            

+    def event_handler(self, event):

+        """

+        Handles user input (used only for name entry)

+        """

+        if event.type == pygame.KEYDOWN:

+            if pygame.key.name(event.key)=='backspace':

+                self.name = self.name[0:-1]

+                return True

+            elif pygame.key.name(event.key)=='return':

+                self.remove_from_engine()

+                self.name_cb()

+                return True

+            else:

+                self.name+=event.unicode

+                return True

+

+    def draw(self):

+        """

+        Draws user input for name to the screen

+        """

+        width = self.game_engine.width

+        height = self.game_engine.height

+

+        draw_width = width/4

+        draw_height = height/4

+        

+        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)

+        

+