@@ -51,8 +51,11 @@ class GameBase:

 	color_light_ground = libtcod.Color(200,200,200)

-	def message(self, msg, color):

-		utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, msg, color)

+	def message(self, msg, color=None):

+		if color is not None:

+			utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, msg, color)

+		else:

+			utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, msg)

 	def __init__(self, app_name='test app', screen_width=SCREEN_WIDTH, screen_height=SCREEN_HEIGHT):

 		print '__init__'

@@ -150,10 +153,12 @@ class GameBase:

 		libtcod.console_blit(self.panel, 0,0, self.SCREEN_WIDTH,self.PANEL_HEIGHT, 0,0, self.PANEL_Y)

 	def inventory_menu(self, header):

-		index = self.menu(self.con, header, self.player.get_item_names(), self.INVENTORY_WIDTH)

+		data = [(item.display_name, item.ident) for item in self.player.get_items()]

+		display = [x[0] for x in data]

+		index = self.menu(self.con, header, display, self.INVENTORY_WIDTH)

 		if index is not None:

-			return self.player.get_item(index)

+			return self.player.get_item(data[index][1])

 	def get_names_under_mouse(self):

 		x,y = self.mouse.cx, self.mouse.cy

@@ -1,4 +1,7 @@

 from __future__ import division

+import os.path

+import glob

+import yaml

 import libtcodpy as libtcod

 import game

@@ -6,13 +9,59 @@ import objects

 import utilities

 import monsters

 import random

-from main import game_instance, Game

+from main import Game

 class Item(object):

+	def __init__(self, stackable=False):

+		self.stackable = stackable

+		self.stacks_with = []

+		self.stack_limit = 5

+

 	def __new__(*args):

 		res = object.__new__(*args)

 		return res

+	def bind_game(self, game):

+		self.game = game

+	def bind_user(self, user):

+		self.user = user

+		return self.owner

+	def free_user(self):

+		self.user = None

+		return self.owner

+

+class ItemLoader(object):

+	def __init__(self, dir):

+		self.dir = dir

+

+	def load_items(self):

+		for fn in glob.glob(os.path.join(self.dir,'*.yml')):

+			print 'fn', fn

+			for doc in yaml.safe_load_all(file(fn)):

+				self.load_item(doc)

+

+	def load_item(self, doc):

+		_color = doc.get('color', None)

+		if _color is None:

+			_color = libtcod.green

+		elif hasattr(_color, 'upper'):

+			_color = getattr(libtcod, _color)

+		else:

+			_color = libtcod.Color(*_color)

+

+		item_class = doc['item_class']

+		module, clas = item_class.rsplit('.',1)

+		module = __import__(module)

+		item_class = getattr(module, clas)

+		print 'item class:', item_class

+

+		print 'loading', doc

+		@Game.register_item_type(doc['spawn_chance'])

+		class LoadedItem(item_class):

+			name = doc.get('item_description')

+			char = doc.get('char', '!')

+			color = _color

+

 @Game.register_item_type(5)

 class HealingPotion(Item):

@@ -24,10 +73,10 @@ class HealingPotion(Item):

 		result = True

 		if fighter.hp == fighter.max_hp:

-			game.message('You\'re full, can\'t heal', libtcod.red)

+			self.game.message('You\'re full, can\'t heal', libtcod.red)

 			result = False

 		else:

-			game.message('Healing...')

+			self.game.message('Healing...')

 			fighter.heal(10)

 		return result

@@ -54,7 +103,7 @@ class Confusion(Item):

 		result = False

 		if monster is not None:

-			game.message('%s becomes confused' % monster.name)

+			self.game.message('%s becomes confused' % monster.name)

 			monsters.ConfusedMonster(random.randrange(10,18)).attach(

 				monster

 			)

@@ -69,13 +118,13 @@ class Strengthen(Item):

 	color = libtcod.chartreuse

 	def use(self):

 		if self.user.fighter:

-			game.message('%s feels a surge of strength' % self.user.name)

