@@ -1,6 +1,20 @@

+<<<<<<< HEAD

 Here it is...

 Requirements:

  Python 2.7

  libtcod 1.5.0 (relies on SDL and zlib)

  pyYAML 3.10 

+=======

+Homepage: http://fiddlerwoaroof.github.com/yinjar/

+

+If you want to modify the code, the files contained under data/ might be a good place to start

+

+### Prereqs:

+

+- Python (included on OS X and usually on Linux, install from http://python.org for Windows)

+- PyYAML

+- libTCOD (included but if on 64-bit linux download from here: doryen.eptalys.net/libtcod/download/)

+- SDL (included with libTCOD)

+

+>>>>>>> remotes/fiddlerwoaroof/master

new file mode 100644

@@ -0,0 +1 @@

+---

new file mode 100644

@@ -0,0 +1,3 @@

+---

+#screen_width: 155 # widescreen (1280x800)

+#screen_height: 90

@@ -21,51 +21,22 @@ class Cursor(object):

 		libtcod.console_put_char(self.con, self.x,self.y, ' ', libtcod.BKGND_NONE)

 class GameBase:

-	#actual size of the window

-	SCREEN_WIDTH, SCREEN_HEIGHT = 50,70

-

-	MAP_WIDTH, MAP_HEIGHT = SCREEN_WIDTH, SCREEN_HEIGHT - 17

-

-	INVENTORY_WIDTH = 50

-	BAR_WIDTH = 25

-

-	PANEL_HEIGHT = SCREEN_HEIGHT - MAP_HEIGHT - 2

-	PANEL_Y = SCREEN_HEIGHT - PANEL_HEIGHT

-

-	MSG_X = BAR_WIDTH + 2

-	MSG_WIDTH, MSG_HEIGHT = SCREEN_WIDTH - BAR_WIDTH - 2, PANEL_HEIGHT - 1

-

-	ROOM_MIN_SIZE, ROOM_MAX_SIZE = 7, 19

-

-	MAX_ROOMS = 51

-

-	MAX_ROOM_MONSTERS, MAX_ROOM_ITEMS = 9, 6

-

-	CONFUSE_NUM_TURNS = 17

-

-	LIMIT_FPS = 20	#20 frames-per-second maximum

-

-	color_dark_wall = libtcod.Color(60, 60, 60)

-	color_light_wall = libtcod.Color(127,127,127)

-	color_dark_ground = libtcod.Color(150,150,150)

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

-

-

 	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)

+		if color is None:

+			color = libtcod.white

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

+	def __init__(self, app_name='test app', screen_width=None, screen_height=None):

 		print '__init__'

+		if screen_width is None:

+			screen_width, screen_height = self.SCREEN_WIDTH, self.SCREEN_HEIGHT

 		libtcod.console_init_root(

 			screen_width, screen_height, app_name, False

 		)

 		self.game_msgs = []

 		global message

-		message = functools.partial(utilities.message, self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH)

+		message = self.message

 		self.game_state = 'playing'

 		self.player_action = 'didnt-take-turn'

@@ -136,30 +107,24 @@ class GameBase:

 		libtcod.console_set_default_background(self.panel, libtcod.black)

 		libtcod.console_clear(self.panel)

-		#utilities.render_bar(self.panel, 1,1, self.BAR_WIDTH, 'HP',

-		#	self.player.fighter.hp,

-		#	self.player.fighter.max_hp,

-		#	libtcod.red,

-		#	libtcod.darker_red

-		#)

-

-		#y = 1

-		#for line, color in self.game_msgs:

-		#	libtcod.console_set_default_foreground(self.panel, color)

-		#	libtcod.console_print_ex(self.panel, self.MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line)

-		#	y += 1

-

-

 		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(self.con, header, display, self.INVENTORY_WIDTH)

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

@@ -174,16 +139,25 @@ class GameBase:

-	def menu(self, con, header, options, width):

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

+		con = self.con

-		print con

 		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, libtcod.white)

+		libtcod.console_set_default_foreground(window, fore_color)

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

 		y = header_height

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

