@@ -3,7 +3,7 @@ import os

 def take(num, iter_):

    for _ in range(num): yield iter_.next()

-def _get_last_module(num=1, exclude_modules={'debug'}):

+def get_last_module(num=1, exclude_modules={'debug'}):

 	modname = '%s.py' % __name__.split('.')[-1]

 	try:

 		result = take(

@@ -35,3 +35,4 @@ def debug(func):

 		return result

 	return _inner

+_get_last_module = get_last_module

@@ -91,12 +91,12 @@ class ItemLoader(object):

 			distance = doc.get('distance')

-@Game.register_item_type(5)

+@Game.register_item_type(10)

 class HealingPotion(Item):

 	name = 'Healing potion'

 	char = '\x03'

 	color = libtcod.violet

-	potency = 10

+	potency = 15

 	item_class = 'healing'

 	def use(self):

 		fighter = self.user.fighter

@@ -111,7 +111,7 @@ class HealingPotion(Item):

 		return result

-@Game.register_item_type(2)

+@Game.register_item_type(7)

 class SuperHealingPotion(Item):

 	name = 'Super healing potion'

 	char = '\x03'

@@ -22,10 +22,11 @@ class Level(object):

 			dj = self.djikstra_cache[x,y] = djikstra.DjikstraMap(self.map.map.data)

 			dj.set_goals( (x,y), weight=0)

 		dj = self.djikstra_cache[x,y]

-		dj.cycle()

+		dj.iter(3)

 		return dj

 	def __init__(self, width, height, con, item_types=None, monster_types=None):

+		self.clear_cells = set()

 		self.djikstra_cache = {}

 		self.objects = []

 		self.map = maps.Map(width, height, con, self)

@@ -101,11 +102,19 @@ class Level(object):

 				wall = cell.block_sight

 				walkable = not cell.blocked

+				if (x,y) in self.clear_cells and not self.is_blocked(x,y):

+					libtcod.console_set_char(self.con, x,y, ord(' '))

 				if wall or walkable:

 					color = {

 						True: {True: self.color_light_wall, False: self.color_light_ground},

 						False: {True: self.color_dark_wall, False: self.color_dark_ground}

 					}[visible][wall]

+					if not self.is_blocked(x,y):

+						dj=self.get_djikstra(*self.player.pos)

+						dist = dj.get_cell( (x,y) )

+						if 0 < dist < 10:

+							libtcod.console_put_char(self.con, x,y, ord(str(dist)))

+							self.clear_cells.add((x,y))

 				elif not walkable:

 					color = libtcod.Color(100,100,200)

@@ -655,7 +655,7 @@ RIGHT=1

 CENTER=2

 # initializing the console

 def console_init_root(w, h, title, fullscreen=False, renderer=RENDERER_SDL):

-    _lib.TCOD_console_init_root(w, h, title, c_uint(fullscreen), c_uint(renderer))

+    _lib.TCOD_console_init_root(w, h, title, c_bool(fullscreen), c_uint(renderer))

 def console_get_width(con):

     return _lib.TCOD_console_get_width(con)

@@ -772,7 +772,7 @@ def console_get_height_rect(con, x, y, w, h, fmt):

     return _lib.TCOD_console_get_height_rect(c_void_p(con), x, y, w, h, c_char_p(fmt))

 def console_rect(con, x, y, w, h, clr, flag=BKGND_DEFAULT):

-    _lib.TCOD_console_rect(con, x, y, w, h, c_int(clr), flag)

+    _lib.TCOD_console_rect(con, x, y, w, h, c_bool(clr), flag)

 def console_hline(con, x, y, l, flag=BKGND_DEFAULT):

     _lib.TCOD_console_hline( con, x, y, l, flag)

@@ -1462,10 +1462,10 @@ def map_copy(source, dest):

     return _lib.TCOD_map_copy(source, dest)

 def map_set_properties(m, x, y, isTrans, isWalk):

-    _lib.TCOD_map_set_properties(m, x, y, c_int(isTrans), c_int(isWalk))

+    _lib.TCOD_map_set_properties(m, x, y, c_bool(isTrans), c_bool(isWalk))

 def map_clear(m,walkable=False,transparent=False):

-    _lib.TCOD_map_clear(m,c_int(walkable),c_int(transparent))

+    _lib.TCOD_map_clear(m,c_bool(walkable),c_bool(transparent))

 def map_compute_fov(m, x, y, radius=0, light_walls=True, algo=FOV_RESTRICTIVE ):

     _lib.TCOD_map_compute_fov(m, x, y, c_int(radius), c_bool(light_walls), c_int(algo))

@@ -103,8 +103,9 @@ if __name__ == 'main':

 			self.levels = [levels.Level(self.MAP_WIDTH, self.MAP_HEIGHT, self.con, self.item_types, self.monster_types)]

 			x,y = None,None

+

 			self.player = objects.Player(self.level.map, self.con, x,y, '@', libtcod.white,

-				fighter=objects.Fighter(hp=20, defense = 2, power = 10, death_function=self.player_death)

+				fighter=objects.Fighter(hp=40, defense = 2, power = 11, death_function=self.player_death)

 			)

@@ -345,6 +346,13 @@ if __name__ == 'main':

 			libtcod.console_print_ex(self.panel, self.BAR_WIDTH/2,3, libtcod.BKGND_NONE, libtcod.CENTER,

 				'%s p %s d' %(self.player.fighter.power, self.player.fighter.defense)

 			)

+			fps = libtcod.sys_get_fps()

+			if fps < 10:

+				import debug

+				print 'FPS drop!'

+			libtcod.console_print_ex(self.panel, self.BAR_WIDTH/2,4, libtcod.BKGND_NONE, libtcod.CENTER,

+				'%s FPS' %(libtcod.sys_get_fps())

+			)

 			libtcod.console_set_default_foreground(self.panel, libtcod.light_gray)

 			libtcod.console_print(self.panel, 1, 0, self.get_names_under_mouse())

@@ -395,6 +403,7 @@ if __name__ == '__main__':

 	game_instance.load_settings()

 	action = game_instance.main_menu()

+	libtcod.sys_set_fps(Game.LIMIT_FPS)

 	while action is None or action.lower() != 'exit':

 		if action is not None:

 			if action.lower() == 'play':

@@ -419,11 +419,13 @@ class Map(collections.MutableSequence):

 	def choose_empty_point(self, room):

 		empty_points = [p for p in room.iter_cells() if not self.is_blocked(*p)]

+

+		result = None,None

 		if empty_points:

-			for x in empty_points:

-				self.level.get_djikstra(*x)

-			return random.choice(empty_points)

-		return None,None

+			result = random.choice(empty_points)

+			self.level.get_djikstra(*result)

+

+		return result

 	def place_objects(self, room, monster_types, max_num_monsters, item_types, max_num_items):

 		self.place_monsters(room, monster_types, max_num_monsters)

@@ -44,15 +44,16 @@ class Thief(BasicMonster):

 			BasicMonster.take_turn(self)

 	def steal(self):

-		if self.player.inventory.keys() == 0:

+		if self.player.inventory.keys():

+			print self.player.inventory.keys()

 			game_instance.message( ('%s can\'t find anything to steal'%self.owner.name).capitalize(), libtcod.orange )

-		obj = random.choice(self.player.inventory.keys())

-		game_instance.message( ('%s tries to steal %s'%(self.owner.name,obj)).capitalize(), libtcod.red)

-		if random.random() < self.skill:

-			game_instance.message( ('%s successfully steals %s'%(self.owner.name,obj)).capitalize(), libtcod.orange)

-			obj = self.player.inventory[obj]

-			self.inventory.append(obj)

-			del self.player.inventory[obj]

+			obj = random.choice(self.player.inventory.keys())

+			game_instance.message( ('%s tries to steal %s'%(self.owner.name,obj)).capitalize(), libtcod.red)

+			if random.random() < self.skill:

+				game_instance.message( ('%s successfully steals %s'%(self.owner.name,obj)).capitalize(), libtcod.orange)

+				obj = self.player.inventory[obj]

+				self.inventory.append(obj)

+				del self.player.inventory[obj.name]

 	def death(self):

 		monster_death(self.owner)

@@ -77,20 +78,12 @@ class DjikstraMonster(Monster):

 	def init(self, level):

 		self.level = level

-		#print

-		#print 'now olog on level:', self.level, self.maps

+		self.owner.always_visible = True

 		self.opos = self.owner.x, self.owner.y

 		self.ppos = None

 		map = level.map

-		if self.dj.map is None:

-			self.dj.load_map(map.map.data)

-

-			self.dj.set_goals(*(room.center for room in map.gen.rooms), weight = 0)

-

-			while self.dj.cycle(): pass

-

 		#self.dj.visualize()

 	def take_turn(self):

@@ -103,8 +96,8 @@ class DjikstraMonster(Monster):

 			else:

 				dx, dy = self.owner.move_towards(*self.level.player.pos)

-		elif random.random() < .4:

-			dx,dy = self.dj.nav(*pos)

+		#elif random.random() < .4:

+		#	dx,dy = self.dj.nav(*pos)

 		else:

 			dj = self.level.get_djikstra(*self.level.player.pos)

@@ -12,6 +12,7 @@ class Object(object):

 		self.color = color

 		self.blocks = blocks

 		self.con = con

+		self.always_visible = False

 #		self.map = map

 		if level is not None:

@@ -80,7 +81,7 @@ class Object(object):

 		return self.move(dx, dy)

 	def draw(self, player=None):

-		if player is None or player.can_see(self.x, self.y):

+		if player is None or self.always_visible or player.can_see(self.x, self.y):

 			libtcod.console_set_default_foreground(self.con, self.color)

 			libtcod.console_put_char(self.con, self.x,self.y, self.char, libtcod.BKGND_NONE)

 		return self