@@ -1,29 +1,78 @@

 import random

 import copy

+try:

+	import numpypy as numpy

+except ImportError: pass

+import numpy

+

 class DjikstraMap(object):

 	def __init__(self, mp=None):

+		self.goals = []

+		self.iters = 0

 		#print '__init__ djm'

 		self.map = None

 		if mp is not None:

 			self.load_map(mp)

+		self.items = {}

+

+	def __getitem__(self, key):

+		return self.map[key]

+

+	def __setitem__(self, key, value):

+		x,y = key

+		self.map[x,y] = value

+

+	def __iter__(self):

+		for x in xrange(self.width):

+			for y in xrange(self.height):

+				yield (x,y), self[x,y]

+

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

+		if y == self.wall:

+			x,y = x

+		return self[x,y]

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

+		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.wall = self.width*self.height + 1

+		self.map = numpy.array([

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

+				for (x,row) in enumerate(mp)

+		], dtype=numpy.uint64)

+		self._set_goals()

+

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

-		for x,y in args:

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

+		self.goals.extend(args)

+

+	def _set_goals(self):

+		for x,y in self.goals:

+			self[x,y] = 0

+

+	def get_cost(self, pos):

+		while self[pos] != min_neighbor+1 and self.cycle():

+			pass

+		return self[pos]

 	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

+		wall = self.wall

+		for idx, cell in enumerate(self.map.flat):

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

+			yield (x,y), cell

+

+	def iter_map(self):

+		return (

+			( (x,y), self[x,y] )

+				for x in xrange(self.width)

+				for y in xrange(self.height)

+				if self[x,y] != self.wall

+		)

 	def get_cross(self, pos, rad):

 		ox,oy = pos

@@ -40,22 +89,16 @@ class DjikstraMap(object):

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

 				result[idx] = None

 			else:

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

+				result[idx] = self[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])

-

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

+		if x-rad < 0: lx = 0

+		if y-rad < 0: ty = 0

+		end = rad+1

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

 		return result

 	def get_line(self, pos1, pos2):

@@ -66,37 +109,6 @@ class DjikstraMap(object):

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

@@ -105,38 +117,39 @@ class DjikstraMap(object):

 				break

 		return result

+	def closest_goal(self, pos):

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

+

 	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:

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

+			if cell > neighbors + 1:

 				changed = True

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

+				self[x,y] = neighbors + 1

+

+		if changed:

+			self.iters += 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

+		out = []

+		for x in range(self.width):

+			out.append([])

+			for y in range(self.height):

+				cell = self[x,y]

+				if cell == self.wall: out[-1].append(' ')

+				elif cell == self.max: out[-1].append('x')

+				elif cell > 9: out[-1].append('*')

+				else: out[-1].append(str(cell))

+		print '\n'.join(''.join(x) for x in zip(*out))

 	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]

+		result = [(i1,i2, v) for i1, r in b for i2,v in r if v != self.wall]

 		#print result

 		return result

@@ -157,15 +170,37 @@ class DjikstraMap(object):

 		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 borders(self, 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 != self.wall:

+						yield cell

 def dist( p1, p2 ):

 	x1,y1 = p1

 	x2,y2 = p2

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

+

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

+

+	import time

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

+	ot = time.time()

+	for _ in range(5):

+		print '\tinit'

+		t0 = time.time()

+		dj = DjikstraMap()

+		dj.set_goals(*goals)

+		dj.load_map(map)

+		dj.iter(10)

+		#while dj.cycle(): pass

+		t = time.time() - t0

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

+	print time.time() - ot

+	dj.visualize()

+

@@ -19,10 +19,12 @@ class Level(object):

 	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)

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

+		dj.iter(5)

 		return dj

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

@@ -102,19 +104,11 @@ 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)

@@ -61,6 +61,7 @@ class Thief(BasicMonster):

 			self.drop(item)

 	def drop(self, item):

+		print 'drop'

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

 		self.level.add_object(item)

 		self.inventory.remove(item)

@@ -90,17 +91,19 @@ class DjikstraMonster(Monster):

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

 		dx,dy = 0,0

+		player_room = self.level.player.get_room()

+

 		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)

+				dx, dy = self.owner.get_step_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)

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

@@ -248,7 +251,7 @@ class MonsterLoader(object):

 						hp=doc['hp'],

 						defense=doc['defense'],

 						power=doc['power'],

-						death_function=monster_death

+						death_function=death_func

 					),

 					ai=ai_class().load_data(cls_data),

 					level=level

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

 		if level is not None:

 			level.add_object(self)

-			level.get_djikstra(x,y)

+			#level.get_djikstra(x,y)

 		self.level = level

@@ -47,7 +47,6 @@ 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

@@ -165,7 +164,10 @@ class Fighter(object):

 		if self.hp <= 0:

 			function = self.death_function

 			if function is not None:

-				function(self.owner)

+				try:

+					function(self.owner)

+				except TypeError:

+					function(self.owner.ai)

 	def attack(self, target):

 		damage = self.power - target.fighter.defense

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

 	@triggers_recompute

 	def move(self, dx, dy):

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

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

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

 		return result

 	def move_or_attack(self, dx, dy):

@@ -231,5 +231,10 @@ class Player(Object):

 		self.x, self.y = self.level.map.map_entrance

 		return self

+	def get_room(self):

+		for room in self.level.map.gen.rooms:

+			if self.pos in room:

+				return room

+

 import game