@@ -109,14 +109,22 @@ 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):

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

+	def Inventory_menu(self, header, items):

+		data = [(item.display_name, item.ident) for item in items]

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

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

+		return index, data

+	def inventory_menu(self, header):

+		index, data = self.Inventory_menu(header, self.player.get_items())

 		if index is not None:

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

+	def mod_menu(self, header):

+		index, data = self.Inventory_menu(header, self.player.get_mods())

+		if index is not None:

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

+

 	def get_names_under_mouse(self):

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

 		names = ', '.join(

@@ -132,6 +140,12 @@ class GameBase:

 	def menu(self, header, options, width, back_color=libtcod.black, fore_color=libtcod.white):

+		import debug

+		print '------\n'

+		print debug._get_last_module(100)

+		print 'menu(', self, header, options, width, back_color, fore_color, ')'

+		print '------\n'

+

 		if self.con is None: self.con = 0

 		if len(options) > 26: raise ValueError('too many items')

@@ -140,6 +154,8 @@ class GameBase:

 		header_height = libtcod.console_get_height_rect(con, 0,0, width, self.SCREEN_HEIGHT, header)

 		height = len(options) + header_height

 		window = libtcod.console_new(width, height)

+		print 'window id is:', window

+		print

 		libtcod.console_set_default_foreground(window, fore_color)

 		libtcod.console_print_rect(window, 0,0, width,height, header)

@@ -152,13 +168,18 @@ class GameBase:

 		x = self.SCREEN_WIDTH/2 - width/2

 		y = self.SCREEN_HEIGHT/2 - height/2

-		libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.7)

+		libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.9)

 		key = libtcod.Key()

 		mouse = libtcod.Mouse()

 		libtcod.console_flush()

 		libtcod.sys_wait_for_event(libtcod.KEY_PRESSED, key, mouse, True)

+		libtcod.console_clear(window)

+		libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.9)

+		libtcod.console_delete(window)

+		libtcod.console_flush()

+

 		index = key.c - ord('a')

 		if index >= 0 and index < len(options): return index

 		return None

@@ -1,4 +1,5 @@

 from __future__ import division

+import collections

 import os.path

 import glob

 import yaml

@@ -14,8 +15,13 @@ from main import Game

 class Item(object):

 	stack_limit = 5

+	potency = None

+	item_class = None

+	distance = None

+	probability = 1

+

 	def __init__(self, stackable=False):

-		self.stacks_with = []

+		self.mods = collections.defaultdict(set)

 	def __new__(*args):

 		res = object.__new__(*args)

@@ -29,6 +35,24 @@ class Item(object):

 		self.user = None

 		return self.owner

+	def modify(self, mod):

+		undo = mod.modify(self)

+		self.mods[mod.name].add(mod)

+		self.owner.name = self.name

+

+	def unmodify(self, mod):

+		if hasattr(mod, 'upper'):

+			mods = self.mods[mod]

+		else:

+			mods = self.mods[mod.name]

+		if mods != set():

+			mod = mods.pop()

+			mod.revert(self)

+			self.owner.name = self.name

+			if mods == set():

+				self.mods.pop(mod.name)

+			print 'self.mods', self.mods

+

 class ItemLoader(object):

 	def __init__(self, dir):

 		self.dir = dir

@@ -40,6 +64,8 @@ class ItemLoader(object):

 				self.load_item(doc)

 	def load_item(self, doc):

+		if doc is None: return

+

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

 		if _color is None:

 			_color = libtcod.green

@@ -61,7 +87,8 @@ class ItemLoader(object):

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

 			color = _color

 			stack_limit = doc.get('stack_limit', Item.stack_limit)

-			stacks_with = doc.get('stacks_with', ())

+			potency = doc.get('potency')

+			distance = doc.get('distance')

 @Game.register_item_type(5)

@@ -69,16 +96,18 @@ class HealingPotion(Item):

 	name = 'Healing potion'

 	char = '\x03'

 	color = libtcod.violet

+	potency = 10

+	item_class = 'healing'

 	def use(self):

 		fighter = self.user.fighter

 		result = True

 		if fighter.hp == fighter.max_hp:

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

