@@ -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,122 @@

+from . import dice

+

+from .combat_parts import races

+from .combat_parts import equipment

+from .combat_parts import skills

+from .combat_parts import constants as const

+

+import collections

+import random

+

+def get_stats(sum_):

+	stats = [sum_/4]*4

+	if sum(stats) != sum_:

+		stats[0] += sum_ - sum(stats)

+

+	mod = +1

+	for x in range(100):

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

+		stats[idx] += mod

+		mod *= -1

+	return stats

+

+class Attributes(object):

+	@classmethod

+	def randomize(cls, sum_):

+		chosen_stats = get_stats(sum_)

+		return cls(*chosen_stats)

+

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

+		self.str = strength

+		self.int = intellect

+		self.dex = dexterity

+		self.spt = spirit

+		self.state = const.HEALTHY

+	def __str__(self):

+		return '%s %s %s %s %s' % (self.str, self.int, self.dex, self.spt, self.state)

+

+

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

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

+class Adventurer(object):

+	@property

+	def state(self):

+		return self.attributes.state

+	@state.setter

+	def state(self, val):

+		if val < 0: val == 0

+		if val > const.KNOCKOUT: val = const.KNOCKOUT

+		self.attributes.state = val

+

+	@classmethod

+	def randomize(cls, stat_sum=28):

+		name = '%s %s%s' % (

+			random.choice(['Bill', 'Bob', 'Jerry']),

+			random.choice(['Longnose', 'Short-Tail', 'Squint']),

+			random.choice(['', ' the Great', ' The Cross-eyed', ' The Magnificent'])

+		)

+		race = races.Race.random_race()

+		attr = Attributes.randomize(stat_sum)

+		print attr

+		return cls(name, race, attr)

+

+	@classmethod

+	def with_stats(cls, name, race, str, int, dex, spt):

+		attr = Attributes(str, int, dex, spt)

+		return cls(name, race, attr)

+

+	def __init__(self, name, race, attr):

+		self.name = name

+		self.attributes = attr

+		self.skills = skills.Skills(self.attributes)

+		self.race = races.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, __ = 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 >= const.KNOCKOUT:

+					self.die()

+

+	def die(self): pass

+

+if __name__ == '__main__':

+	a = Adventurer.randomize(28)

+	b = Adventurer.randomize(28)

+

+	while const.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

new file mode 100644

@@ -0,0 +1,5 @@

+HEALTHY = 0

+WOUNDED = 1

+KNOCKOUT = 2

+

+

new file mode 100644

@@ -0,0 +1,77 @@

+from .. import type_dict

+

+import collections

+

+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 Sword(Weapon):

+	attack = 1

+	damage_mod = 1

+

+

new file mode 100644

@@ -0,0 +1,48 @@

+import random

+

+class Race(object):

+	registry = {}

+	@classmethod

+	def register(cls, new):

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

+

+	@classmethod

+	def random_race(cls):

+		return random.choice(cls.registry.keys())

+

+	@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, attr):

+		attr.str += 1

+

+@Race.register

+class Hobbit(Race):

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

+	def mod(self, attr):

+		attr.dex += 1

+

+

+

new file mode 100644

@@ -0,0 +1,124 @@

+from ..dice import MULT, ADD

+from .. import dice

+from .constants import *

+

+import collections

+

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

+		die = dice.DieJar().d20

+		if dieroll is None:

+			dieroll = die

+		else:

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

+

+

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,119 @@

+import abc

+import collections

+from . import combat

+

+class Overlay(object):

+	__metaclass__ = abc.ABCMeta

+

+	char = abc.abstractproperty()

+	color = (0,0,0)

+	blocks = False

+

+	@property

+	def pos(self):

+		return self.x, self.y

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

+		self.events = collections.OrderedDict()

+		self.x = x

+		self.y = y

+		self.map = map

+		for key, value in self.handled_events.viewitems():

+			self.events.setdefault(key, []).extend(value)

+

+	def draw(self):

+		self.map.add(self)

+

+	def register_event(self, event, cb):

+		'''register a callback for an event

+

+		if the callback returns a false value besides None, execution will end after that event'''

+		self.events.setdefault(event, []).append(cb)

+

+	def trigger_event(self, event, *args, **kw):

+		if event not in self.events:

+			raise ValueError('%r has no event %r' % (self, event))

+

+		for cb in self.events[event]:

+			result = cb(self, *args, **kw)

+			result = result is None or result # if the event returns a false value besides None, break

+			if result == False: break

+

+	handled_events = collections.OrderedDict()

+	@classmethod

+	def handle_event(cls, event):

+		def _inner(cb):

+			cls.handled_events.setdefault(event, []).append(cb)

+			return cb

+		return _inner

+

+

+

+class Actor(Overlay):

+	char = ord('@')

+	color = (255,0,0)

+	blocks = True

+

+	@property

+	def pos(self):

+		return self.x, self.y

+

+	def __init__(self, x,y, map, adventurer=None):

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

+		self.inventory = []

+		if adventurer is None:

+			adventurer = combat.Adventurer.randomize()

+		self.adventurer = adventurer

+

+	def move(self, dx, dy):

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

+		self.x += dx

+		self.y += dy

+

+	def tick(self):

+		result = True

+		if self.adventurer.state >= 2:

+			result = False

+			self.char = ord('%')

+			self.blocks = False

+		return result

+

+	def ishostile(self, other):

+		return self.adventurer.state < 2 #TODO: implement factions

+

+	def bump(self, other):

+		print '%s bumped %s' % (type(self).__name__, type(other).__name__)

+		if isinstance(other, Actor) and other.ishostile(self):

+			self.adventurer.attack(other.adventurer)

+			other.trigger_event('attacked', self)

+		elif isinstance(other, Object):

+			self.pickup(other)

+			other.trigger_event('picked_up', self)

+

+		other.trigger_event('bumped', self)

+

+	@Overlay.handle_event('attacked')

+	def attacked_by(self, other):

+		if self.adventurer.skills.check('agility'):

+			self.adventurer.attack(other.adventurer)

+

+	@Overlay.handle_event('bumped')

+	def bumped_by(self, other):

+		print '%s was bumped by %s' % (type(self).__name__, type(other).__name__)

+

+class Object(Overlay):

+	item = None

+	@Overlay.handle_event('picked_up')

+	def picked_up_by(self, other):

+		self.map.remove(self)

+

+class Weapon(Object):

+	item = None

+

+class Potion(Object):

+	char = ord('!')

+

+class Scroll(Object):

+	char = ord('!')

+

+class Equipment(Object):

+	pass

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