Ejemplo n.º 1
0
    def setUp(self):

        self.i1 = Item()
        self.i2 = Item(name='axe', weight=1000)

        self.c1 = Container()
        self.c2 = Container(name='backpack', weight=2000)
Ejemplo n.º 2
0
 def throw(self):
     """Throwing item from eq"""
     thrown = self.equipment.remove_item("active")
     if thrown:
         thrown.position = vector(self.position.x + 80 * self.facing + 15, self.position.y - 50)
         Item.scale_item(thrown, BLOCK_SIZE // 1.6)
         self.game.items.add(thrown)
Ejemplo n.º 3
0
def build_item(name, item_data, actor=None, is_player=False): 
    # Build a new item and return finished item
    item = Item(name, item_data[name]['image'], item_data[name]['color_fg'],
                1, item_data[name]['stackable'], item_data[name]['targeting'],
                item_data[name]['range'])
    item.action = build_action(name, item, item_data, actor, is_player)

    return item
Ejemplo n.º 4
0
class TestItem(unittest.TestCase):
    def setUp(self):
        self.item = Item('Generic Item', 1.99)

    def test_is_item(self):
        self.assertIsInstance(self.item, Item)

    def test_has_name(self):
        self.assertEqual(self.item.name, 'Generic Item')

    def test_has_price(self):
        self.assertEqual(self.item.price, 1.99)

    def test_set_price(self):
        self.item.price = 1.50
        self.assertEqual(self.item.price, 1.50)

    def test_set_name(self):
        self.item.name = "Common Item"
        self.assertEqual(self.item.name, "Common Item")

    def test_can_sell(self):
        self.item.quantity = 6
        self.assertEqual(self.item.quantity, 6)

        sold = self.item.sell(5)
        self.assertTrue(sold)
        self.assertEqual(self.item.quantity, 1)

    def test_can_sell_to_zero(self):
        self.item.quantity = 6
        sold = self.item.sell(6)
        self.assertTrue(sold)
        self.assertEqual(self.item.quantity, 0)

    def test_no_sell_past_zero(self):
        self.item.quantity = 6
        sold = self.item.sell(7)
        self.assertFalse(sold)

        # quantity should be unaffected if the sale doesn't go through.
        self.assertEqual(self.item.quantity, 6)

    def test_no_sell_after_zero(self):
        self.item.quantity = 6
        first_sale = self.item.sell(6)
        self.assertTrue(first_sale)

        # quantity should go to zero.
        self.assertEqual(self.item.quantity, 0)

        # no more sales should be made.
        second_sale = self.item.sell(1)
        self.assertFalse(second_sale)

        # quantity should stay at zero.
        self.assertEqual(self.item.quantity, 0)
Ejemplo n.º 5
0
    def setUp(self):
        from items.item import Item
        from items.item_set import ItemSet

        sword = Item("sword", "made by elves", 2)
        helmet = Item("helmet", "made by men", 1)
        potion = Item("potion", "restores health", 1)

        self._itemList = [sword, helmet, potion]
        self._items = ItemSet([sword, helmet, potion])
    def test_inventory_add(self):
        inventory = Inventory()
        cool_item_1 = Item(uid="cool_item_1", name="Very Cool Item")
        cool_item_2 = Item(uid="cool_item_2", name="Very Cool Item Too")
        inventory.add_item(cool_item_1)
        inventory.add_item(cool_item_2)

        self.assertEqual(
            inventory.get_items("cool_item_1", pop=True)[0], cool_item_1)
        self.assertGreater(len(inventory.get_items("cool_item_1")), 0)
        self.assertEqual(inventory.get_items("cool_item_2")[0], cool_item_2)
Ejemplo n.º 7
0
    def testItems(self):
        from space import Space
        from items.item import Item

        #Prepare items
        blade = Item("blade", "appears to be dull", 1)
        bow = Item("bow", "long bow", 2)

        #Create space
        space = Space("shire", "Home of the Hobbits.")
        items = space.getItemSet()

        #Assert space initially empty
        errorMsg = "New space contains items; should be empty"
        self.assertEqual(items.count(), 0, errorMsg)

        errorMsg = "Space claims to contain item even though it is empty."
        self.assertFalse(space.containsItem(blade), errorMsg)
        self.assertFalse(space.containsItem(bow), errorMsg)

        #Add blade
        space.addItem(blade)
        errorMsg = "Space failed to report that it contained item known to exist."
        self.assertTrue(space.containsItem(blade), errorMsg)

        #Add bow
        space.addItem(bow)
        self.assertTrue(space.containsItem(bow), errorMsg)

        #Get room's items. Assert blade and bow exist
        items = space.getItemSet()
        self.assertEqual(items.count(), 2,
                         "Room should contain exactly two items.")
        self.assertTrue(items.containsItem(blade),
                        "Could not find blade in room's set of items.")
        self.assertTrue(items.containsItem(bow),
                        "Could not find bow in room's set of items.")

        #Remove blade
        space.removeItem(blade)
        errorMsg = "Space claims to have item that was removed."
        self.assertFalse(space.containsItem(blade), errorMsg)
        errorMsg = "Space missing item that should still exist."
        self.assertTrue(space.containsItem(bow), errorMsg)

        #Get room's items. Assert only bow exists
        items = space.getItemSet()
        self.assertEqual(items.count(), 1,
                         "Room should contain exactly one item.")
        self.assertFalse(items.containsItem(blade),
                         "Blade found in room (even though it was removed).")
        self.assertTrue(items.containsItem(bow),
                        "Could not find bow in room's set of items.")
Ejemplo n.º 8
0
    def __init__(self, name, description, weight, defense, cost):
        """
        Initializes armor class.

        @param name:         The name of the item.
        @param description:  Armor description.
        @param weight:       Armor weight.
        @param defense:      The defense stat of the piece of armor. Reduces the amount
                             of damage that player receives by this amount. 
        """
        Item.__init__(self, name, description, weight)
        self._defense = defense
        self._cost = cost
Ejemplo n.º 9
0
    def __init__(self, name, description, weight, healing, cost):
        """
        Initializes potions class.

        @param name:          Name of portion.
        @param description:   Description of potion.
        @param weight:        Weight of weapon.
        @param healing:       Healing stat of weapon. Player heals by the maximum
                              of this amount when player uses potion.
        """
        Item.__init__(self, name, description, weight)
        self._healing = healing
        self._cost = cost
Ejemplo n.º 10
0
    def __init__(self, name, description, weight, cost, defense):
        """
        Initializes armor class.

        @param name:         The name of the piece of armor.
        @param description:  Armor description.
        @param weight:       Armor weight.
        @param cost:         The cost of the armor.
        @param defense:      The defense stat of the piece of armor. 
        """
        Item.__init__(self, name, description, weight, cost)

        self._defense = defense
Ejemplo n.º 11
0
    def __init__(self, name, description, weight, defense, cost):
        """
        Initializes armor class.

        @param name:         The name of the item.
        @param description:  Armor description.
        @param weight:       Armor weight.
        @param defense:      The defense stat of the piece of armor. Reduces the amount
                             of damage that player receives by this amount. 
        """
        Item.__init__(self, name, description, weight)
        self._defense = defense
        self._cost = cost
Ejemplo n.º 12
0
    def __init__(self, name, description, weight, attack, cost):
        """
        Initializes weapon class.

        @param name:          Name of weapon.
        @param description:   Description of weapon.
        @param weight:        Weight of weapon.
        @param attack:        Attack stat of weapon. Player damage increases by this
                              amount when weapon is equipped.
        """
        Item.__init__(self, name, description, weight)
        self._attack = attack
        self._cost = cost
Ejemplo n.º 13
0
    def update(self, game: List[List[int]]) -> None:
        """Loop through the game list and mirror it to a list of objects such that
        the objects represent visually what is going on in the game.

        Both lists are iterated on in parallel, if the object list contains an
        item where the new game list is empty remove that item. If they are
        different change it to the new one.
        """

        wall_color = (0, 0, 255)
        player_color = (0, 255, 0)
        food_color = (255, 0, 0)

        temp_list = []

        for row in range(len(game)):
            temp_col = []

            # Create a object based on the item in the list
            for col in range(len(game[row])):
                current = game[row][col]

                # Check which item is in the spot
                if current == 0:
                    temp_col.append(None)

                # add player object
                elif current == 1:
                    item = Item((row * self.SCALE, col * self.SCALE),
                                player_color)
                    temp_col.append(item)

                # add food object
                elif current == 2:
                    item = Item((row * self.SCALE, col * self.SCALE),
                                food_color)
                    temp_col.append(item)

                # add wall object
                elif current == 3:  # add green item
                    item = Item((row * self.SCALE, col * self.SCALE),
                                wall_color)
                    temp_col.append(item)

                else:
                    temp_col.append(None)

            temp_list.append(temp_col)

        self.objects = temp_list
Ejemplo n.º 14
0
    def __init__(self, name, description, weight, cost, healing):
        """
        Initializes potions class.

        @param name:          Name of portion.
        @param description:   Description of potion.
        @param weight:        Weight of weapon.
        @param cost:          The cost of the potion.
        @param healing:       Healing stat of potion. Player may heal at most 
                              this amount upon use.
        """
        Item.__init__(self, name, description, weight, cost)
        
        self._healing = healing
Ejemplo n.º 15
0
    def testItem(self):
        from items.item import Item
        name = "Generic item"
        description = "Generic description"
        weight = 9

        item = Item(name, description, weight)

        errorMsg = "Expected item name to be '%s'." % name
        self.assertEqual(item.getName(), name, errorMsg)
        errorMsg = "Expected item description to be '%s'." % description
        self.assertEqual(item.getDescription(), description, errorMsg)
        errorMsg = "Expected item weight to be '%s'." % weight
        self.assertEqual(item.getWeight(), weight, errorMsg)
Ejemplo n.º 16
0
    def testItem(self):
        from items.item import Item
        name = "Generic item"
        description = "Generic description"
        weight = 9

        item = Item(name, description, weight)

        errorMsg = "Expected item name to be '%s'." % name
        self.assertEqual(item.getName(), name, errorMsg)
        errorMsg = "Expected item description to be '%s'." % description 
        self.assertEqual(item.getDescription(), description, errorMsg)
        errorMsg = "Expected item weight to be '%s'." % weight 
        self.assertEqual(item.getWeight(), weight, errorMsg)
Ejemplo n.º 17
0
    def load(self):
        with open("savefile", "rb") as f:
            loaddata = pickle.load(f)
        self.all_sprites = pg.sprite.LayeredUpdates()
        self.walls = pg.sprite.Group()
        self.mobs = pg.sprite.Group()
        self.mobslist = []
        self.ghostlist = []
        self.bullets = pg.sprite.Group()
        self.items = pg.sprite.Group()
        self.itemslist = []
        self.map = TiledMap(path.join(map_folder, 'Fase1.tmx'))
        self.map_img = self.map.make_map()
        self.map.rect = self.map_img.get_rect()

        self.player = Player(self, loaddata[0][2][0], loaddata[0][2][1])
        self.player.health = loaddata[0][0]
        self.player.weapon = loaddata[0][1]
        for zombie in loaddata[1]:
            M = Mob(self, zombie[0], zombie[1])
            self.mobslist.append(M)
        for ghost in loaddata[3]:
            G = Ghost(self, ghost[0], ghost[1])
            self.ghostlist.append(G)
        for item in loaddata[2]:
            I = Item(self, item[0], item[1])
            self.itemslist.append(I)
        for tile_object in self.map.tmxdata.objects:
            if tile_object.name == 'wall':
                Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
                         tile_object.height)

        self.camera = Camera(self.map.width, self.map.height)
        self.draw_debug = False
        self.paused = False
    def test_inventory_keybound(self):
        inventory = KeyBoundInventory()
        cool_item_1 = Item(uid="cool_item_1", name="Very Cool Item")
        cool_item_2 = Item(uid="cool_item_2", name="Very Cool Item Too")
        cool_item_1_symbol = inventory.add_item(cool_item_1)
        cool_item_2_symbol = inventory.add_item(cool_item_2)

        self.assertEqual(inventory.pop_item_from_symbol(cool_item_1_symbol),
                         cool_item_1)
        self.assertEqual(inventory.pop_item_from_symbol(cool_item_2_symbol),
                         cool_item_2)

        symbols = []
        for kek in range(0, 1000):
            symbols.append(inventory.add_item(cool_item_1))
        print(symbols)
