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

+.*.swp

+

 *.py[cod]

new file mode 100644

@@ -0,0 +1,36 @@

+grass:

+   char: '.'

+   fg: [0,255,0]

+   bg: [0,100,0]

+   passable: true

+   transparent: true

+   prob: 10

+sand:

+   char: ','

+   fg: [255,255,0]

+   bg: [100,100,0]

+   passable: true

+   transparent: true

+scrub:

+   char: ','

+   fg: [0,127,0]

+   bg: [0,64,0]

+   passable: true

+   transparent: true

+water:

+   char: '~'

+   fg: [128,128,255]

+   bg: [64,64,128]

+   transparent: true

+   prob: 5

+brush:

+   char: '#'

+   fg: [0,122,0]

+   bg: [0,64,0]

+   passable: true

+   prob: 0.5

+tree:

+   char: '#'

+   fg: [0,244,0]

+   bg: [0,122,0]

+   prob: 0.1

new file mode 100644

@@ -0,0 +1,9 @@

+class Cache(object):

+	def __init__(self):

+		self.cache = {}

+	def add(self, key, value):

+		self.cache[key] = value

+	def get(self, key, cb):

+		if key not in self.cache:

+			self.add(key, cb())

+		return self.cache[key]

new file mode 100644

@@ -0,0 +1,328 @@

+from . import dice

+from .dice import MULT,ADD

+from . import type_dict

+

+import collections

+

+class Attributes(object):

+	def __init__(self, strength, intellect, dexterity, spirit):

+		self.str = strength

+		self.int = intellect

+		self.dex = dexterity

+		self.spt = spirit

+		self.state = HEALTHY

+

+def health_mod(func):

+	def _inner(self):

+		mod = 0

+		if self.attr.state >= WOUNDED:

+			mod = -3

+		result = func(self)

+		result += mod

+		return result

+	return _inner

+

+

+

+class Skills(object):

+	def __init__(self, attr):

+		self.skills = {

+			'agility','craft','fighting','knowledge',

+			'perception','persuasion','shooting','speed',

+			'stealth','toughness'

+		}

+		self.attr = attr

+		self.training = Trainer(self)

+		self.train = self.training.select

+

+	def check(self, skill, dieroll):

+		dieroll.dice = dice.DieJar().d20

+		roll = dieroll.roll()

+		if roll == 1:

+			result = False

+		if roll == 20:

+			result = True

+		else:

+			result = roll < getattr(self, skill)

+		return result, roll-result # (passes, difference)

+

+	@property

+	@health_mod

+	def agility(self):

+		return (self.attr.dex * 2) + self.training.agility

+	@property

+	@health_mod

+	def craft(self):

+		return self.attr.dex + self.attr.int + self.training.craft

+	@property

+	@health_mod

+	def fighting(self):

+		return self.attr.str + self.attr.int + self.training.fighting

+	@property

+	@health_mod

+	def knowledge(self):

+		return self.attr.int * 2 + self.training.knowledge

+	@property

+	@health_mod

+	def perception(self):

+		return self.attr.int + attr.spt + self.training.perception

+	@property

+	@health_mod

+	def persuasion(self):

+		return self.attr.spt * 2 + self.training.persuasion

+	@property

+	@health_mod

+	def shooting(self):

+		return self.attr.dex + self.attr.int + self.training.shooting

+	@property

+	@health_mod

+	def speed(self):

+		return self.attr.str + self.attr.dex + self.training.speed

+	@property

+	@health_mod

+	def stealth(self):

+		return self.attr.dex + self.attr.spt + self.training.stealth

+	@property

+	@health_mod

+	def toughness(self):

+		return self.attr.str + self.attr.spt + self.training.toughness

+

+class Trainer(object):

+	mods = dict(

+		untrained=-1,

+		familiar=0,

+		trained=1,

+		experienced=2,

+		mastered=3

+	)

+

+	def __init__(self, skills):

+		self.skills = skills

+		self.training = collections.defaultdict(lambda: -1)

+		self.points = 500

+		self.training_cost = 100

+

+	def select(self, skill, degree):

+		if hasattr(degree, 'upper'):

+			degree = self.mods.get(degree, 0)

+		if self.points >= self.training_cost and degree in self.mods.values():

+			self.training[skill] = degree

+			self.points -= self.training_cost

+

+	def __getattr__(self, key):

+		skills = object.__getattribute__(self, 'skills')

+		if key in self.skills.skills:

+			return self.training[key]

+		else:

+			raise

+	def __setattr__(self, key, value):

+		if hasattr(self, 'skills') and key in self.skills.skills:

+			if -1 <= value <= 3:

