new file mode 100644

@@ -0,0 +1 @@

+ASD: 123

new file mode 100644

@@ -0,0 +1,27 @@

+import random

+

+class Die(object):

+	def __init__(self, sides, min=1, step=1):

+		self.sides = sides

+		self.min = min

+		self.step = 1

+		self.sides = range(min, (min+sides)*step, step)

+		self._value = None

+		self.combine_func = lambda a,b: a+b

+

+	def roll(object):

+		self._value = random.choice(self.sides)

+		return self._value

+

+	@property

+	def value(object):

+		if self._value is None: self.roll()

+		return self._value

+

+	def combine(self, other):

+		if hasattr(other, 'value'): other = other.value

+		return self.combine_func(self.value, other.value)

+

+def DiceRoll(object):

+	def __init__(self, dice):

+		self.dice = dice

new file mode 100644

@@ -0,0 +1,71 @@

+def row2diterate(dct, width, height):

+	for y in range(height):

+		for x in range(width):

+			yield dct[c,r]

+

+class Cell(object):

+	def __init__(self, pos, value=0, neighbors = None, previous = None):

+		self.pos = pos

+		self.value = value

+

+		if previous is None: previous = {}

+		self.previous = previous

+		self.previous[pos] = self

+

+		if neighbors is None: neighbors = [None,None,None,None]

+		chg_funcs = [

+			lambda (x,y): (x,y-1),

+			lambda (x,y): (x+1,y),

+			lambda (x,y): (x,y+1),

+			lambda (x,y): (x-1,y),

+		]

+		for idx,val in enumerate(neighbors):

+			val = neighbors[idx] = previous.get(chg_funcs[idx](pos))

+			if val is not None: val.reconnect()

+		self.neighbors = neighbors

+

+

+	def reconnect(self):

+		chg_funcs = [

+			lambda (x,y): (x,y-1),

+			lambda (x,y): (x+1,y),

+			lambda (x,y): (x,y+1),

+			lambda (x,y): (x-1,y),

+		]

+		for idx,val in enumerate(self.neighbors):

+			if val is None: continue

+			self.neighbors[idx] = self.previous.get(chg_funcs[idx](self.pos))

+

+	def expand(self, tl=(0,0),br=(None,None), recurse=0):

+		chg_funcs = [

+			lambda (x,y): (x,y-1),

+			lambda (x,y): (x+1,y),

+			lambda (x,y): (x,y+1),

+			lambda (x,y): (x-1,y),

+		]

+

+

+		for idx, (cfunc,val) in enumerate(zip(chg_funcs,self.neighbors)):

+			if val is None:

+				nx,ny = cfunc(self.pos)

+				if any(a<b for (a,b) in zip((nx,ny), tl)): continue

+				elif br[0] is not None and any(a>b for (a,b) in zip((nx,ny), br)): continue

+

+				if (nx,ny) in self.previous:

+					val = self.previous[nx,ny]

+					if val.value + 1 < self.value:

+						self.value = val.value + 1

+				else:

+					val = Cell((nx,ny), self.value+1, None, self.previous)

+

+				self.neighbors[idx] = val

+				if self not in val.neighbors or val.value > self.value + 1:

+					val.expand(tl,br)

+

+

+

+

+	@staticmethod

+	def get_topleftmost(cell):

+		return cell.neighbors[min(cell.neighbors, key=lambda (x,y): x+y)]

+

new file mode 100644

@@ -0,0 +1,140 @@

+from __future__ import print_function

+import collections

+

+#

+#  (0,0)  (1,0) | (2,0) (3,0)

+#  (0,1)  (1,1) | (2,1) (3,1)

+#  -------------+------------

+#  (0,2)  (1,2) | (2,2) (3,2)

+#  (0,3)  (1,3) | (2,3) (3,3)

+#

+

+class XY(collections.namedtuple('XY', 'x y')):

+	def __add__(self, other):

+		dx, dy = other

+		return XY(self.x+dx, self.y+dy)

+	def __sub__(self, other):

+		dx, dy = other

+		return XY(self.x-dx, self.y-dy)

+	def __div__(self, n):

+		return XY(self.x/n, self.y/n)

+	def __mul__(self, n):

+		return XY(self.x*n, self.y*n)

+	def __abs__(self):

+		return XY(abs(self.x), abs(self.y))

+

+class AABB(collections.namedtuple('AABB', 'center halfDimension')):

+	@property

+	def tl(self):

+		return self.center - self.halfDimension

+	@property

+	def br(self):

+		return self.center + self.halfDimension

+	@property

+	def tr(self):

+		return XY(self.br[0], self.tl[1])

+	@property

+	def bl(self):

+		return XY(self.tl[0], self.br[1])

+	def containsPoint(self, p):

+		tl = self.center - self.halfDimension

+		br = (self.center + self.halfDimension) - (1,1)

+		return all(x >= 0 for x in p - tl) and all(x > 0 for x in br - p)

+

+	def intersectsAABB(self, other):

+		tl = self.center - self.halfDimension

+		br = self.center + self.halfDimension

+		tr = XY(br[0], tl[1])