Ejemplo n.º 19
0
    def __init__(self, name, description, weight, cost, attack, defense, hp):
        """
        Initializes charm class.

        @param name:         The name of the item.
        @param description:  Charm description.
        @param weight:       Charm weight.
        @param attack:       Attack bonus given by charm.    
        @param defense:      The defense stat of the charm. Reduces the amount
                             of damage that player receives by this amount.
        @param hp:           The hp bonus of the charm. 
        """
        Item.__init__(self, name, description, weight, cost)
        
        self._attack = attack
        self._defense = defense
        self._hp = hp
Ejemplo n.º 20
0
def convert_to_object(entity):
    item_id = entity.key.id_or_name

    return Item(item_id, entity['title'], entity['daily_price'],
                entity['weekly_price'], entity['monthly_price'],
                entity['description'], entity['retail_price'], entity['kind'],
                entity['rented'], entity['rentee'], entity['renter'],
                entity['past_rented'], entity['category'], entity['location'],
                entity['blob_url'])
Ejemplo n.º 21
0
    def spawn_energy_orbs(self, quantity: int):
        image_file = "misc/energy_orb.png"

        for _ in range(quantity):
            chosen = choice(list(self.floors))
            position = (chosen.rect.left, chosen.rect.top)

            self.energy_orbs.add(
                Item(self.surface, position, (20, 20), image_file, 0))