+				self.training[key] = int(round(value))

+			else:

+				raise AttributeError(

+					'cannot set training of %s to %d, (out of range [-1,3])' % (key, value)

+				)

+		else:

+			object.__setattr__(self, key, value)

+

+

+class Equipment(object): pass

+class Weapon(Equipment): pass

+class Armor(Equipment): pass

+

+

+class Slot(object):

+	def __init__(self, name, type):

+		self.name = name

+		self.attr = 'slotted_%s' % name

+		self.type = type

+

+	def __get__(self, instance, owner):

+		return self.getitem(instance)

+	def __set__(self, instance, value):

+		self.setitem(instance, value)

+

+	def setitem(self, instance, value):

+		if isinstance(value, self.type):

+			setattr(instance, 'slotted_%s' % self.name, value)

+		else:

+			raise ValueError(

+				'Can\'t use an object of type %s in a slot of type %s' % (type(value), self.type)

+			)

+

+

+	def getitem(self, instance):

+		return getattr(instance, self.attr, None)

+

+	def filled(self, instance):

+		return self.getitem(instance) is not None

+

+	@classmethod

+	def add_slot(cls, name, type):

+		def _inner(to_cls):

+			inst = cls(name, type)

+			setattr(to_cls, name, inst)

+			if not hasattr(to_cls, 'equipment_slots'):

+				to_cls.equipment_slots = Slots((name,inst))

+			else:

+				to_cls.equipment_slots[name] = inst

+			return to_cls

+		return _inner

+

+

+class Slots(collections.MutableMapping):

+	def __init__(self, *args, **kw):

+		self.slots = dict(args)

+		self.slots.update(kw)

+		self.slots_by_type = type_dict.TypeDict(__default=[])

+		for k in self.slots:

+			slot = self.slots[k]

+			self.slots_by_type[slot.type].append(slot)

+

+	def __getitem__(self, key):

+		return self.slots[key]

+	def __setitem__(self, k, v):

+		self.slots[k] = v

+	def __delitem__(self, key):

+		del self.slots[key]

+

+	def __iter__(self):

+		return iter(self.slots)

+	def __len__(self):

+		return len(self.slots)

+

+	def slots_of_type(self, slot_type):

+		return self.slots_by_type[slot_type]

+

+class Race(object):

+	registry = {}

+	@classmethod

+	def register(cls, new):

+		cls.registry[new.__name__.lower()] = new

+

+	@classmethod

+	def random_race(cls):

+		return random.choice(self.registry.values())

+	@property

+	def name(self):

+		return self.__class__.__name__.lower()

+

+	allowed_professions = set()

+	def __init__(self, attr):

+		self.mod(attr)

+

+	def allows_profession(self, prof):

+		return prof in self.allowed_professions

+

+@Race.register

+class Human(Race):

+	def mod(self, attr):

+		attr.spt += 1

+

+@Race.register

+class Elf(Race):

+	allowed_professions = {'fighter', 'wizard', 'thief'}

+	def mod(self, attr):

+		attr.int += 1

+

+@Race.register

+class Dwarf(Race):

+	allowed_professions = {'fighter', 'Priest', 'thief'}

+	def mod(self, atr):

+		attr.str += 1

+

+@Race.register

+class Hobbit(Race):

+	allowed_professions = {'thief', 'barbarian'}

+	def mod(self, atr):

+		attr.dex += 1

+

+

+class Sword(Weapon):

+	attack = 1

+	damage_mod = 1

+

+

+HEALTHY = 0

+WOUNDED = 1

+KNOCKOUT = 2

+

+@Slot.add_slot('weapon', Weapon)

+@Slot.add_slot('armor', Armor)

+class Adventurer(object):

+	@property

+	def state(self):

+		return self.attributes.state

+	@state.setter

+	def state(self, val):

+		if val not in {HEALTHY, WOUNDED, KNOCKOUT}:

+			raise ValueError('Value for state invalid')

+		self.attributes.state = val

+

+	def __init__(self, name, race, str, int, dex, spt):

+		self.name = name

+		self.attributes = Attributes(str, int, dex, spt)

+		self.skills = Skills(self.attributes)

+		self.race = Race.registry[race](self.attributes)

+

+	def wield(self, slot, equipment):

+		turns = 1

+		if self.equipment_slots[slot].filled(self):

+			turns += 1

+		self.equipment_slots[slot].setitem(self, equipment)

+		return turns

+

+	def attack(self, opponent, type='fighting', num_allies=0):

+		dieroll = dice.DieRoll()

+

+		ally_bonus = -1 if num_allies > 0 else 0

+		# TODO: implement professions, figure out how to mod ally_bonus for thieves cleanly