@@ -13,10 +14,14 @@ 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.stackable = stackable

-		self.stacks_with = []

-		self.stack_limit = 5

+		self.mods = collections.defaultdict(set)

 	def __new__(*args):

 		res = object.__new__(*args)

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

@@ -41,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,6 +86,9 @@ class ItemLoader(object):

 			name = doc.get('item_description')

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

 			color = _color

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

+			potency = doc.get('potency')

+			distance = doc.get('distance')

 @Game.register_item_type(5)

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

@@ -86,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)

@@ -98,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)

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

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

@@ -152,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')

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

@@ -191,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)

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

@@ -212,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:

@@ -224,7 +268,9 @@ class Fireball(Item):

 	name = 'Fireball'

 	char = '*'

 	color = libtcod.darker_red

-	effect_radius = 3

+	effect_radius = 5

+	potency = (20,6)

+	item_class = 'splash attack'

 	def use(self):

 		self.game.select(self.smite)

@@ -232,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:

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

@@ -1,43 +1,96 @@

 import os.path

+import yaml

 import textwrap

 import math

 import libtcodpy as libtcod

 import glob

 libtcod.console_set_keyboard_repeat(500, 50)

-for file in glob.glob('./data/namegen/*.cfg'):

-	libtcod.namegen_parse(file)

+for fil in glob.glob('./data/namegen/*.cfg'):

+	libtcod.namegen_parse(fil)

+

+help = '''

+ 'i': Inventory

+ 'd': Drop

+ 'g': Get item (Pick up)

+ '?': Help

+ Alt+Escape: Exit

+

+ Arrow Keys for movement / selecting

+ Name of item under the mouse shown

+ above the health bar

+'''

 from game import GameBase

 import levels

 import objects

 import utilities

 if __name__ == 'main':

+	class Null: pass

+	class SettingsObject(object):

+		def __init__(self, setting_name, default=Null):

+			self.setting_name = setting_name

+			self.default = default

+

+		def __get__(self, instance, owner):

+			result = instance.settings.get(self.setting_name, self.default)

+			if result is Null:

+				raise KeyError('%s is not specified in the configuration' % self.setting_name)

+			return result

+

 	class Game(GameBase):

 		#actual size of the window

-		SCREEN_WIDTH, SCREEN_HEIGHT = 155, 90

+		def load_settings(self):

+			self.settings = yaml.safe_load(

+				file(os.path.join('./data/main.yml'))

+			)

+			if self.settings == None:

+				self.settings = {}

+			print self.settings

-		MAP_WIDTH, MAP_HEIGHT = SCREEN_WIDTH, SCREEN_HEIGHT - 17

+		SCREEN_WIDTH = SettingsObject('screen_width', 80)

+		SCREEN_HEIGHT = SettingsObject('screen_height', 50)

+

+		PANEL_HEIGHT = 15

 		INVENTORY_WIDTH = 50

-		BAR_WIDTH = 25

-		PANEL_HEIGHT = SCREEN_HEIGHT - MAP_HEIGHT - 2

-		PANEL_Y = SCREEN_HEIGHT - PANEL_HEIGHT

+		@property

+		def MAP_WIDTH(self):

+			return self.SCREEN_WIDTH

+		@property

+		def MAP_HEIGHT(self):

+			return self.SCREEN_HEIGHT - (self.PANEL_HEIGHT + 2)

+

+		BAR_WIDTH = 25

 		MSG_X = BAR_WIDTH + 2

-		MSG_WIDTH, MSG_HEIGHT = SCREEN_WIDTH - BAR_WIDTH - 2, PANEL_HEIGHT - 1

+		MSG_HEIGHT = PANEL_HEIGHT

+

+		@property

+		def PANEL_Y(self):

+			return self.SCREEN_HEIGHT - self.PANEL_HEIGHT

+

+		@property

+		def MSG_WIDTH(self):

+			return self.SCREEN_WIDTH - self.MSG_X

-		ROOM_MIN_SIZE, ROOM_MAX_SIZE = 7, 19

+		@property