Ejemplo n.º 22
0
    def spawn_hearts(self, quantity: int):
        image_file = "misc/heart.png"

        for _ in range(quantity):
            chosen = choice(list(self.floors))
            position = (chosen.rect.left, chosen.rect.top)

            self.hearts.add(
                Item(self.surface, position, (30, 30), image_file, 0))
Ejemplo n.º 23
0
def build_leather_hood():
    _item = Item(
        uid="hood",
        name="hood",
        description="A leather hood.",
        display=Display(Colors.DARK_GRAY, Colors.BLACK_COLOR, "!"),
    )
    _item.register_component(data.python_templates.material.Leather.copy())
    _item.register_component(Stats(health=10, size=Size.Medium, weight=2))
    _item.register_component(
        Armor(base_armor_class=2,
              armor_category=item_enums.ArmorCategory.Medium,
              wearable_body_parts_uid=["humanoid_head"],
              worn_layer=item_enums.WornLayer.Outer))

    return _item
Ejemplo n.º 24
0
def build_long_sword():
    _long_sword = Item(
        uid="long_sword",
        name="Longsword",
        description="A longsword.",
        display=Display(Colors.DARK_GRAY, Colors.BLACK_COLOR, "!"),
    )
    _long_sword.register_component(data.python_templates.material.Iron.copy())
    _long_sword.register_component(Stats(health=1, size=Size.Medium))
    _long_sword.register_component(
        Weapon(weapon_category=item_enums.WeaponCategory.Martial,
               weapon_type=item_enums.WeaponType.Melee,
               size=Size.Medium,
               melee_damage_type=DamageType.Slash,
               damage_dice=DiceStack(1, Dice(8))))

    return _long_sword