+			self.game.message('Full health, can\'t heal', libtcod.red)

 			result = False

 		else:

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

-			fighter.heal(10)

+			fighter.heal(self.potency)

 		return result

@@ -87,11 +116,14 @@ class SuperHealingPotion(Item):

 	name = 'Super healing potion'

 	char = '\x03'

 	color = libtcod.yellow

+	probability = .5

+	potency = 10

+	item_class = 'healing'

 	def use(self):

 		fighter = self.user.fighter

-		if random.random() < .75:

-			fighter.max_hp += 10

-			fighter.heal(10)

+		if random.random() < self.probability:

+			fighter.max_hp += self.potency

+		fighter.heal(self.potency)

 		return True

 @Game.register_item_type(1)

@@ -99,6 +131,7 @@ class Confusion(Item):

 	name = 'Confusion'

 	char = 'c'

 	color=libtcod.dark_chartreuse

+	item_class = 'monster defense'

 	def use(self):

 		monster = monsters.get_closest_monster(self.user)

@@ -117,10 +150,12 @@ class Strengthen(Item):

 	name = 'Strengthen'

 	char = 's'

 	color = libtcod.chartreuse

+	item_class = 'attack'

+	potency = 20

 	def use(self):

 		if self.user.fighter:

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

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

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

 		return True

 	def adj(self, owner):

@@ -135,10 +170,12 @@ class Protect(Item):

 	name = 'Protect'

 	char = 'p'

 	color = libtcod.chartreuse

+	item_class = 'defense'

+	potency = 15

 	def use(self):

 		if self.user.fighter:

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

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

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

 		return True

 	def adj(self, owner):

@@ -153,12 +190,14 @@ class LightningBolt(Item):

 	name = 'Lightning Bolt'

 	char = 'z'

 	color = libtcod.darkest_red

+	item_class = 'attack'

+	potency = 13

 	def use(self):

 		monster = monsters.get_closest_monster(self.user)

 		result = False

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

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

-			monster.fighter.take_damage(13)

+			monster.fighter.take_damage(self.potency)

 			result = True

 		else:

 			self.game.message('No target')

@@ -169,22 +208,23 @@ class Jump(Item):

 	name = 'Jump'

 	char = 'j'

 	color= libtcod.dark_green

-	jump_distance = 3

+	distance = 3

+	item_class = 'movement'

 	def use(self):

 		self.game.select(self.jump)

 		return True

 	def jump(self, x,y):

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

-		if dist <= self.jump_distance:

+		if dist <= self.distance:

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

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

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

+		elif random.random() < self.distance/dist:

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

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

 		else:

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

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

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

 @Game.register_item_type(3)

 class Acquire(Item):

@@ -192,6 +232,7 @@ class Acquire(Item):

 	char = 'a'

 	color= libtcod.dark_green

 	effect_distance = 5

+	item_class = 'pickup'

 	def use(self):

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

 		self.game.select(self.get)

@@ -206,6 +247,8 @@ class Smite(Item):

 	name = 'Smite'

 	char = '\x0f'

 	color = libtcod.red

+	item_class = 'attack'

+	potency = 10

 	def use(self):

 		self.game.select(self.smite)

 		return True

@@ -213,7 +256,7 @@ class Smite(Item):

 	def smite(self, x,y):

 		monster = monsters.monster_at(x,y)

 		if monster:

-			monster.fighter.take_damage(10)

+			monster.fighter.take_damage(self.potency)

 			if monster.fighter:

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

 			else:

@@ -226,6 +269,8 @@ class Fireball(Item):

 	char = '*'

 	color = libtcod.darker_red

 	effect_radius = 5

+	potency = (20,6)

+	item_class = 'splash attack'

 	def use(self):

 		self.game.select(self.smite)

@@ -233,16 +278,18 @@ class Fireball(Item):

 	def smite(self, x,y):

 		if random.random() < .1:

+			self.game.message('the fireball is amazingly effective', libtcod.green)

 			self.effect_radius *= 2

+		direct_damage, splash_damage = self.potency

 		strikes = []

 		for obj in self.owner.level.objects:

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

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

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

-					obj.fighter.take_damage(20)

+					obj.fighter.take_damage(direct_damage)

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

