new file mode 100644

new file mode 100644

@@ -0,0 +1,171 @@

+import random

+import copy

+

+class DjikstraMap(object):

+	def __init__(self, mp=None):

+		#print '__init__ djm'

+		self.map = None

+		if mp is not None:

+			self.load_map(mp)

+

+	def load_map(self, mp):

+		self.map = [

+			[ [255,None][cell] for cell in row ]

+				for row in mp

+		]

+		self.width = len(self.map)

+		self.height = len(self.map[0])

+	def set_goals(self, *args, **k):

+		for x,y in args:

+			self.map[x][y] = k.get('weight', 0)

+

+	def iter_map(self):

+		for x, row in enumerate(self.map):

+			for y, cell in enumerate(row):

+				if cell is not None:

+					yield (x,y), cell

+

+	def get_cross(self, pos, rad):

+		ox,oy = pos

+		# up, down, left, right

+		result = [

+			(ox, oy-rad),

+			(ox, oy+rad),

+			(ox-rad, oy),

+			(ox+rad, oy),

+		]

+		for idx, (x,y) in enumerate(result):

+			if x < 0 or x >= self.width:

+				result[idx] = None

+			elif y < 0 or y >= self.height:

+				result[idx] = None

+			else:

+				result[idx] = self.map[x][y]

+		return result

+

+	def get_rect(self, pos, rad):

+		x,y = pos

+		result = []

+		for cx in range(x-rad, x+rad+1):

+			result.append([])

+			for cy in range(y-rad, y+rad+1):

+				if cx < 0 or cx >= len(self.map):

+					result[-1].append(None)

+				elif cy < 0 or cy >= len(self.map[0]):

+					result[-1].append(None)

+				else:

+					result[-1].append(self.map[cx][cy])

+

+		return result

+

+	def get_line(self, pos1, pos2):

+		x1,y1 = pos1

+		x2,y2 = pos2

+		if y1 == y2:

+			return [ (x,y1) for x in range(x1,x2+1) ]

+		if x1 == x2:

+			return [ (x1,y) for y in range(y1,y2+1) ]

+

+	def get_borders(self, pos, rad):

+		x,y = pos

+

+		results = []

+		results.extend(

+			self.get_line(

+				(min(x-rad, 0), min(y-rad, 0)),

+				(min(x-rad, 0), min(y+rad, self.height))

+			)

+		)

+		results.extend(

+			self.get_line(

+				(min(x-rad, 0),          min(y-rad, 0)),

+				(min(x+rad, self.width), min(y-rad, 0))

+			)

+		)

+

+		results.extend(

+			self.get_line(

+				(min(x+rad, self.width), min(y+rad, self.height)),

+				(min(x-rad, 0),          min(y+rad, self.height))

+			)

+		)

+

+		results.extend(

+			self.get_line(

+				(min(x+rad, self.width), min(y+rad, self.height)),

+				(min(x+rad, self.width), min(y-rad, 0))

+			)

+		)

+

+	def iter(self, num):

+		result = True

+		for _ in range(num):

+			result = self.cycle()

+			if result == False:

+				break

+		return result

+

+	def cycle(self):

+		changed = False

+		out = self.map

+		for pos, cell in self.iter_map():

+			x,y = pos

+

+			#rect = self.get_rect(pos, 2)

+			#neighbors = [n for n in borders(rect)]

+			neighbors = (r for r in sum(self.get_rect(pos, 1), []) if r is not None)

+			#neighbors = (r for r in self.get_cross(pos, 1) if r is not None)

+

+			try:

+				min_neighbor = min(neighbors)

+			except ValueError: continue

+

+			if cell > min_neighbor + 1:

+				changed = True

+				out[x][y] = min_neighbor + 1

+		return changed

+

+	def visualize(self):

+		print

+		for row in zip(*self.map):

+			for cell in row:

+				if cell is None: print ' ',

+				elif cell > 9: print '*',

+				else: print cell,

+			print

+

+	def get_neighbor_values(self, x,y):