Ejemplo n.º 25
0
def build_boot():
    _boot = Item(
        uid="boot",
        name="Boot",
        description="An iron boot",
        display=Display(Colors.DARK_GRAY, Colors.BLACK_COLOR, "!"),
    )
    _boot.register_component(data.python_templates.material.Iron.copy())
    _boot.register_component(Stats(health=10, size=Size.Medium, weight=0.5))
    _boot.register_component(
        Armor(base_armor_class=0.5,
              armor_category=item_enums.ArmorCategory.Medium,
              wearable_body_parts_uid=["humanoid_foot"],
              worn_layer=item_enums.WornLayer.Outer,
              maximum_dexterity_bonus=2))

    return _boot
Ejemplo n.º 26
0
    def create_player(self, name, address=None):
        players = self.players
        for plr in players:
            if plr.name == name:
                return None

        room1 = self.rooms[0]

        name = str(name)
        id_player = len(players) + 1
        new_player = Player(id_player, name, address=address)
        new_player.inventory.append(Item('Map', command='map'))

        self.add_to_room(new_player, room1)
        players.append(new_player)
        return id_player
Ejemplo n.º 27
0
def build_leather_pants():
    # TODO Some items need to take two slots rather than one.
    item = Item(
        uid="pants",
        name="pants",
        description="Leather pants",
        display=Display(Colors.DARK_GRAY, Colors.BLACK_COLOR, "!"),
    )
    item.register_component(data.python_templates.material.Leather.copy())
    item.register_component(Stats(health=10, size=Size.Medium, weight=0.5))
    item.register_component(
        Armor(base_armor_class=1,
              armor_category=item_enums.ArmorCategory.Medium,
              wearable_body_parts_uid=["humanoid_leg"],
              worn_layer=item_enums.WornLayer.Outer,
              maximum_dexterity_bonus=2))

    return item