-					obj.fighter.take_damage(6)

+					obj.fighter.take_damage(splash_damage)

 					if obj.fighter:

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

 					else:

@@ -250,17 +250,34 @@ if __name__ == 'main':

 		@mvkeyhandler.handle('i')

 		def mvkeyhandler(self):

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

+			item = self.inventory_menu('Choose item to use\n')

 			if item is not None:

 				item.bind_game(self)

 				self.player.use(item)

 		@mvkeyhandler.handle('d')

 		def mvkeyhandler(self):

-			chosen_item = self.inventory_menu('Choose the item to drop:')

+			chosen_item = self.inventory_menu('Choose item to drop\n')

 			if chosen_item is not None:

 				self.player.drop(chosen_item.owner)

+		@mvkeyhandler.handle('n')

+		def mvkeyhandler(self):

+			chosen_item = self.inventory_menu('Choose item to unmod\n')

+			if chosen_item is not None:

+				data = chosen_item.mods.keys()

+				index = self.menu('Choose \nmod to \nundo\n', data, self.INVENTORY_WIDTH)

+				if index is not None:

+					self.player.unmodify(chosen_item.name, data[index])

+

+		@mvkeyhandler.handle('m')

+		def mvkeyhandler(self):

+			chosen_item = self.inventory_menu('Choose item to mod\n')

+			if chosen_item is not None:

+				chosen_mod = self.mod_menu('Choose mod to apply\n')

+				if chosen_mod is not None:

+					self.player.modify(chosen_item.name, chosen_mod.name)

+

 		@mvkeyhandler.handle('g')

 		def mvkeyhandler(self):

 			for obj in self.level.iter_objects():

new file mode 100644

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

+import math

+class Mod(object):

+	'''An undoable change to some object or item'''

+

+	def __init__(self):

+		pass

+

+	def modify(self, target):

+		pass

+

+	def revert(self, target):

+		pass

+

+class Boost(Mod):

+	name = 'boost'

+

+	def modify(self, target):

+		target.potency *= 1.5

+		result = math.ceil(target.potency)

+		target.potency = int(result)

+		target.name = 'boosted %s' % target.name

+	def revert(self, target):

+		target.potency /= 1.5

+		result = math.ceil(target.potency)

+		target.potency = int(result)

+		target.name = target.name.split(' ', 1)[1]

+

@@ -1,5 +1,7 @@

+import contextlib

 import libtcodpy as libtcod

 from objects import Object, Fighter

+import mods

 def get_pos_pair(x,y):

 	if y is None:

@@ -83,6 +85,7 @@ class Inventory(object):

 		self.add_item(v)

 	def add_item(self, item):

+		print 'add_item', item.name

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

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

 			print 'add slot'

@@ -111,6 +114,13 @@ class Player(Object):

 		map.player = self

 		self.inventory = Inventory()

+		self.mods = Inventory()

+

+		class Item:

+			stack_limit = 5

+		obj = Object(None, con, None,None, 'b', 'boost', color, item=Item())

+		obj.mod = mods.Boost()

+		self.mods.add_item(obj)

 	def draw(self, player=None):

 		if player is None:

@@ -141,10 +151,34 @@ class Player(Object):

 		if success:

 			del self.inventory[item.name]

+	@contextlib.contextmanager

+	def recategorize_item(self, item_name):

+		item = self.inventory[item_name]

+		yield item

+		del self.inventory[item_name]

+		self.inventory.add_item(item)

+

+	def modify(self, item_name, mod_name):

+		mod = self.mods[mod_name]

+		with self.recategorize_item(item_name) as item:

+			item.item.modify(mod.mod)

+			del self.mods[mod_name]

+		print list(self.mods)

+

+	def unmodify(self, item_name, mod_name):

+		with self.recategorize_item(item_name) as item:

+			item.item.unmodify(mod_name)

+		print list(self.mods)

+

+	def get_mod(self, index):

+		return self.mods[index].mod

+	def get_mod_names(self):

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

+	def get_mods(self):

+		return [item for item in self.mods]

 	def get_item(self, index):

 		return self.inventory[index].item

-

 	def get_item_names(self):

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

 	def get_items(self):