+		bl = XY(tl[0], br[1])

+		return other.containsPoint(tl) or other.containsPoint(br) or other.containsPoint(tr) or other.containsPoint(bl)

+

+

+	def subdivide(self):

+		tl = self.center - self.halfDimension

+		br = self.center + self.halfDimension

+		tr = XY(br[0], tl[1])

+		bl = XY(tl[0], br[1])

+

+		center = self.center

+		ne = AABB( (tl+center)/2, self.halfDimension/2 )

+		nw = AABB( (tr+center)/2, self.halfDimension/2 )

+		se = AABB( (br+center)/2, self.halfDimension/2 )

+		sw = AABB( (bl+center)/2, self.halfDimension/2 )

+		return nw, ne, se, sw

+

+class QuadTree(object):

+	QT_NODE_CAPACITY = 4

+

+	def __init__(self, boundary):

+		self.boundary = boundary

+		self.nw = None

+		self.ne = None

+		self.se = None

+		self.sw = None

+		self.points = []

+

+	def insert(self, p):

+		if not self.boundary.containsPoint(p): return False

+

+		if len(self.points) < self.QT_NODE_CAPACITY:

+			self.points.append(p)

+			return True

+

+		if self.nw is None:

+			self.nw, self.ne, self.se, self.sw = map(self.__class__, self.boundary.subdivide())

+			while self.points:

+				point = self.points.pop()

+				if self.nw.insert(point): pass

+				elif self.ne.insert(point): pass

+				elif self.se.insert(point): pass

+				elif self.sw.insert(point): pass

+

+		elif self.nw.insert(p): return True

+		elif self.ne.insert(p): return True

+		elif self.se.insert(p): return True

+		elif self.sw.insert(p): return True

+

+		return False

+

+	def query(self, range):

+		pointsInRange = []

+

+		if not self.boundary.intersectsAABB(range):

+			return pointsInRange

+

+		for p in self.points:

+			if range.containsPoint(p):

+				pointsInRange.append(p)

+

+		if self.nw is None: return pointsInRange

+

+		pointsInRange.extend(self.nw.query(range))

+		pointsInRange.extend(self.ne.query(range))

+		pointsInRange.extend(self.se.query(range))

+		pointsInRange.extend(self.sw.query(range))

+

+		return pointsInRange

+

+	def visualize(self):

+		points = self.query(self.boundary)

+		import numpy

+		out = numpy.zeros(self.boundary.halfDimension * 2).astype('int')

+		for p in points:

+			out[p] = 1

+

+		for row in out:

+			for cell in row:

+				if cell == 1: print('#',end='')

+				elif cell == 0: print(' ',end='')

+			print()

+

+a = QuadTree(AABB(XY(128,128), XY(128,128)))

+import random

+for x in range(128):

+	for y in range(128):

+		if not a.insert(XY(x,y)):

+			pass #print (x,y)

+#points = {XY(random.randrange(128),random.randrange(128)) for ___ in range(300)}

+#for p in points:

+	#a.insert(p)

+#a.visualize()

@@ -111,12 +111,13 @@ class LevelMap(object):

 		self.fovmaps = [None]

 	def get_tile_type(self, level,x,y):

-		tile_val = mapping.get(self.map.data[level][y][x],(None,' '))[1]

+		lvl = self.map.get_level(level)

+		tile_val = mapping.get(lvl[y][x],(None,' '))[1]

 		return names.get(tile_val,('',True,True))

 	def get_fovmap(self,level):

 		if level >= len(self.fovmaps):

-			levelmap = self.map.data[level]

+			levelmap = mp.get_level(level)

 			self.fovmaps.append(libtcod.map_new(len(levelmap), len(levelmap[0])))

 			libtcod.map_clear(self.fovmaps[-1])

 		return self.fovmaps[level]

@@ -151,7 +152,8 @@ class LevelMap(object):

 	def calculate_level(self, level):

 		if not self.has_level(level):

 			print 'calculate_level'

-			for y,row in enumerate(mp.data[level]):

+			lvl = mp.get_level(level)

+			for y,row in enumerate(lvl):

 				for x,__ in enumerate(row):

 					lm.adj_map(level, x,y)

@@ -164,7 +166,8 @@ for c in [con,message_con]:

 	libtcod.console_clear(c)

 offset_x, offset_y = 0,0

-MAP_Y,MAP_X = len(mp.data[level]), len(mp.data[level][0])

+levelmap = mp.get_level(level)

+MAP_Y,MAP_X = len(levelmap), len(levelmap[0])

 player_x, player_y = random.randrange(0,MAP_X),random.randrange(0,MAP_Y)

 if not lm.get_walkable(level,player_x,player_y):

 	player_x,player_y = [(x,y) for x in range(player_x-2,player_x+3) for y in range(player_y-2,player_y+3) if lm.get_walkable(level,x,y)][-1]

@@ -188,7 +191,7 @@ while not libtcod.console_is_window_closed():

 	t1 = time.time()

 	lm.comp_fov(level, player_x, player_y,10)

 	player_screen_pos = player_x-offset_x,player_y-offset_y