+		b = enumerate((enumerate(r,-1) for r in self.get_rect( (x,y), 1 )),-1)

+		result = [(i1,i2, v) for i1, r in b for i2,v in r if v is not None]

+		#print result

+		return result

+

+	def get_low_neighbors(self, x,y, num=2):

+		result = sorted(self.get_neighbor_values(x,y), key=lambda a: a[-1])

+		return result[:num]

+

+	def categorize(self, values):

+		results = {}

+		for i1,i2,v in values:

+			results.setdefault(v,[]).append( (i1,i2) )

+		return results

+	def nav(self, x,y):

+		results = self.get_neighbor_values(x,y)

+		results = self.categorize(results)

+		dx,dy = random.choice(results[min(results)])

+		#print dx,dy,min(results)

+

+		return dx,dy

+

+def borders(rect):

+	mx, my = len(rect)-1, len(rect[0])-1

+	for x, row in enumerate(rect):

+		for y, cell in enumerate(row):

+			if x in {0,mx} or y in {0,my}:

+				if cell is not None:

+					yield cell

+

+def dist( p1, p2 ):

+	x1,y1 = p1

+	x2,y2 = p2

+	return int( ( (x2-x1)**2+(y2-y1)**2 ) ** .5 )

@@ -4,7 +4,7 @@ namegen_class: "male"

 char: "h"

 color: amber

-spawn_chance: 4

+spawn_chance: 0

 hp: 10

 defense: 1

@@ -18,7 +18,7 @@ namegen_class: "male"

 char: "i"

 color: dark_red

-spawn_chance: 7

+spawn_chance: 3

 hp: 4

 defense: 0

@@ -30,7 +30,7 @@ namegen_class: "demon male"

 char: "%"

 color: darker_yellow

-spawn_chance: 1

+spawn_chance: 0

 hp: 17

 defense: 2

@@ -24,7 +24,7 @@ class GameBase:

 	def message(self, msg, color=None):

 		if color is None:

 			color = libtcod.white

-		utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, msg)

+		utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, msg, color=color)

 	def __init__(self, app_name='test app', screen_width=None, screen_height=None):

 		print '__init__'

@@ -1,3 +1,4 @@

+from algorithms import djikstra

 import libtcodpy as libtcod

 import maps

 import debug

@@ -16,7 +17,16 @@ class Level(object):

 		self.number = num

 		return self

+	def get_djikstra(self, x,y):

+		if (x,y) not in self.djikstra_cache:

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

+		return dj

+

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

+		self.djikstra_cache = {}

 		self.objects = []

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

 		self.fov_map = libtcod.map_new(self.map.width, self.map.height)

@@ -119,7 +129,13 @@ class Level(object):

 		return libtcod.map_is_in_fov(self.fov_map, x,y)

 	def is_blocked(self, x,y):

-		return self.map.is_blocked(x,y)

+		if x < 0 or x > self.map.width:

+			result = True

+		elif y < 0 or y > self.map.height:

+			result = True

+		else:

+			result = self.map.is_blocked(x,y)

+		return result

 import game

@@ -366,7 +366,7 @@ if __name__ == 'main':

 				'',

 			)

-			options = ['Play', 'Exit']

+			options = ['Resume', 'Play', 'Exit']

 			result = self.menu('\n'.join(message), options, len(message[0]))

 			if result is not None:

 				return options[result]

@@ -396,9 +396,11 @@ if __name__ == '__main__':

 	game_instance.load_settings()

 	action = game_instance.main_menu()

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

-		if action is not None and action.lower() == 'play':

-			game_instance.setup_map()

-			game_instance.main()

-			libtcod.console_clear(0)

+		if action is not None:

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

+				game_instance.setup_map()

+			if action.lower() in {'play', 'resume'}:

+				game_instance.main()

+				libtcod.console_clear(0)

 		action = game_instance.main_menu()

@@ -15,6 +15,7 @@ class Tile(object):

 		self.block_sight = block_sight

