@@ -2,9 +2,10 @@ Homepage: http://fiddlerwoaroof.github.com/yinjar/

 If you want to modify the code, the files contained under data/ might be a good place to start

-### Prereqs:

+### Requirements:

 - Python (included on OS X and usually on Linux, install from http://python.org for Windows)

 - PyYAML

+- Numpy

 - libTCOD (if you are running 64bit Linux, run linux64.sh before starting the game)

 - SDL (included with libTCOD)

@@ -36,8 +36,7 @@ class DjikstraMap(object):

 	def load_map(self, mp):

 		self.width = len(mp)

 		self.height = len(mp[0])

-		self.max = dist( (0,0), (self.width, self.height) ) ** 2

-		self.max = int(self.max)

+		self.max = self.width*self.height

 		self.wall = self.width*self.height + 1

 		self.map = numpy.array([

 			[ [self.max,self.wall][cell] for (y,cell) in enumerate(row) ]

@@ -63,7 +62,7 @@ class DjikstraMap(object):

 			if cell == self.wall: continue

 			h = self.height

 			x,y = idx // h, idx % h

-			assert cell == self.map[x,y], "%s %s %s != %s" % (x,y, cell, self[x,y])

+			#assert cell == self.map[x,y], "%s %s %s != %s" % (x,y, cell, self[x,y])

 			yield (x,y), cell

 	def iter_map(self):

@@ -94,10 +93,10 @@ class DjikstraMap(object):

 	def get_rect(self, pos, rad):

 		x,y = pos

-		lx,ty = x-rad, y-rad

-		if x-rad < 0: lx = 0

-		if y-rad < 0: ty = 0

+		lx = max(x-rad,0)

+		ty = max(y-rad,0)

 		end = rad+1

+		#print (x,y), end, (lx, ty) ,(x+end,y+end)

 		result = self.map[lx:x+end,ty:y+end]

 		return result

@@ -121,14 +120,42 @@ class DjikstraMap(object):

 		return min( (g for g in self.goals), key=lambda g: dist(g,pos) )

 	def cycle(self):

+		goals = self.goals[:]

+		for i in range(1,max(self.width,self.height)):

+			for (x,y) in goals:

+				neighbors = self.get_rect( (x,y), i )

+				neighbors[(neighbors >= i) & (neighbors != self.wall)] = i

+		return False

+

+	def cycle1(self):

+		t0 = time.time()

 		changed = False

 		out = self.map

 		for pos, cell in self.iter_map():

 			x,y = pos

-			neighbors = numpy.min(self.get_rect(pos, 1))

-			if cell > neighbors + 1:

+

+			#print

+			neighbors = self.get_rect(pos,1)

+

+			#print pos, cell == self.max, cell==self.wall, cell == 0

+			#print neighbors

+

+			if len(neighbors[0]) == 0:

+				print 'ack'

+				continue

+			#for l in neighbors:

+			#	print (x,y), l

+			#print

+

+			min_neighbor = numpy.min(neighbors)

+

+			if cell > min_neighbor + 1:

+				self[x,y] = min_neighbor + 1

 				changed = True

-				self[x,y] = neighbors + 1

+

+			#if cell > min_neighbor + 1:

+			#	changed = True

+			#	self[x,y] = min_neighbor + 1

 		if changed:

 			self.iters += 1

@@ -186,19 +213,32 @@ def dist( p1, p2 ):

 if __name__ == '__main__':

 	import random

 	width, height = 199,50

-	map = [ [ random.choice([0,0,0,0,0]) for _ in range(height) ] for __ in range(width) ]

+	#map = [ [ random.choice([1,0,0,0,0]) for _ in range(height) ] for __ in range(width) ]

+	import sys

+

+	out = []

+	for line in sys.stdin:

+		out.append( [ int(x) for x in line.strip() ] )

+	map = out

+	width, height = len(map), len(map[0])

+

+

 	import time

-	goals = [ (random.randrange(width), random.randrange(height)) for _ in range(1) ]

+	goals = [ (random.randrange(width), random.randrange(height)) for _ in range(5) ]

 	ot = time.time()

-	for _ in range(5):

+	for _ in range(3):

 		print '\tinit'

 		t0 = time.time()

 		dj = DjikstraMap()

 		dj.set_goals(*goals)

 		dj.load_map(map)

-		dj.iter(10)

-		#while dj.cycle(): pass

+		#dj.iter(10)

+		while dj.cycle():

+			pass

+			#print 'c'

+			#dj.visualize()

+			#print

 		t = time.time() - t0

 		print '\tdone', t, 'iters', dj.iters

 	print time.time() - ot

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

 ---

-#screen_width: 155 # widescreen (1280x800)

-#screen_height: 90

+screen_width: 155 # widescreen (1280x800)

+screen_height: 90

@@ -17,14 +17,13 @@ class Level(object):

 		self.number = num

 		return self

+	dijkstra_cache = {}

 	def get_djikstra(self, x,y):

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

 			print 'new (%s, %s)' % (x,y)

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

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

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

-		dj = self.djikstra_cache[x,y]

-		dj.iter(5)

+			dj = libtcod.dijkstra_new(self.fov_map)

+			libtcod.dijkstra_compute(dj, x, y)

+			self.dijkstra_cache[x,y] = dj

 		return dj

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

@@ -99,7 +98,6 @@ class Level(object):

 				cell.explored = True

 			color = libtcod.black

-			#if True:

 			if cell.explored:

 				wall = cell.block_sight

 				walkable = not cell.blocked

@@ -113,11 +111,14 @@ class Level(object):

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

 			if cell.explored or clear_all:

-				libtcod.console_set_char_background(self.con, x, y, color, libtcod.BKGND_SET)

+				if cell.block_sight and cell.explored:

+					libtcod.console_put_char_ex(self.con, x, y, '#', libtcod.white, color)

+				else:

+					libtcod.console_set_char_background(self.con, x, y, color, libtcod.BKGND_SET)

 	def init_fov(self):

 		libtcod.map_clear(self.fov_map)

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

+

 		for x,y,cell in self.map.iter_cells_with_coords():

 			libtcod.map_set_properties(self.fov_map, x,y,

 				not cell.block_sight,

@@ -1,4 +1,5 @@

 from __future__ import division

+import time

 import copy

 import libtcodpy as libtcod

 import random

@@ -28,7 +29,7 @@ class AutomataEngine(object):

 			self.data = [ [ random.choice([0]+[1]*3) for y in range(height)] for x in range(width) ]

 		else:

 			self.data = [ [1 for y in range(height)] for x in range(width) ]

-		self.data = np.array(self.data)

+		#self.data = np.array(self.data)

 		self.width = width

 		self.height = height

@@ -37,7 +38,8 @@ class AutomataEngine(object):

 		x2,y2 = p2

 		x1,x2 = min([x1,x2]), max([x1,x2])

 		y1,y2 = min([y1,y2]), max([y1,y2])

-		result = self.data[x1:x2,y1:y2]

+		#result = self.data[x1:x2,y1:y2]

+		result = [ row[y1:y2] for row in self.data[x1:x2] ]

 		return result

 	def sum_area(self, p1, p2=None, summator=sum):

@@ -274,14 +276,13 @@ 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.gen = MazeGen(width, height)

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

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

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

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

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

 		self.data = self.map.to_map()

 		self.width = width

@@ -332,6 +333,8 @@ class Map(collections.MutableSequence):

 		rooms = []

 		num_rooms = 0

+		print '\n'.join(''.join(map(str, row)) for row in self.map.data)

+

 		for x in range(self.width):

 			for y in range(self.height):

 				if x in {0,self.width-1} or y in {0,self.height-1}:

@@ -346,55 +349,11 @@ class Map(collections.MutableSequence):

 		self.place_items(self.gen.rooms[0], item_types, max_num_items)

 		for r in self.gen.rooms[1:]:

-		#	pass

 			self.place_objects(r,

 				monster_types, max_num_monsters,

 				item_types, max_num_items

 			)

-#		for r in range(max_rooms):

-#			w = random.randrange(min_size, max_size)

-#			h = random.randrange(min_size, max_size)

-

-#			x = random.randrange(0, self.width-w-1)

-#			y = random.randrange(0, self.height-h-1)

-

-#			new_room = Rect(x,y, w,h)

-

-#			failed = any(

-#				new_room ^ other_room for other_room in rooms

-#			)

-

-#			if not failed:

-#				#self.create_room(new_room)

-#				(new_x, new_y) = new_room.random_point

-#

-#				if num_rooms == 0:

-#					x,y = new_room.random_point

-#					while self.is_blocked(x,y):

-#						x,y = new_room.random_point

-#

-#					self.map_entrance = x,y

-#

-#				else:

-#					self.place_objects(new_room,

-#						monster_types, max_num_monsters,

-#						item_types, max_num_items

-#					)

-#

-#					prev_x, prev_y = rooms[-1].center

-#					#while self.is_blocked(prev_x, prev_y):

-#					#	prev_x, prev_y = rooms[-1].random_point

-#

-#					if random.randrange(0,1) == 1:

-#						self.create_h_tunnel(prev_x, new_x, prev_y)

-#						self.create_v_tunnel(new_x, prev_y, new_y)

-#					else:

-#						self.create_v_tunnel(new_x, prev_y, new_y)

-#						self.create_h_tunnel(prev_x, new_x, prev_y)

-#

-#				rooms.append(new_room)

-#				num_rooms += 1

 		return self

@@ -428,7 +387,6 @@ class Map(collections.MutableSequence):

 		result = None,None

 		if empty_points:

 			result = random.choice(empty_points)

-			self.level.get_djikstra(*result)

 		return result

@@ -6,7 +6,6 @@ import libtcodpy as libtcod

 import items

 from main import game_instance

-from algorithms import djikstra

 class Monster(object):

 	def init(self,*a): pass

@@ -70,13 +69,6 @@ class Thief(BasicMonster):

 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

 		self.owner.always_visible = True

@@ -85,7 +77,6 @@ class DjikstraMonster(Monster):

 		self.ppos = None

 		map = level.map

-		#self.dj.visualize()

 	def take_turn(self):

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

@@ -99,14 +90,17 @@ class DjikstraMonster(Monster):

 			else:

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

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

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

-		elif player_room is not None:

-			dj = self.level.get_djikstra(*player_room.center)

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

-			x,y = pos

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

+		else:

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

+			path = libtcod.dijkstra_path_set(dj, *self.level.player.pos)

+			x,y = libtcod.dijkstra_path_walk(dj)

+

+			if x is not None:

+				dx = x - self.owner.x

+				dy = y - self.owner.y

+			else:

+				print '!'

 		self.owner.move(dx,dy)

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

 		if level is not None:

 			level.add_object(self)

-			#level.get_djikstra(x,y)

 		self.level = level

@@ -209,7 +209,6 @@ class Player(Object):

 	@triggers_recompute

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