+			self.game.message('%s feels a surge of strength' % self.user.name)

 			self.user.fighter.stat_adjust(20, self.adj)

 		return True

 	def adj(self, owner):

 		return (

-			lambda _: game.message('The surge of strength has subsided'),

+			lambda _: self.game.message('The surge of strength has subsided'),

 			owner.fighter.defense,

 			owner.fighter.power+3

 		)

@@ -87,13 +136,13 @@ class Protect(Item):

 	color = libtcod.chartreuse

 	def use(self):

 		if self.user.fighter:

-			game.message('%s is surrounded by a protecting aura' % self.user.name)

-			self.user.fighter.stat_adjust(10, self.adj)

+			self.game.message('%s is surrounded by a protecting aura' % self.user.name)

+			self.user.fighter.stat_adjust(15, self.adj)

 		return True

 	def adj(self, owner):

 		return (

-			lambda _: game.message('The protecting aura dissipates'),

+			lambda _: self.game.message('The protecting aura dissipates'),

 			owner.fighter.defense+6,

 			owner.fighter.power

 		)

@@ -107,11 +156,11 @@ class LightningBolt(Item):

 		monster = monsters.get_closest_monster(self.user)

 		result = False

 		if monster and self.user.can_see(monster.x, monster.y):

-			game.message('Monster %s has been struck by lightning' % monster.name)

+			self.game.message('Monster %s has been struck by lightning' % monster.name)

 			monster.fighter.take_damage(13)

 			result = True

 		else:

-			game.message('No target')

+			self.game.message('No target')

 		return result

 @Game.register_item_type(5)

@@ -121,19 +170,19 @@ class Jump(Item):

 	color= libtcod.dark_green

 	jump_distance = 3

 	def use(self):

-		game_instance.select(self.jump)

+		self.game.select(self.jump)

 		return True

 	def jump(self, x,y):

 		dist = self.user.distance(x,y)

 		if dist <= self.jump_distance:

 			self.user.x, self.user.y = x,y

-			game.message('you are transported to a new place')

+			self.game.message('you are transported to a new place')

 		elif random.random() < self.jump_distance/dist:

 			self.user.x, self.user.y = x,y

-			game.message('you strain all your power to move %d squares' % int(dist))

+			self.game.message('you strain all your power to move %d squares' % int(dist))

 		else:

-			game.message('you didn\'t make it')

+			self.game.message('you didn\'t make it')

 			self.user.fighter.take_damage( int(round(2 * dist/self.jump_distance)) )

 @Game.register_item_type(3)

@@ -143,8 +192,8 @@ class Acquire(Item):

 	color= libtcod.dark_green

 	effect_distance = 5

 	def use(self):

-		game.message('what do you want?')

-		game_instance.select(self.get)

+		self.game.message('what do you want?')

+		self.game.select(self.get)

 		return True

 	def get(self, x,y):

 		if self.user.distance(x,y) < self.effect_distance:

@@ -157,7 +206,7 @@ class Smite(Item):

 	char = '\x0f'

 	color = libtcod.red

 	def use(self):

-		game_instance.select(self.smite)

+		self.game.select(self.smite)

 		return True

 	def smite(self, x,y):

@@ -165,9 +214,9 @@ class Smite(Item):

 		if monster:

 			monster.fighter.take_damage(10)

 			if monster.fighter:

-				game.message('%s is smitten, he only retains %s hp' % (monster.name, monster.fighter.hp))

+				self.game.message('%s is smitten, he only retains %s hp' % (monster.name, monster.fighter.hp))

 			else:

-				game.message('%s thought it better to go elsewhere' % monster.name)

+				self.game.message('%s thought it better to go elsewhere' % monster.name)

 @Game.register_item_type(2)

@@ -178,7 +227,7 @@ class Fireball(Item):

 	effect_radius = 3

 	def use(self):

-		game_instance.select(self.smite)

+		self.game.select(self.smite)

 		return True

 	def smite(self, x,y):

@@ -189,7 +238,7 @@ class Fireball(Item):

 		for obj in self.owner.level.objects:

 			if obj.fighter and obj is not self.user:

 				if (obj.x, obj.y) == (x,y):

-					game.message('%s takes a direct hit from the fireball' % obj.name)