Ejemplo n.º 28
0
    def testAddRemoveContainsItems(self):
        from items.item import Item
        antidote = Item("antidote", "cures poison", 1)

        #Verify item not included in collection
        errorMsg = "ItemSet.containsItem() claimed to contain item not present."
        self.assertFalse(self._items.containsItem(antidote), errorMsg)

        #Add item
        self._items.addItem(antidote)

        errorMsg = "ItemSet.containsItem() failed to identify existing item."
        self.assertTrue(self._items.containsItem(antidote), errorMsg)

        #Remove item
        self._items.removeItem(antidote)

        errorMsg = "ItemSet.containsItem() claimed to contain item not present."
        self.assertFalse(self._items.containsItem(antidote), errorMsg)
Ejemplo n.º 29
0
    def testExecute(self):
        from player import Player
        from space import Space
        from items.item import Item
        from items.weapon import Weapon
        from commands.unequip_command import UnequipCommand

        #Attempting to unequip item not currently equipped
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        unequipCmd = UnequipCommand("unequip",
                                    "Unequips currently equipped item", player)

        item = Item("Charm", "Unknown effects", 1)
        weapon = Weapon("Dagger", "A trusty blade", 2, 2)

        rawInputMock = MagicMock(return_value="Dagger")
        with patch('commands.unequip_command.raw_input',
                   create=True,
                   new=rawInputMock):
            unequipCmd.execute()

        ###TODO: FIND SOME WAY TO MAKE SURE THAT PRINT STATEMENT PRINTED

        #Attempting to unequip item that may be unequipped
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        unequipCmd = UnequipCommand("unequip",
                                    "Unequips currently equipped item", player)

        weapon = Weapon("Dagger", "A trusty blade", 2, 2)

        player.equip(weapon)

        rawInputMock = MagicMock(return_value="Dagger")
        with patch('commands.unequip_command.raw_input',
                   create=True,
                   new=rawInputMock):
            unequipCmd.execute()

        equipped = player.getInventory()
        self.assertFalse(equipped.containsItem(weapon),
                         "Failed to unequip item that it should have.")