+		dieroll.add_adjustment(add=ally_bonus)

+

+		pass_, damage = self.skills.check(type, dieroll)

+		if pass_:

+			if self.weapon is not None:

+				damage += self.weapon.damage_mod

+			print '%s inflicts %d damage upon %s' % (self.name, damage, opponent.name)

+			opponent.take_damage(damage)

+

+	def take_damage(self, damage):

+		if self.armor is not None:

+			damage += self.armor.damage_mod

+

+		dieroll = dice.DieRoll()

+		dieroll.add_adjustment(-damage)

+

+		result, damage = self.skills.check('toughness', dieroll)

+

+		if not result:

+			if damage > 0:

+				self.state += 1

+				print '%s takes %d damage and is now %s' % (self.name, damage, ['healthy', 'wounded', 'ko'][self.state if self.state < 3 else 2])

+				if self.state >= KNOCKOUT:

+					self.die()

+

+	def die(self): pass

+

+def get_stats():

+	stats = [7,7,7,7]

+	import random

+	mod = +1

+	for x in range(100):

+		idx = random.choice([x for x in range(len(stats)) if stats[x] > 5])

+		stats[idx] += mod

+		mod *= -1

+	print sum(stats), stats

+	return stats

+

+

+a = Adventurer('bob', 'elf', *get_stats())

+b = Adventurer('bill', 'elf', *get_stats())

+

+while KNOCKOUT not in {a.state, b.state}:

+	a.attack(b)

+	b.attack(a)

+

+print a.name, 'is', ['healthy', 'wounded', 'ko'][a.state if a.state < 3 else 2]

+print b.name, 'is', ['healthy', 'wounded', 'ko'][b.state if b.state < 3 else 2]

new file mode 100644

@@ -0,0 +1,173 @@

+import random

+import collections

+import itertools

+import re

+

+basestr = (str,unicode)

+

+class DieJar(object):

+	parser = re.compile(r'^(?:_?(?P<num>[1-9][0-9]*))?d(?P<sides>[1-9][0-9]*)$')

+	def __getattr__(self, key):

+		out = []

+		for sect in key.split('__'):

+			out.extend(self.parse_section(sect))

+		return Dice(out)

+

+	def parse_section(self, key):

+		out = self.parser.match(key)

+		if out is None:

+			raise AttributeError('invalid die specification')

+		else:

+			dct = out.groupdict()

+			dct['sides'] = int(dct['sides'])

+			dct['num'] = int(dct['num'] or 1)

+			dice = [Die(dct['sides']) for __ in range(dct['num'])]

+			return dice

+

+

+

+

+

+def iterable(obj):

+	return (not isinstance(obj, basestr)) and isinstance(obj, collections.Iterable)

+

+def flatten(lis):

+	return itertools.chain(*[(x if iterable(x) else [x]) for x in lis])

+

+class Die(object):

+	'Note: hashed by sides, min and step.  Consequently not necessarily preserved when used as a dictionary key'

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

+		self.sides = sides

+		self.min = min

+		self.step = 1

+		self.sides = sides

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

+		self._value = None

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

+

+	def roll(self):

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

+		return self._value

+

+	@property

+	def value(self):

+		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 __str__(self):

+		base = 'd%d' % self.sides

+		if self.min != 1:

+			base = '%s+%d' % (base,self.min)

+		if self.step != 1:

+			base = '(%s)*%d' % (base, self.step)

+		return base

+

+	def __eq__(self, other):

+		return (self.sides == other.sides) and (self.min == other.min) and (self.step == other.step)

+

+	def __hash__(self):

+		return hash((self.sides,self.min,self.step))

+

+class Dice(collections.Sequence):

+	'A collection of dice, can be initialized either with Die instances or lists of Die instances'

+

+	def __init__(self, *dice, **kw):

+		self.dice = list(flatten(dice))

+		self.combiner = kw.get('combiner', lambda a,b:a+b)

+

+	def __getitem__(self, k): return self.dice[k]

+	def __len__(self): return len(self.dice)

+

+	def roll(self):

+		return reduce(self.combiner, (die.roll() for die in self.dice))

+	def __str__(self):

+		groups = collections.Counter(self.dice)

+		out = []

+		dice = sorted(groups, key=lambda k:-groups[k])

+		if len(dice) > 1:

+			for die in dice[:-1]:

+				count = groups[die]

+				out.append('%d%s' % (count,die))

+			out = ','.join(out)

+			out = ' and '.join([out, str(dice[-1])])

+		else:

+			out = '%d%s' % (groups[dice[0]],dice[0])

+

+

+		return out

+

+