-	for y,row in enumerate(mp.data[level][offset_y:offset_y+Settings.SCREEN_HEIGHT]):

+	for y,row in enumerate(levelmap[offset_y:offset_y+Settings.SCREEN_HEIGHT]):

 		for x,cell in enumerate(row[offset_x:offset_x+Settings.SCREEN_WIDTH]):

 			color,char,bgcolor = mapping.get(cell, (libtcod.Color(0,0,0),' ',libtcod.Color(0,0,0)))

@@ -279,7 +282,8 @@ while not libtcod.console_is_window_closed():

 	else:

 		player_prop = player_x/MAP_X, player_y/MAP_Y

 		offset_prop = offset_x/MAP_X, offset_y/MAP_Y

-		MAP_Y,MAP_X = len(mp.data[level]), len(mp.data[level][0])

+		levelmap = mp.get_level(level)

+		MAP_Y,MAP_X = len(levelmap), len(levelmap[0])

 		libtcod.console_clear(0)

 		libtcod.console_clear(con)

@@ -1,21 +1,22 @@

+

 # Copyright (c) 2013 Edward Langley

 # All rights reserved.

-# 

+#

 # Redistribution and use in source and binary forms, with or without

 # modification, are permitted provided that the following conditions

 # are met:

-# 

+#

 # Redistributions of source code must retain the above copyright notice,

 # this list of conditions and the following disclaimer.

-# 

+#

 # Redistributions in binary form must reproduce the above copyright

 # notice, this list of conditions and the following disclaimer in the

 # documentation and/or other materials provided with the distribution.

-# 

+#

 # Neither the name of the project's author nor the names of its

 # contributors may be used to endorse or promote products derived from

 # this software without specific prior written permission.

-# 

+#

 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

@@ -29,6 +30,7 @@

 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 from __future__ import division

+import collections

 import random

 import numpy

@@ -62,24 +64,84 @@ P2

 %(data)s

 """

+class MapData(collections.MutableMapping):

+	def __init__(self, data, base=9):

+		self.data = data

+		self.base = base

+		self.below = [[None for __ in range(base)] for ___ in range(base)]

+

+	@classmethod

+	def rand_new(cls, mean, base=9):

+		data = numpy.random.normal(mean, max(mean/4,1), (base,base)).astype(int)

+		return cls(data,base)

+

+	def get_cell(self, x,y, depth=1):

+		cur = self

+		if depth > 1:

+			below = self.get_below(x,y)

+			depth -= 1

+			while depth > 1:

+				below = below.get_below(0,0)

+				depth -= 1

+			cur = below

+		return cur.data[y,x]

+

+	def get_below(self, x,y):

+		below = self.below[y][x]

+		if below is None:

+			mean = self.get_cell(x,y)

+			below = self.below[y][x] = self.rand_new(mean,self.base)

+		return below

+

+	def get_all_below(self):

+		for y, lis in enumerate(self.below):

+			for x, val in enumerate(lis):

+				if val is not None: continue

+				self.get_below(x,y)

+		return numpy.concatenate([numpy.concatenate([x.data for x in l],1) for l in self.below])

+

+	def get_rect_below(self, x,y, w,h):

+		tw = w/self.base

+		tw = int(numpy.ceil(tw))

+		th = h/self.base

+		th = int(numpy.ceil(th))

+		out = []

+		for ny  in range(y,min(len(self.data),y+th)):

+			out.append([])

+			for nx in range(x,min(len(self.data[0]),x+tw)):

+				out[-1].append(self.get_below(nx,ny))

+

+		return numpy.concatenate([numpy.concatenate([x.data for x in l],1) for l in out])[:h,:w]

+

+	def __getitem__(self, key):

+		return self.data.__getitem__(key)

+	def __delitem__(self, key):

+		self.data.__setitem__(key, 0.0)

+	def __len__(self):

+		return len(self.data)

+	def __setitem__(self, key, value):

+		self.data.__setitem__(key, value)

+	def __iter__(self):

+		return iter(self.data)

+

+

 class Map(object):

 	def __init__(self, data, depth, base=9):

 		self.data = data

 		self.depth = depth

 		self.base = base

+

 	@classmethod

 	def rand_new(cls, depth,base=9):

-		data = [numpy.random.random_integers(0,10,(1,1))]

-		for x in range(1,depth+1):

-			global out

-			out = numpy.zeros((base**x, base**x),'int')

-			for r, row in enumerate(data[-1]):

-				for c, col in enumerate(row):

-					new = numpy.random.normal(col,max(col/4,1),(base,base)).astype(int)

-					out[r*base:r*base+base,c*base:c*base+base] = new

-			data.append(out)

+		data = MapData.rand_new(numpy.random.randint(0,10),base)

 		return cls(data,depth)

+	def get_level(self, level):

+		cur = self.data

+		for idx in range(1, level):

+			cur = cur.get_below(0,0)

+		return cur.get_rect_below(0,0, self.base**level, self.base**level)

+

 	def to_pgm(self,level):

 		level = self.data[level].copy()

 		level -= min(l.min() for l in self.data)

deleted file mode 100644

Binary files a/terminal.png and b/terminal.png differ