+					self.game.message('%s takes a direct hit from the fireball' % obj.name)

 					obj.fighter.take_damage(20)

 				elif obj.distance(x,y) < self.effect_radius:

 					obj.fighter.take_damage(6)

@@ -197,5 +246,5 @@ class Fireball(Item):

 						strikes.append('%s %s' % (obj.name, obj.fighter.hp))

 					else:

 						strikes.append('%s dead' % obj.name)

-		game.message('The names of those who were to close for comfort: %s' % ', '.join(strikes))

+		self.game.message('The names of those who were to close for comfort: %s' % ', '.join(strikes))

@@ -86,8 +86,8 @@ class Level(object):

 				cell.explored = True

 			color = libtcod.black

-			#if True:

-			if cell.explored:

+			if True:

+			#if cell.explored:

 				wall = cell.block_sight

 				walkable = not cell.blocked

@@ -57,7 +57,7 @@ if __name__ == 'main':

 		def player_death(self, player):

-			utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, 'You died!')

+			self.message('You died!', libtcod.red)

 			self.game_state = 'dead'

 			player.char = '%'

 			player.color = libtcod.dark_red

@@ -82,7 +82,7 @@ if __name__ == 'main':

 		def register_item_type(cls, chance):

 			def _inner(typ):

 				cls.item_types[typ] = chance

-				return cls

+				return typ

 			return _inner

@@ -90,6 +90,7 @@ if __name__ == 'main':

 		@classmethod

 		def register_monster_type(cls, typ, chance):

 			cls.monster_types[typ] = chance

+			return typ

 		@property

 		def level(self):

@@ -198,6 +199,7 @@ if __name__ == 'main':

 		def mvkeyhandler(self):

 			item = self.inventory_menu('choose item\n')

 			if item is not None:

+				item.bind_game(self)

 				self.player.use(item)

 		@mvkeyhandler.handle('d')

@@ -298,8 +300,11 @@ if __name__ == '__main__':

 	from functools import partial

 	render_bar = partial(render_bar, game_instance.panel)

-	a = MonsterLoader(os.path.join('.','data','monsters'))

-	a.load_monsters()

+	ml = MonsterLoader(os.path.join('.','data','monsters'))

+	ml.load_monsters()

+

+	il = ItemLoader(os.path.join('.','data','items'))

+	il.load_items()

 	game_instance.setup_map()

 	game_instance.main()

@@ -216,6 +216,14 @@ class Smoother(AutomataEngine):

 		else:

 			return cell

+class NewSmoother(AutomataEngine):

+	def rule(self, x,y, cell):

+		avg = self.sum_area( (x,y), 2 ) / 16

+		if avg < .5:

+			return 0

+		else:

+			return 1

+

 import collections

 class Map(collections.MutableSequence):

 	def __init__(self, width, height, con, level):

@@ -258,7 +266,7 @@ class Map(collections.MutableSequence):

 	def __getitem__(self, k):

 		return self.data[k]

 	def __setitem__(self, k,v):

-		return self.data[k][v]

+		self.data[k] = v

 	def __delitem__(self, k):

 		del self.data[k]