+		def MSG_HEIGHT(self):

+			return self.PANEL_HEIGHT - 1

-		MAX_ROOMS = 51

+		ROOM_MIN_SIZE = SettingsObject('room_min_wall_length', 4)

+		ROOM_MAX_SIZE = SettingsObject('room_max_wall_length', 7)

-		MAX_ROOM_MONSTERS, MAX_ROOM_ITEMS = 9, 6

+		MAX_ROOMS = SettingsObject('max_number_rooms', 10)

+		MAX_ROOM_MONSTERS = SettingsObject('max_number_room_monsters', 6)

+		MAX_ROOM_ITEMS = SettingsObject('max_number_room_items', 3)

 		CONFUSE_NUM_TURNS = 17

 		LIMIT_FPS = 20	#20 frames-per-second maximum

 		def __init__(self):

+			self.load_settings()

 			GameBase.__init__(self, 'caer flinding', self.SCREEN_WIDTH, self.SCREEN_HEIGHT)

 			self.select_cb = None

@@ -197,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():

@@ -222,6 +292,10 @@ if __name__ == 'main':

 		def mvkeyhandler(self):

 			self.change_level(down=True)

+		@mvkeyhandler.handle('?')

+		def mvkeyhandler(self):

+			self.menu(help, [], 50)

+

 		selectkeyhandler = utilities.MovementKeyListener()

 		@selectkeyhandler.up

 		def selectkeyhandler(self):

@@ -284,6 +358,19 @@ if __name__ == 'main':

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

+		def main_menu(self):

+			message = (

+				'Welcome to YinJAR: is not Just Another Roguelike (WIP)',

+				'',

+				'Choose an option:',

+				'',

+			)

+

+			options = ['Play', 'Exit']

+			return options[

+				self.menu('\n'.join(message), options, len(message[0]))

+			]

+

 	game_instance = Game()

 	from monsters import MonsterLoader

@@ -306,6 +393,9 @@ if __name__ == '__main__':

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

 	il.load_items()

-	game_instance.setup_map()

-	game_instance.main()

+	game_instance.load_settings()

+	action = game_instance.main_menu()

+	if action.lower() == 'play':

+		game_instance.setup_map()

+		game_instance.main()

@@ -151,6 +151,7 @@ class MazeGen(AutomataEngine):

 			cx, cy = point

 			lx, ty = cx-left_offset, cy-up_offset

+

 			if lx < 0:

 				max_width += lx

 				lx = 0

@@ -160,10 +161,11 @@ class MazeGen(AutomataEngine):

 			w, h = random.randrange(1,max_width+1), random.randrange(1, max_height+1)

 			if lx + w >= self.width:

-				lx -= (lx+w) - self.width

+				w -= (lx+w) - self.width

 			if ty + h >= self.height:

-				ty -= (ty+h) - self.height

+				h -= (ty+h) - self.height

+			print '(',lx,ty, ')', w, h

 			room = Rect(lx,ty, w,h)

 			success = True

 			for o_room in self.rooms:

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]

+

@@ -4,6 +4,7 @@ import libtcodpy as libtcod

 import maps

 class Object(object):

+	# FIXME: map argument unused, remove

 	def __init__(self, map, con, x,y, char, name, color, blocks=False, level=None, fighter=None, ai=None, item=None):

 		self.name = name

 		self.x, self.y = x,y

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

new file mode 100644

@@ -0,0 +1,26 @@

+

+class Weapon(object):

+	def __init__(self, power_boost=0, chance_to_hit=100):

+		self.power_boost = power_boost

+		self.chance_to_hit = chance_to_hit

+

+		self.ammo = []

+		self.mods = []

+		self.user = None

+

+	def modify(self, mod):

+		if mod.modify(self):

+			self.mods.append(mod)

+	def remove_mod(self, mod):

+		if mod.undo(self):

+			self.mods.remove(mod)

+

+	def load(self, ammo):

+		self.ammo.append(ammo)

+

+	def equip(self, user):

+		self.user = user

+

+	def attack(self, target):

+		pass

+