Ejemplo n.º 30
0
    def testExecute(self):
        from space import Space
        from player import Player
        from items.item import Item
        from commands.pick_up_command import PickUpCommand

        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        item = Item("Dagger", "A trusty blade", 2)
        pickUpCmd = PickUpCommand("pick up", "Picks up an object", player)

        space.addItem(item)

        #Assert item in space but not in inventory and not in equipment
        self.assertTrue(space.containsItem(item),
                        "Space should have item but does not.")

        inventory = player.getInventory()
        self.assertFalse(inventory.containsItem(item),
                         "Player should not have item but does in inventory.")

        equipped = player.getEquipped()
        self.assertFalse(equipped.containsItem(item),
                         "Player should not have item but does in equipment.")

        #Assert item in player inventory but not in space and not in equipment
        rawInputMock = MagicMock(return_value="Dagger")

        with patch('commands.pick_up_command.raw_input',
                   create=True,
                   new=rawInputMock):
            pickUpCmd.execute()

        self.assertFalse(space.containsItem(item),
                         "Space should not have item but does.")

        equipped = player.getEquipped()
        self.assertFalse(equipped.containsItem(item),
                         "Player should not have item in equipment.")

        inventory = player.getInventory()
        self.assertTrue(inventory.containsItem(item),
                        "Player should have item but does not.")
Ejemplo n.º 31
0
    def new(self):
        # Criando grupos de sprites

        self.all_sprites = pg.sprite.Group()
        self.walls = pg.sprite.Group()
        self.mobs = pg.sprite.Group()
        self.mobslist = []
        self.ghostlist = []
        self.bullets = pg.sprite.Group()
        self.items = pg.sprite.Group()
        self.itemslist = []

        # Usando a biblioteca Pytween para criar um mapa em tiles, usando o editor de mapas
        self.map = TiledMap(
            path.join(path.join(path.dirname(__file__), 'maps'), 'fase1.tmx'))
        self.map_img = self.map.make_map()
        self.map.rect = self.map_img.get_rect()

        # loop que lê os objetos posicionados no editor de mapas e cria eles
        for tile_object in self.map.tmxdata.objects:
            obj_center = vec(tile_object.x + tile_object.width / 2,
                             tile_object.y + tile_object.height / 2)

            if tile_object.name == 'player':
                self.player = Player(self, obj_center.x, obj_center.y)
            if tile_object.name == 'zombie':
                M = Mob(self, obj_center.x, obj_center.y)
                self.mobslist.append(M)
            if tile_object.name == 'ghost':
                G = Ghost(self, obj_center.x, obj_center.y)
                self.ghostlist.append(G)
            if tile_object.name == 'wall':
                Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
                         tile_object.height)
            if tile_object.name in ['health', 'shotgun', 'staff']:
                I = Item(self, obj_center, tile_object.name)
                self.itemslist.append(I)

        self.camera = Camera(self.map.width, self.map.height)
        self.paused = False
Ejemplo n.º 32
0
    def testEquipUnequip(self):
        from player import Player
        from space import Space
        from items.item import Item
        from items.weapon import Weapon
        from items.armor import Armor

        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)

        newItem = Item("Chainik Reakettle", "Makes good tea", 1)
        newWeapon = Weapon("Gun of Hurlocker", "Oppressive, but friendly", 2,
                           3)
        newArmor = Armor("Cookies of Miles", "Defends against sadness", 2, 4)

        player.addToInventory(newItem)
        player.addToInventory(newWeapon)
        player.addToInventory(newArmor)

        #Attempt to equip new items
        player.equip(newItem)
        self.assertFalse(newItem in player.getEquipped(),
                         "Equipped %s and should not have." % newItem)
        player.equip(newWeapon)
        self.assertTrue(newWeapon in player.getEquipped(),
                        "Failed to equip %s" % newWeapon)
        player.equip(newArmor)
        self.assertTrue(newArmor in player.getEquipped(),
                        "Failed to equip %s" % newArmor)

        #Attempt to unequip items
        player.unequip(newWeapon)
        self.assertFalse(newWeapon in player.getEquipped(),
                         "Failed to unequip %s" % newWeapon)
        player.unequip(newArmor)
        self.assertFalse(newArmor in player.getEquipped(),
                         "Failed to unequip %s" % newArmor)