+

 class AutomataEngine(object):

 	def __init__(self, width=None, height=None, data=None, randomize=True):

 		if data:

@@ -187,6 +188,47 @@ class MazeGen(AutomataEngine):

 				tmp_data[x][y] = self.rule(x,y, cell)

 		return AutomataEngine(data=tmp_data)

+class AutomataLoader(AutomataEngine):

+	def load_rules(self):

+		self.rules = yaml.load(

+			file(

+				os.path.join('.', 'data', 'mapgenerator.yml')

+			)

+		)

+

+	def parse_rule(self, rule):

+		comp, val = rule.split('->')

+		val = val.strip()

+		if comp == 'is':

+			if val == 'odd':

+				return lambda a: (a%2)==1

+			elif val == 'even':

+				return lambda a: (a%2)==0

+			else:

+				return lambda a: a == int(val)

+		else:

+			val = int(val)

+			if comp.startswith('>'):

+				if comp.startswith('>='):

+					return lambda a: a >= val

+				return lambda a: a > val

+

+			elif comp.startswith('<'):

+				if comp.startswith('<='):

+					return lambda a: a <= val

+				return lambda a: a < val

+

+			elif comp.startswith('=='):

+				return lambda a: a == val

+

+	def rule(self, x,y, cell):

+		sum = self.sum_area((x,y), 1)

+		for rule in self.rules:

+			rule, _, result = rule.partition('::')

+			if parse_rule(rule)(cell):

+				if hasattr(result, 'upper') and result.lower()=='cell':

+					result = cell

+				return result

 class Automata1(AutomataEngine):

 	def rule(self, x,y, cell):

@@ -227,15 +269,15 @@ class NewSmoother(AutomataEngine):

 			return 1

 import collections

+from algorithms import djikstra

 class Map(collections.MutableSequence):

 	def __init__(self, width, height, con, level):

 		print 'hello again'

-		#self.data = Smoother(data=Automata1(width, height).iter(6).data).munge().to_map()

 		self.gen = MazeGen(width, height)

-		self.data = self.gen.munge()

+		self.map = self.data = self.gen.munge()

 		self.data = Automata1(data=self.data.data).iter(2)

-		self.data = Smoother(data=self.data.data).munge()

-		self.data = self.data.to_map()

+		self.map = Smoother(data=self.data.data).munge()

+		self.data = self.map.to_map()

 		self.width = width

 		self.height = height

@@ -378,6 +420,8 @@ 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)]

 		if empty_points:

+			for x in empty_points:

+				self.level.get_djikstra(*x)

 			return random.choice(empty_points)

 		return None,None

@@ -6,8 +6,10 @@ import libtcodpy as libtcod

 import items

 from main import game_instance

+from algorithms import djikstra

 class Monster(object):

+	def init(self,*a): pass

 	def take_turn(self): pass

 class BasicMonster(Monster):

@@ -20,10 +22,62 @@ class BasicMonster(Monster):

 				while (dx,dy) == (0,0) and counter < 10: # wiggle around if stuck

 					counter += 1

 					dx,dy = monster.move(random.randrange(-1,2,2), random.randrange(-1,2,2))

-				print 'wiggled %s times' % counter

+				#print 'wiggled %s times' % counter

 			elif game_instance.player.fighter.hp > 0:

 				monster.fighter.attack(game_instance.player)

+class DjikstraMonster(Monster):

+	maps = {}

+

+	@property

+	def dj(self):

+		result = self.maps.get(id(self.level))

+		if result is None:

+			result = self.maps[id(self.level)] = djikstra.DjikstraMap()

+		return result

+

+	def init(self, level):

+		self.level = level

+		#print

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

+

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

+		pos = self.owner.x, self.owner.y

+

+		dx,dy = 0,0

+		if self.level.is_visible(*pos):

+			if self.level.player.distance(*pos) < 2:

+				self.owner.fighter.attack(game_instance.player)

+			else:

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

+

+		elif random.random() < .4:

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

+