@@ -143,7 +143,10 @@ class MonsterLoader(object):

 			(lambda doc:

 				lambda map,level,con,x,y: objects.Object( map, con, x,y,

 					doc['char'],

-					doc.get('name_fmt', '%s the %s') % (libtcod.namegen_generate(doc['namegen_class']).capitalize(), doc['race_name'].capitalize()),

+					doc.get('name_fmt', '%s the %s') % (

+						libtcod.namegen_generate(doc['namegen_class']).capitalize(),

+						doc['race_name'].capitalize()

+					),

 					color,

 					True,

 					fighter=objects.Fighter(

@@ -11,6 +11,91 @@ def get_pos_pair(x,y):

 			x,y = x.pos

 	return x,y

+import collections

+class Slot(object):

+	def __init__(self):

+		self.limit = None

+		self.items = []

+

+	@property

+	def display_name(self):

+		if self.items != []:

+			return '%s (x%s)' % (self.items[0].name, len(self.items))

+

+	@property

+	def ident(self):

+		if self.items != []:

+			return self.items[0].name

+

+

+	def empty(self):

+		return len(self.items) == 0

+

+	def _add_item(self, item):

+		self.items.append(item)

+		return True

+

+	def add_item(self, item):

+		result = False

+		if self.limit is None or len(self.items) <= self.limit:

+			if self.items == []:

+				self.limit = item.item.stack_limit

+				print 'no items'

+				return self._add_item(item)

+			elif (len(self.items) < self.limit) and (self.ident == item.name):

+				print 'add_items %d' % len(self.items)

+				return self._add_item(item)

+			elif self.ident != item.name:

+				raise ValueError('Cannot stack %s with %s' % (self.ident, item.ident))

+		return result

+

+	def get_item(self, default=None):

+		result = default

+		if self.items != []:

+			result = self.items[-1]

+		return result

+

+	def consume(self):

+		self.items.pop()

+

+

+

+class Inventory(object):

+	def __init__(self):

+		self.objects = {}

+

+	def __iter__(self):

+		for v in self.objects.itervalues():

+			for i in v:

+				yield i

+

+	def __len__(self):

+		return sum(len(x) for x in self.objects.values())

+

+	def __contains__(self, it):

+		return it.ident in self.objects

+

+	def __getitem__(self, k):

+		return self.objects[k][-1].get_item()

+

+	def __setitem__(self, k,v):

+		if v.ident != k: raise ValueError('Inventory key must equal the item\'s name')

+		self.add_item(v)

+

+	def add_item(self, item):

+		slot = self.objects.setdefault(item.name, [Slot()])

+		while not slot[-1].add_item(item):

+			print 'add slot'

+			slot.append(Slot())

+

+	def __delitem__(self, k):

+		self.objects[k][-1].consume()

+		while self.objects[k] != [] and self.objects[k][-1].empty():

+			self.objects[k].pop()

+		else:

+			if self.objects[k] == []:

+				del self.objects[k]

+

 class Player(Object):

 	def triggers_recompute(func):

 		def _inner(self, *a, **kw):

@@ -25,7 +110,7 @@ class Player(Object):

 		)

 		map.player = self

-		self.inventory = []

+		self.inventory = Inventory()

 	def draw(self, player=None):

 		if player is None:

@@ -33,38 +118,37 @@ class Player(Object):

 		return Object.draw(self, player)

 	def pick_up(self, obj):

+		# TODO: limit number of items

 		if len(self.inventory) >= 26:

 			game.message('Your inventory is full, cannot pick up %s' % obj.name, libtcod.red)

-		else:

-			self.inventory.append(

-				self.level.claim_object(obj)

+		elif obj is not None:

+			self.inventory.add_item(

+				self.level.claim_object(obj).item.bind_user(self) # returns item.owner

 			)

 			game.message('you picked up a %s!' % obj.name, libtcod.green)

-			obj.item.user = self

 		return self

 	def drop(self, obj):

-		self.level.objects.insert(0, obj)

+		obj = self.inventory[obj.name]

 		obj.x, obj.y = self.x, self.y

-		game.message('you dropped a %s' % obj.name, libtcod.yellow)

+		self.level.add_object(obj)

+		del self.inventory[obj.name]

 	def use(self, item):

 		item.owner.enter_level(self.level)

 		success = item.use()

-		try:

-			index = self.inventory.index(item.owner)

-		except ValueError:

-			index = -1

+		if success:

+			del self.inventory[item.name]

-		if success and index != -1:

-			self.inventory.pop(index)

 	def get_item(self, index):

 		return self.inventory[index].item

 	def get_item_names(self):

-		return [item.name for item in self.inventory]

+		return [item.display_name for item in self.inventory]

+	def get_items(self):

+		return [item for item in self.inventory]

 	def tick(self):

 		if self.fighter:

@@ -90,6 +90,8 @@ class MovementKeyListener(object):

 			result = self.handlers[key.vk](*a, **kw) or True

 		elif key.c in self.char_handlers:

 			result = self.char_handlers[key.c](*a, **kw) or True

+		if result is None:

+			result = 'didnt-take-turn'

 		return (key, result)

 	def handle(self, key):