Ejemplo n.º 33
0
    def testItemsWeight(self):
        from items.item import Item

        errorMsg = "Initial weight of ItemSet object incorrect."
        expectedWeight = ItemSetTest.INITIAL_WEIGHT
        actualWeight = self._items.weight()
        self.assertEqual(expectedWeight, actualWeight, errorMsg)

        heavyRock = Item("heavy rock", "weighs a ton", 2000)

        #Add item
        self._items.addItem(heavyRock)

        errorMsg = "ItemSet.weight() reported incorrect weight."
        expectedWeight += 2000
        actualWeight = self._items.weight()
        self.assertEqual(expectedWeight, actualWeight, errorMsg)

        #Remove item
        self._items.removeItem(heavyRock)

        expectedWeight -= 2000
        actualWeight = self._items.weight()
        self.assertEqual(expectedWeight, actualWeight, errorMsg)
 def __init__(self):
     Item.__init__(self, "Dragon's Claw", "+40 Magic Resistance, Gain 83% resistance to magic damage", True)
Ejemplo n.º 35
0
    def testExecute(self):
        from player import Player
        from space import Space
        from items.item import Item
        from items.weapon import Weapon
        from commands.equip_command import EquipCommand

        #Tests default states
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)

        #Trying to equip item not in inventory
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        equipCmd = EquipCommand("Equip", "Equips item in inventory to player",
                                player)

        item = Item("Charm", "Unknown effects", 1)
        weapon = Weapon("Dagger", "A trusty blade", 2, 2)

        rawInputMock = MagicMock(return_value="Dagger")
        with patch('commands.equip_command.raw_input',
                   create=True,
                   new=rawInputMock):
            equipCmd.execute()

        equipped = player.getEquipped()
        self.assertFalse(equipped.containsItem(weapon),
                         "Player equipped item not in inventory.")

        #Trying to equip item that cannot be equipped (e.g. item is not instance of Armor or Weapon)
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        equipCmd = EquipCommand("Equip", "Equips item in inventory to player",
                                player)

        item = Item("Charm", "Unknown effects", 1)

        inventory = player.getInventory()
        inventory.addItem(item)

        rawInputMock = MagicMock(return_value="Charm")
        with patch('commands.equip_command.raw_input',
                   create=True,
                   new=rawInputMock):
            equipCmd.execute()

        equipped = player.getEquipped()
        self.assertFalse(equipped.containsItem(item),
                         "Player equipped item of Item class.")

        #Equipping item that can be equipped
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        equipCmd = EquipCommand("Equip", "Equips item in inventory to player",
                                player)

        weapon = Weapon("Dagger", "A trusty blade", 2, 2)

        inventory = player.getInventory()
        inventory.addItem(weapon)

        rawInputMock = MagicMock(return_value="Dagger")
        with patch('commands.equip_command.raw_input',
                   create=True,
                   new=rawInputMock):
            equipCmd.execute()

        equipped = player.getEquipped()

        self.assertTrue(equipped.containsItem(weapon),
                        "Player failed to equip equipable item.")

        #Equipping an item that is already equipped
        space = Space("Shire", "Home of the Hobbits.")
        player = Player("Frodo", space)
        equipCmd = EquipCommand("Equip", "Equips item in inventory to player",
                                player)

        weapon = Weapon("Dagger", "A trusty blade", 2, 2)

        inventory = player.getInventory()
        inventory.addItem(weapon)

        equipped = player.getEquipped()
        equipped.addItem(weapon)

        rawInputMock = MagicMock(return_value="Dagger")
        with patch('commands.equip_command.raw_input',
                   create=True,
                   new=rawInputMock):
            equipCmd.execute()

        numberInInventory = 0
        numberInEquipped = 0
        for item in inventory._items:
            if item == weapon:
                numberInInventory += 1
        for item in equipped._items:
            if item == weapon:
                numberInEquipped += 1

        self.assertEqual(
            inventory.count(), 1,
            "Equipping an item that is already equipped failed -- inventory problem."
        )
        self.assertEqual(
            equipped.count(), 1,
            "Equipping an item that is already equipped failed -- equipment problem."
        )