+		else:

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

+			#print pos, '<---', self.level.player.distance(*pos)

+			x,y = pos

+			dx,dy = dj.nav(x,y)

+

+		self.owner.move(dx,dy)

+

+

+

+

 class AdvancedMonster(Monster):

 	def perimeter(self, rect):

 		for dx,row in enumerate(rect, -1):

@@ -160,25 +214,25 @@ class MonsterLoader(object):

 				)

 			)(doc), doc['spawn_chance'])

-Game.register_monster_type(

-	lambda map,level, con,x,y: objects.Object(map, con,

-		x,y, '\x02', '%s the Orc' % libtcod.namegen_generate('Fantasy male'),

-			libtcod.blue, True,

-

-		fighter=objects.Fighter(hp=10, defense=2, power=3, death_function=monster_death),

-		ai=AdvancedMonster(),

-		level=level

-), 8)

-

-Game.register_monster_type(

-	lambda map,level, con,x,y: objects.Object(map, con,

-		x,y, '\x01', '%s the Troll' % libtcod.namegen_generate('Norse male'),

-			libtcod.orange, True,

-

-		fighter=objects.Fighter(hp=16, defense=1, power=4, death_function=monster_death),

-		ai=AdvancedMonster(),

-		level=level

-), 2)

+#Game.register_monster_type(

+#	lambda map,level, con,x,y: objects.Object(map, con,

+#		x,y, '\x02', '%s the Orc' % libtcod.namegen_generate('Fantasy male'),

+#			libtcod.blue, True,

+#

+#		fighter=objects.Fighter(hp=10, defense=2, power=3, death_function=monster_death),

+#		ai=AdvancedMonster(),

+#		level=level

+#), 8)

+#

+#Game.register_monster_type(

+#	lambda map,level, con,x,y: objects.Object(map, con,

+#		x,y, '\x01', '%s the Troll' % libtcod.namegen_generate('Norse male'),

+#			libtcod.orange, True,

+#

+#		fighter=objects.Fighter(hp=16, defense=1, power=4, death_function=monster_death),

+#		ai=AdvancedMonster(),

+#		level=level

+#), 2)

 Game.register_monster_type(

 	lambda map,level, con,x,y: objects.Object(map, con,

@@ -186,7 +240,7 @@ Game.register_monster_type(

 			libtcod.amber, True,

 		fighter=objects.Fighter(hp=16, defense=1, power=7, death_function=monster_death),

-		ai=AdvancedMonster(),

+		ai=DjikstraMonster(),

 		level=level

 ), 1)

 Game.register_monster_type(None, 7)

@@ -14,23 +14,26 @@ class Object(object):

 		self.con = con

 #		self.map = map

+		if level is not None:

+			level.add_object(self)

+			level.get_djikstra(x,y)

+

+		self.level = level

+

+

 		if fighter is not None:

 			fighter.owner = self

 		self.fighter = fighter

 		if ai is not None:

 			ai.owner = self

+			ai.init(self.level)

 		self.ai = ai

 		if item is not None:

 			item.owner = self

 		self.item = item

-		if level is not None:

-			level.add_object(self)

-

-		self.level = level

-

 	def enter_level(self, level):

 		self.level = level

 		return self

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

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

 			self.x += dx

 			self.y += dy

+			self.level.get_djikstra(self.x, self.y)

 		else:

 			dx,dy = 0,0

 		return dx,dy

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

 		dx = target_x - self.x

 		dy = target_y - self.y

 		distance = math.sqrt(dx**2+dy**2)

+		if distance == 0: distance = 1

 		dx = int(round(dx/distance))

 		dy = int(round(dy/distance))

@@ -204,7 +204,9 @@ class Player(Object):

 	@triggers_recompute

 	def move(self, dx, dy):

-		return Object.move(self, dx,dy)

+		result = Object.move(self, dx,dy)

+		self.level.get_djikstra(*self.pos)

+		return result

 	def move_or_attack(self, dx, dy):

 		x = self.x + dx