+

+MULT=1

+ADD=2

+class DieRoll(object):

+	def __init__(self, dice=None, adjustments=None):

+		self.dice = dice

+		self.adjustments = [] if adjustments is None else adjustments

+

+	def add_adjustment(self, add=None, mult=None):

+		if None not in {add,mult}: raise ValueError('can\'t add two adjustments at once')

+		elif {add,mult} - {None} == set(): raise ValueError('No adjustment given')

+

+		if add is not None:

+			adjustment = (ADD,add)

+		elif mult is not None:

+			adjustment = (MULT,mult)

+		self.adjustments.append(adjustment)

+

+	def roll(self):

+		result = self.dice.roll()

+		for type,bonus in self.adjustments:

+			if type == MULT:

+				result *= type

+			elif type == ADD:

+				result += bonus

+		return result

+

+if __name__ == '__main__':

+	import unittest

+	tests = unittest.TestSuite()

+	inst = lambda a:a()

+

+	class TestDie(unittest.TestCase):

+		def test_roll_plain(self):

+			a = Die(6)

+			for __ in range(40):

+				self.assertLess(a.roll(), 7)

+				self.assertGreater(a.roll(), 0)

+		def test_roll_min(self):

+			a = Die(6,min=4)

+			for __ in range(40):

+				self.assertLess(a.roll(), 6+4+1)

+				self.assertGreater(a.roll(), 3)

+		def test_roll_step(self):

+			a = Die(6,step=2)

+			for __ in range(40):

+				self.assertLess(a.roll(), 6+(6*2)+1)

+				self.assertGreater(a.roll(), 0)

+				self.assertTrue((a.roll()-1) % 2 == 0)

+		def test_str(self):

+			self.assertEqual(str(Die(6)), 'd6')

+			self.assertEqual(str(Die(6,min=2)), 'd6+2')

+

+	class TestDice(unittest.TestCase):

+		def test_init(self):

+			dice = [Die(6) for __ in range(20)]

+			a = Dice(dice)

+			self.assertEqual(dice,a.dice)

+			a = Dice(*dice)

+			self.assertEqual(dice,a.dice)

+		def test_roll(self):

+			dice = [Die(6) for __ in range(2)]

+			dice = Dice(dice)

+			self.assertGreater(dice.roll(), 1)

+			self.assertLess(dice.roll(), 13)

+

+	class TestDieRoll(unittest.TestCase):

+		pass

+

+	unittest.main()

new file mode 100644

@@ -0,0 +1,74 @@

+# Copyright (c) 2011 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

+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

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

+

+import random

+import numpy.random

+

+class MyRand(random.Random):

+  def random(self):

+    return numpy.random.random()

+  def seed(self, a=None):

+    if a is None:

+      import time

+      a = time.time() * 10000

+    print a

+    numpy.random.seed(int(a))

+    self.gauss_next = None

+  def setstate(self, state):

+    numpy.random.set_state(state)

+  def getstate(self):

+    return numpy.random.get_state()

+  def jumpahead(self, n):

+    self.seed()

+

+_inst = random._inst = MyRand()

+random.seed = _inst.seed

+random.random = _inst.random

+random.uniform = _inst.uniform

+random.triangular = _inst.triangular

+random.randint = _inst.randint

+random.choice = _inst.choice

+random.randrange = _inst.randrange

+random.sample = _inst.sample

+random.shuffle = _inst.shuffle

+random.normalvariate = _inst.normalvariate

+random.lognormvariate = _inst.lognormvariate

+random.expovariate = _inst.expovariate

+random.vonmisesvariate = _inst.vonmisesvariate

+random.gammavariate = _inst.gammavariate

+random.gauss = _inst.gauss

+random.betavariate = _inst.betavariate

+random.paretovariate = _inst.paretovariate

+random.weibullvariate = _inst.weibullvariate

+random.getstate = _inst.getstate

+random.setstate = _inst.setstate

+random.jumpahead = _inst.jumpahead

+random.getrandbits = _inst.getrandbits

+

new file mode 100644

@@ -0,0 +1,72 @@

+import collections

+import copy

+

+class TypeDict(collections.MutableMapping):

+	def __init__(self, *args, **kw):

+		if '__default' in kw:

+			self.default = kw.pop('__default')

+

+		self.store = dict(args)

+		self.store.update(kw)

+

+	def get_store(self, cls):

+		cur = self.store

+		bases = cls.__bases__

+		if bases:

+			head, tail = bases[0], bases[1:]

+			while tail:

+				cur = self.store.setdefault(head, {})

+				head, tail = tail[0], tail[1:]

+		return cur

+

+	def __getitem__(self, cls):

+		store = self.get_store(cls)

+		try:

+			print store

+			return store[cls]

+		except KeyError:

+			if hasattr(self, 'default'):

+				return copy.copy(self.default)

+			else:

+				raise

+

+	def __setitem__(self, cls, value):

+		store = self.get_store(cls)

+		store[cls] = value

+	def __delitem__(self, cls):

+		store = self.get_store(cls)

+		del store[cls]

+

+	def __iter__(self):

+		return TypeDictIterator(self)

+	def __len__(self):

+		return len(self.slots)

+

+class _Null: pass

+

+class TypeDictIterator(collections.Iterator):

+	def __init__(self, dct):

+		self.dct = dct

+		self.dcts = [dct]

+		self.iters = [iter(dct)]

+		self.cur = self.iters[-1]

+

+	def next(self):

+		result = _Null

+		try: result = self.cur.next()

+		except StopIteration:

+			self.iters.pop()

+			self.dcts.pop()

+			if self.iters:

+				self.cur = self.iters[-1]

+				result = self.cur.next()

+			else:

+				raise StopIteration

+

+		if result in self.dcts[-1] and self.dcts[-1][result]:

+			self.iters.append(iter(self.dcts[-1][result]))

+			self.cur = self.iters[-1]

+

+		return result

+

+

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

+import libs.patch_random

+import random

+random.seed(2)

+

 import libtcodpy as tc

 import numpy as np

@@ -19,14 +23,17 @@ class Application(object):

 		self.events = events.EventHandler()

 		player.ArrowHandler(self.player, self.events)

-

-

+		self.actors = []

+		for x in range(40):

+			self.actors.append(player.Actor(random.randrange(100), random.randrange(63), self.map))

 		tc.sys_set_fps(60)

 	def init(self):

 		self.screen.init("test")

 		self.player.draw()

+		for actor in self.actors:

+			actor.draw()

 	def run(self):

 		while not tc.console_is_window_closed():

@@ -53,7 +53,7 @@ class Map(object):

 			ox,oy = object.pos

 			x = squeeze(ox+dx, 0, self.width-1)

 			y = squeeze(oy+dy, 0, self.height-1)

-			if not self.fov.is_passable((x,y)):

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

 				x,y = ox,oy

 		else:

@@ -61,7 +61,7 @@ class Map(object):

 			tx,ty = ox+dx, oy+dy

 			gx,gy = ox,oy

 			for x,y in libs.bresenham.line(ox,oy, tx,ty, 1):

-				if not self.fov.is_passable((x,y)): break

+				if not self.is_passable((x,y)): break

 				else: gx,gy = x,y

 			x,y = gx,gy

@@ -75,6 +75,19 @@ class Map(object):

 			if (x,y) in self.overlays and self.overlays[x,y] == []:

 				self.overlays.pop((x,y))

+	def set_pov(self, pov):

+		self.pov = pov

+

+	def get_visible_objects(self):

+		o,r = self.pov

+		results = set()

+		for x,y in self.overlays:

+			if self.fov.is_visible(o,r, (x,y)):

+				results.update(self.overlays[x,y])

+		return results

+

+

+

 	def get_rgb(self, colors, fg=True,slices=(slice(0),slice(0))):

 		result = np.rollaxis(colors[slices], 2)

 		return [x.transpose() for x in result]

@@ -123,6 +136,12 @@ class Map(object):

 	def dim(self):

 		return self.width, self.height

+	def is_passable(self, coord):

+		if coord in self.overlays and any(x.blocks for x in self.overlays[coord]):

+			return False

+		else:

+			return self.fov.is_passable(coord)

+

 class FovCache(object):

 	# TODO: get allow updates to base_map

@@ -1,8 +1,10 @@

 import libtcodpy as tc

+import libs.combat

 class Actor(object):

 	char = ord('@')

 	color = (255,0,0)

+	blocks = True

 	@property

 	def pos(self):

@@ -20,11 +22,20 @@ class Actor(object):

 		dx, dy = self.map.move(self, dx,dy)

 		self.x += dx

 		self.y += dy

-		self.map.pov = (self.pos, 10)

+

+	def tick(self):

+		pass

 class Player(Actor):

 	char = ord('@')

 	color = (255,255,255)

+	light_radius = 10

+	def __init__(self, x,y, map):

+		Actor.__init__(self, x,y, map)

+		self.map.set_pov((self.pos, self.light_radius))

+	def move(self, dx, dy):

+		Actor.move(self, dx,dy)

+		self.map.set_pov((self.pos, self.light_radius))

 class ArrowHandler(object):

 	def __init__(self, player, eh):

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