Part 9: Refactoring

In this section we are going to work on refactoring our game. Refactoring is when you change code to make the code better, but without changing what the software does.

It is key to make changes in small, incremental steps which are tested regularly to ensure the program works properly throughout. Avoid tearing out and reworking vast swaths of code at a time, which will often leave you with a hopeless tangle of broken code.

Here we’ll be focusing on the DRY1 principle–don’t repeat yourself. This means that when you notice you’re repeating the same, or nearly the same, code over and over again, find a way to put it somewhere it can be reused. In this case we’ll be adding a few functions, then call those functions in the places where the same code is repeated.

Part 9.1: Add abort()

source code

The abort() function will be similar to the error() function, except it will exit the game immediately. This function will be for errors that only happen if there is a problem with the code, as opposed to errors that can be caused by something the user typed in.

(This will actually result in a minor change in behavior. Now, when you encounter any errors using the abort() function, your game will end immediately instead of continuing on.)

A. Define abort()

The abort() function will simply call error() to print an error message, then exit the program.

When abort() is called, a return statement will no longer be needed since the program will end immediately.

1. [ ] define an abort() function that takes one argument message

2. [ ] in abort()

   • [ ] call error() with the argument message.

   • [ ] call the built-in exit() function and pass it the argument 1

Code

def abort(message):
    """Print a fatal error message then exit the game."""
    error(message)
    exit(1)

B. Modify do_take()

Since we always expect to be able to find an item in the ITEMS dictionary for a key in the place items list, if we fail to find one that means that we messed something up, not the player. This is a perfect place to use abort() instead of error().

Then because abort() exits the program immediately, we can remove the return.

1. [ ] Call abort() instead of error() when you check if item is falsy

2. [ ] remove the return statement

3. [ ] To test, temporarily change the key for "book" to something else, then type take book from home. It should print an error message then exit the program. After verifying that it works, change it back.

Code

def do_take(args):
    """Pick up an item and add it to inventory."""
    debug(f"Trying to take: {args}")

    # make sure the player typed an item
    if not args:
        error("What do you want to take?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # look up where the player is now
    place_name = PLAYER["place"]
    place = PLACES[place_name]

    # make sure the item is in this place
    if name not in place.get("items", []):
        error(f"Sorry, I don't see a {name!r} here.")
        return

    # get the item information
    item = ITEMS.get(name)

    # make sure the item is in the ITEMS dictionary
    if not item:
        abort(f"Woops! The information about {name!r} seems to be missing.")

C. Modify do_examine()

This is nearly exactly the same as the previous section.

1. [ ] Call abort() instead of error() when you check if name is not in ITEMS

2. [ ] remove the return statement

3. [ ] To test, temporarily change the key for "book" to something else, then type take book from home. It should print an error message then exit the program. After verifying that it works, change it back.

Code

def do_examine(args):
    """Look at an item in the current place."""

    debug(f"Trying to examine: {args}")

    # make sure the player said what they want to examine
    if not args:
        error("What do you want to examine?")
        return

    # look up where the player is now
    place_name = PLAYER["place"]
    place = PLACES[place_name]

    # get the item entered by the user and make it lowercase
    name = args[0].lower()

    # make sure the item is in this place or in the players inventory
    if not (name in place.get("items", []) or name in PLAYER["inventory"]):
        error(f"Sorry, I don't know what this is: {name!r}.")
        return

    # make sure the item is in the ITEMS dictionary
    if name not in ITEMS:
        abort(f"Woops! The information about {name} seems to be missing.")

D. Modify do_go()

Similar to the previous two sections, we always expect to be able to find an place in the PLACES dictionary for a key from another place dictionary, so if we don’t it means there’s an error somewhere in the code.

1. [ ] Call abort() instead of error() when you check if new_place is truthy

2. [ ] remove the return statement

3. [ ] To test, temporarily change the value for home["east"] to something else, then type go east from home. It should print an error message then exit the program. After verifying that it works, change it back.

Code

def do_go(args):
    """Move to a different place"""
    debug(f"Trying to go: {args}")

    # make sure the player included a direction
    if not args:
        error("Which way do you want to go?")
        return

    # get the direction from arguments
    # and make it lowercase
    direction = args[0].lower()

    # make sure it's a valid direction
    if direction not in ('north', 'south', 'east', 'west'):
        error(f"Sorry, I don't know how to go: {direction}.")
        return

    # look up where the player is now
    old_name = PLAYER["place"]
    old_place = PLACES[old_name]

    # look up what is in that direction from here
    new_name = old_place.get(direction)

    # print an error if there is nothing in that direction
    if not new_name:
        error(f"Sorry, you can't go {direction} from here.")
        return

    # look up the place information
    new_place = PLACES.get(new_name)

    # this should never happen if we write the code correctly
    # but just in case there is no key in PLACES matching
    # the new name, print an error
    if not new_place:
        abort(f"Woops! The information about {new_name} seems to be missing.")

Part 9.2: Add get_place()

source code

Since we’re so often needing to get place information from the PLACES dictionary, we’ll wrap this functionality into a function called get_place() that we can call from anywhere in our program where we need to get place information.

A. Define get_place()

The get_place() function will take one argument, the key to get from the PLACES dictionary. We’ll make that argument optional though, and set the default to None.

If the user passes a key argument, then we’ll get the place information from PLACES for that key. If they don’t, we’ll get the key from the PLAYER dictionary for their current location. That way we can call get_place() with no args to get the current place.

This function will also check to make sure the place is found in the PLACES dictionary, and call abort() if it is not. That means that anywhere we call get_place() will not have to do that error handling over and over.

1. [ ] define a get_place() function that takes one optional argument key with a default value of None

2. [ ] if key is falsy then assign key to the value of the PLAYER dict associated with the "place" value

3. [ ] get the value from the PLACES dictionary associated from the key key and assign it to the variable place

4. [ ] If place is falsy,

   • [ ] Use the abort() function to print an error message like:

     "Woops! The information about the place name seems to be missing."

5. [ ] return place

Code

def get_place(key=None):
    """Return the place information from the PLACES dictionary, either
       associated with key, or if none is passed, where the user is
       currently at. """
    # get the current player's place if key is not passed
    if not key:
        key = PLAYER["place"]

    # get the place info
    place = PLACES.get(key)

    # this should never happen if we write the code correctly
    # but just in case there is no key in PLACES matching
    # the new name, print an error
    if not place:
        abort(f"Woops! The information about {key!r} seems to be missing.")

    return place

B. Modify do_go()

1. [ ] Call get_place() with no arguments to get the value for old_place. (This will replace the existing PLACES[old_place].)

2. [ ] Remove the line assigning old_name since that is taken care of in get_place()

3. [ ] Call get_place() with the argument new_name to get the value for new_place. (This will replace the existing PLACES.get(new_place).)

4. [ ] Remove the lines that calls abort() if new_place is falsy.

Code

def do_go(args):
    """Move to a different place"""
    debug(f"Trying to go: {args}")

    # make sure the player included a direction
    if not args:
        error("Which way do you want to go?")
        return

    # get the direction from arguments
    # and make it lowercase
    direction = args[0].lower()

    # make sure it's a valid direction
    if direction not in ('north', 'south', 'east', 'west'):
        error(f"Sorry, I don't know how to go: {direction}.")
        return

    # look up where the player is now
    old_place = get_place()

    # look up what is in that direction from here
    new_name = old_place.get(direction)

    # print an error if there is nothing in that direction
    if not new_name:
        error(f"Sorry, you can't go {direction} from here.")
        return

    # look up the place information
    new_place = get_place(new_name)

    # move the player to the new place
    PLAYER["place"] = new_name

    # print information about the new place
    header(f"{new_place['name']}")
    wrap(new_place["description"])

C. Modify do_look()

1. [ ] Replace the existing value for place with a call to get_place().

2. [ ] Remove the line assigning place_name since that is taken care of in get_place()

3. [ ] Replace the existing value for destination with a call to get_place() with the argument name.

Code

def do_look():
    """Look at the current place"""

    debug("Trying to look around.")

    # look up where the player is now
    place = get_place()

    # print information about the current place
    header(f"{place['name']}")
    wrap(place["description"])

    # get the items in the room
    items = place.get("items", [])

    if items:

        # for each of the place items
        # get the info from the ITEMS dictionary
        # and make a list of item names
        names = []
        for key in items:
            item = ITEMS.get(key)
            names.append(item["name"])

        # remove the last name from the list
        last = names.pop()

        # construct a sentence that looks like one of:
        #   x, x and y
        #   x and y
        #   y
        text = ", ".join(names)
        if text:
            text += " and "
        text += last

        # print the list of items.
        print()
        wrap(f"You see {text}.\n")

    # add a blank line
    print()

    # print what is in each direction from here
    for direction in ("north", "east", "south", "west"):
        name = place.get(direction)
        if not name:
            continue

        destination = get_place(name)
        write(f"To the {direction} is {destination['name']}.")

D. Modify do_take(), do_examine() and do_drop()

1. [ ] Replace the existing value for place with a call to get_place().

2. [ ] Remove the line assigning place_name since that is taken care of in get_place()

do_take()

def do_take(args):
    """Pick up an item and add it to inventory."""
    debug(f"Trying to take: {args}")

    # make sure the player typed an item
    if not args:
        error("What do you want to take?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # look up where the player is now
    place = get_place()

    # make sure the item is in this place
    if name not in place.get("items", []):
        error(f"Sorry, I don't see a {name!r} here.")
        return

    # get the item information
    item = ITEMS.get(name)

    # make sure the item is in the ITEMS dictionary
    if not item:
        abort(f"Woops! The information about {name!r} seems to be missing.")

    if not item.get("can_take"):
        error(f"You try to pick up {name!r}, but you find you aren't able to lift it.")
        return

    # add to inventory
    PLAYER["inventory"].setdefault(name, 0)
    PLAYER["inventory"][name] += 1

    # remove from place
    place["items"].remove(name)

    wrap(f"You pick up {item['name']} and put it in your pack.")

do_examine()

def do_examine(args):
    """Look at an item in the current place."""

    debug(f"Trying to examine: {args}")

    # make sure the player said what they want to examine
    if not args:
        error("What do you want to examine?")
        return

    # look up where the player is now
    place = get_place()

    # get the item entered by the user and make it lowercase
    name = args[0].lower()

    # make sure the item is in this place or in the players inventory
    if not (name in place.get("items", []) or name in PLAYER["inventory"]):
        error(f"Sorry, I don't know what this is: {name!r}.")
        return

    # make sure the item is in the ITEMS dictionary
    if name not in ITEMS:
        abort(f"Woops! The information about {name} seems to be missing.")

    # get the item dictionary
    item = ITEMS[name]

    # print the item information
    header(item["name"].title())
    wrap(item["description"])

do_drop()

def do_drop(args):
    """Remove an item from inventory"""

    debug(f"Trying to drop: {args}.")

    # make sure the player typed an item
    if not args:
        error("What do you want to drop?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # make sure the item is in inventory
    if name not in PLAYER["inventory"] or not PLAYER["inventory"][name]:
        error(f"You don't have any {name!r}.")
        return

    # remove from inventory
    PLAYER["inventory"][name] -= 1
    if not PLAYER["inventory"][name]:
        PLAYER["inventory"].pop(name)

    # look up where the player is now
    place = get_place()

    # add to place items
    place.setdefault("items", [])
    place["items"].append(name)

    # print a message
    wrap(f"You set down the {name}.")

Part 9.3: Add get_item()

source code

In this section we’ll be adding a get_item() function which will be very similar to get_place() but for items instead of places.

A. Define get_item()

The get_item() function will be almost exactly like get_place(). It will also take one argument, the key to get from the ITEMS dictionary, but it will not be optional. We’ll call abort() if the key is not in the ITEMS dictionary and finally return the item otherwise.

1. [ ] define a get_item() function that takes one argument key

2. [ ] use the .get() method on the ITEMS dictionary to get the value associated from the key key and assign it to the variable item

3. [ ] If item is falsy,

   • [ ] Use the abort() function to print an error message like:

     "Woops! The information about the item name seems to be missing."

4. [ ] return item

Code

def get_item(key):
    """Return item information from ITEMS dictionary associated with key. If no
       item is found, print an error message and return None."""
    item = ITEMS.get(key)

    if not item:
        abort(f"Woops! The information about {key!r} seems to be missing.")

    return item

B. Modify do_look() and do_inventory(): call get_item()

Throughout the rest of the program, you’ll replace anywhere that you get an item from the ITEMS dictionary using subscription or the .get() method with a call to get_item().

1. [ ] Call get_item() with the argument name or key to get the value for item. This will replace the existing ITEMS.get(key) or ITEMS[key].

do_look()

def do_look():
    """Look at the current place"""

    debug("Trying to look around.")

    # look up where the player is now
    place = get_place()

    # print information about the current place
    header(f"{place['name']}")
    wrap(place["description"])

    # get the items in the room
    items = place.get("items", [])

    if items:

        # for each of the place items
        # get the info from the ITEMS dictionary
        # and make a list of item names
        names = []
        for key in items:
            item = get_item(key)
            names.append(item["name"])

        # remove the last name from the list
        last = names.pop()

        # construct a sentence that looks like one of:
        #   x, x and y
        #   x and y
        #   y
        text = ", ".join(names)
        if text:
            text += " and "
        text += last

        # print the list of items.
        print()
        wrap(f"You see {text}.\n")

    # add a blank line
    print()

    # print what is in each direction from here
    for direction in ("north", "east", "south", "west"):
        name = place.get(direction)
        if not name:
            continue

        destination = get_place(name)
        write(f"To the {direction} is {destination['name']}.")

do_inventory()

def do_inventory():
    """Show the players inventory"""

    debug("Trying to show inventory.")

    header("Inventory")

    if not PLAYER["inventory"]:
        write("Empty.")
        return

    for name, qty in PLAYER["inventory"].items():
        item = get_item(name)
        write(f"(x{qty:>2})  {item['name']}")

    print()

C. Modify do_examine() and do_take(): call get_item()

In these functions we’ll do a similar replacement as above. Additionally, we’ll remove error handling that is done in get_item().

1. [ ] Call get_item() with the argument name or key to get the value for item. This will replace the existing ITEMS.get(key) or ITEMS[key].

2. [ ] Remove the lines that calls abort() if item is falsy or if name is not in ITEMS.

do_examine()

def do_examine(args):
    """Look at an item in the current place."""

    debug(f"Trying to examine: {args}")

    # make sure the player said what they want to examine
    if not args:
        error("What do you want to examine?")
        return

    # look up where the player is now
    place = get_place()

    # get the item entered by the user and make it lowercase
    name = args[0].lower()

    # make sure the item is in this place or in the players inventory
    if not (name in place.get("items", []) or name in PLAYER["inventory"]):
        error(f"Sorry, I don't know what this is: {name!r}.")
        return

    # get the item dictionary
    item = get_item(name)

    # print the item information
    header(item["name"].title())
    wrap(item["description"])

do_take()

def do_take(args):
    """Pick up an item and add it to inventory."""
    debug(f"Trying to take: {args}")

    # make sure the player typed an item
    if not args:
        error("What do you want to take?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # look up where the player is now
    place = get_place()

    # make sure the item is in this place
    if name not in place.get("items", []):
        error(f"Sorry, I don't see a {name!r} here.")
        return

    # get the item information
    item = get_item(name)

    if not item.get("can_take"):
        error(f"You try to pick up {name!r}, but you find you aren't able to lift it.")
        return

    # add to inventory
    PLAYER["inventory"].setdefault(name, 0)
    PLAYER["inventory"][name] += 1

    # remove from place
    place["items"].remove(name)

    wrap(f"You pick up {item['name']} and put it in your pack.")

Part 9.4: Validation functions

source code

In this section we’ll be several functions return True or False so that they can be used for things we commonly need to check. Specifically the functions player_has(), place_has(), and is_for_sale().

A. Define player_has()

The player_has() function will return True if the player has a particular item in inventory.

1. [ ] define a player_has() function that takes one argument key, and an optional argument qty with a default value of 1

2. [ ] Check if the key is in the players inventory (stored in the PLAYER dict with the "inventory" key), and if so, if the value is greater than or equal to qty.

   • [ ] If so, return True

   • [ ] If not, return False

Code

def player_has(key, qty=1):
    """Return True if the player has at least qty item(s) associated with key in
       their inventory."""
    return key in PLAYER["inventory"] and PLAYER["inventory"][key] >= qty

B. Modify do_drop(): call player_has()

Now in our if statements where we check the same thing we can replace it with a call to player_has().

1. [ ] Find the if statement where we check to see if the item is in not inventory.

2. [ ] Replace the part of the condition that checks with a call to player_has() and pass the argument name(). (Be sure to keep the not.)

Code

def do_drop(args):
    """Remove an item from inventory"""

    debug(f"Trying to drop: {args}.")

    # make sure the player typed an item
    if not args:
        error("What do you want to drop?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # make sure the item is in inventory
    if not player_has(name):
        error(f"You don't have any {name!r}.")
        return

    # remove from player inventory
    PLAYER["inventory"][name] -= 1
    if not PLAYER["inventory"][name]:
        PLAYER["inventory"].pop(name)

    # look up where the player is now
    place = get_place()

    # add to place items
    place.setdefault("items", [])
    place["items"].append(name)

    # print a message
    wrap(f"You set down the {name}.")

C. Call player_has() from do_examine()

1. [ ] Find the if statement where we check to see if the item is not in either the current place or the inventory.

2. [ ] Replace the part of the condition that checks with a call to player_has() and pass the argument name(). (Be sure to keep the not, as well as the part that checks if the item is in the current place.)

Code

def do_examine(args):
    """Look at an item in the current place."""

    debug(f"Trying to examine: {args}")

    # make sure the player said what they want to examine
    if not args:
        error("What do you want to examine?")
        return

    # look up where the player is now
    place = get_place()

    # get the item entered by the user and make it lowercase
    name = args[0].lower()

    # make sure the item is in this place or in the players inventory
    if not (place_has(name) or player_has(name)):
        error(f"Sorry, I don't know what this is: {name!r}.")
        return

    # get the item dictionary
    item = get_item(name)

    # print the item information
    header(item["name"].title())
    wrap(item["description"])

D. Define place_has()

The place_has() function will return True if the place has a particular item.

1. [ ] define a place_has() function that takes one argument item.

2. [ ] In the function get the current place by calling get_place() assign it to the variable place.

3. [ ] Check if the item is in the list of items in the current place by using the .get() method on place with the key "items".

   • [ ] If so, return True

   • [ ] If not, return False

Code

def place_has(item):
    """Return True if current place has a particular item."""
    place = get_place()
    return item in place.get("items", [])

E. Call place_has() from do_take()

Now in our if statements where we check the same thing we can replace it with a call to place_has().

1. [ ] Find the if statement where we check to see if the item is not in the current place.

2. [ ] Replace the part of the condition that checks with a call to place_has() and pass the argument name(). (Be sure to keep the not.)

Code

def do_take(args):
    """Pick up an item and add it to inventory."""
    debug(f"Trying to take: {args}")

    # make sure the player typed an item
    if not args:
        error("What do you want to take?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # look up where the player is now
    place = get_place()

    # make sure the item is in this place
    if not place_has(name):
        error(f"Sorry, I don't see a {name!r} here.")
        return

    # get the item information
    item = get_item(name)

    if not item.get("can_take"):
        error(f"You try to pick up {name!r}, but you find you aren't able to lift it.")
        return

    # add to inventory
    PLAYER["inventory"].setdefault(name, 0)
    PLAYER["inventory"][name] += 1

    # remove from place
    place["items"].remove(name)

    wrap(f"You pick up {item['name']} and put it in your pack.")

F. Call place_has() from do_examine()

Now in our if statements where we check the same thing we can replace it with a call to place_has().

1. [ ] Find the if statement where we check to see if the item is not in the current place.

2. [ ] Replace the part of the condition that checks with a call to place_has() and pass the argument name. (Be sure to keep the not as well as the part that checks if the player has the item.)

Code

def do_examine(args):
    """Look at an item in the current place."""

    debug(f"Trying to examine: {args}")

    # make sure the player said what they want to examine
    if not args:
        error("What do you want to examine?")
        return

    # look up where the player is now
    place = get_place()

    # get the item entered by the user and make it lowercase
    name = args[0].lower()

    # make sure the item is in this place or in the players inventory
    if not (place_has(name) or player_has(name)):
        error(f"Sorry, I don't know what this is: {name!r}.")
        return

    # get the item dictionary
    item = get_item(name)

    # print the item information
    header(item["name"].title())
    wrap(item["description"])

G. Define is_for_sale()

The is_for_sale() function will return True if an item is for sale.

1. [ ] Define a is_for_sale() function that takes one argument, item.

2. [ ] Check if the "price" key is in the item dictionary.

   • [ ] If so, return True

   • [ ] If not, return False

Code

def is_for_sale(item):
    """Return True if item is for sale (has a price)."""
    return "price" in item

H. Call is_for_sale() from do_shop()

Now in our if statements where we check the same thing we can replace it with a call to is_for_sale().

1. [ ] Find the if statement where we check to see if the "price" key is in an item dictionary

2. [ ] Replace the part of the condition that checks with a call to is_for_sale() and pass the argument item. (Be sure to keep the not.)

Code

def do_shop():
    """List the items for sale."""

    header("Items for sale.")

    for item in ITEMS.values():
        if not is_for_sale(item):
            continue

        write(f'{item["name"]:<13}  {item["description"]}')

    print()

Part 9.5: Add inventory_change()

source code

In this section we’ll be adding an inventory_change() function that will add or remove items from the players inventory.

A. Define inventory_change()

The inventory_change() function will handle either adding items to a player’s inventory or removing from it. We’ll use an optional argument quantity for the number to add. (If the number is negative, then it the quantity will be subtracted.)

In this function we’ll use the .setdefault() method on the inventory dictionary. This is kind of like the inverse of the .get() method–if the key is not currently in the dictionary, it will set it default value. Otherwise, nothing will happen.2

Once we are done changing the quantity in inventory, we’ll remove the entire item from dictionary if there is 0 (or less) of them left. This way items with a zero quantity won’t show up in do_inventory().

1. [ ] Define a inventory_change() function that takes one argument key, and an optional argument quantity with a default value of 1

2. [ ] Call the .setdefault() method on the players inventory (accessed in the PLAYER dict with the "inventory" key) with the arguments key and 0 for the default.

3. [ ] Add quantity to the players inventory (accessed in the PLAYER dict with the "inventory" key) for the key key.

   Hint: Use the += operator.

4. [ ] Check if the value associated with key in the players inventory is falsy, or if it is less than or equal to zero.

   • [ ] If so, remove that key from the player’s inventory by calling the .pop() method on the inventory dictionary with the key argument.

Code

def inventory_change(key, quantity=1):
    """Add item to player inventory."""
    PLAYER["inventory"].setdefault(key, 0)
    PLAYER["inventory"][key] += quantity

    # remove from inventory dictionary if quantity is zero
    if not PLAYER["inventory"][key]:
        PLAYER["inventory"].pop(key)

B. Call inventory_change() in do_take()

Now we can call inventory_change() anytime we want to add or remove something from inventory. Let’s start in the do_take() function. Since we currently can only have one of something in a room at a time, we won’t pass the quantity argument, so it will default to 1.

1. [ ] Find where you add the item to the player’s inventory. Replace those lines with a call to inventory_change() and pass the name argument.

Code

def do_take(args):
    """Pick up an item and add it to inventory."""
    debug(f"Trying to take: {args}")

    # make sure the player typed an item
    if not args:
        error("What do you want to take?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # look up where the player is now
    place = get_place()

    # make sure the item is in this place
    if not place_has(name):
        error(f"Sorry, I don't see a {name!r} here.")
        return

    # get the item information
    item = get_item(name)

    if not item.get("can_take"):
        error(f"You try to pick up {name!r}, but you find you aren't able to lift it.")
        return

    # add to inventory
    inventory_change(name)

    # remove from place
    place["items"].remove(name)

    wrap(f"You pick up {item['name']} and put it in your pack.")

C. Call inventory_change() in do_drop()

Next, we’ll call it from do_drop().

Here we’ll be subtracting from inventory by passing in a negative value for quantity by putting a - in front of the value. Then when the negative number is added to the current inventory value in inventory_change(), it will be the same as if we had subtracted a positive number.

We run into a little issue, since we can have more than one of something in the player’s inventory, but only one of something in a place. To account for this, we’ll zero out that item in inventory and only add one item to place. (Someday we may want to make the place "items" a dictionary instead of a list so we can have more than one of a thing in a particular place, but this will have to do for now.)

1. [ ] Find where you remove the item from the player’s inventory. Right above that, get the amount the player has in their inventory (stored in the PLAYER dict with the "inventory" key) using the name key and assign it to the qty variable.

2. [ ] Replace the lines where you add to the inventory with a call to inventory_change() with the arguments name and -qty.

Code

def do_drop(args):
    """Remove an item from inventory"""

    debug(f"Trying to drop: {args}.")

    # make sure the player typed an item
    if not args:
        error("What do you want to drop?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # make sure the item is in inventory
    if not player_has(name):
        error(f"You don't have any {name!r}.")
        return

    # get the amount currently in inventory
    qty = PLAYER["inventory"][name]

    # remove from player inventory
    inventory_change(name, -qty)

    # look up where the player is now
    place = get_place()

    # add to place items
    place.setdefault("items", [])
    place["items"].append(name)

    # print a message
    wrap(f"You set down the {name}.")

Part 9.6: Add place_add()

source code

In this section we’ll be adding an place_add() function that will add an item to the current place.

A. Define place_add()

The place_add() function will take care of looking up the current place, making sure that the places "items" dictionary is set to an empty list if it’s missing, making sure that it’s not already in the place, and finally adding the item key to the place list.

1. [ ] Define a place_add() function that takes one argument key.

2. [ ] Get the current place by calling get_place() and assign it to the variable place.

3. [ ] Call .setdefault() on place with the arguments "items" and an empty list.

4. [ ] Check if key is in the place["items"] list

   • [ ] If not, append key to the place["items"] dict

Code

def place_add(key):
    """Add an item to the current place."""
    # get the current place
    place = get_place()

    # add the item key to the place items list
    place.setdefault("items", [])
    if key not in place["items"]:
        place["items"].append(key)

B. Call place_add() in do_drop()

Now we can call place_add() anytime we want to add something to a place. Right now, this only happens in the do_drop() function.

1. [ ] Find where you add the item to the place. Replace those lines with a call to place_add() and pass the name argument.

2. [ ] You can also remove the line where you get the current place using the get_place() function.

Code

def do_drop(args):
    """Remove an item from inventory"""

    debug(f"Trying to drop: {args}.")

    # make sure the player typed an item
    if not args:
        error("What do you want to drop?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # make sure the item is in inventory
    if not player_has(name):
        error(f"You don't have any {name!r}.")
        return

    # get the amount currently in inventory
    qty = PLAYER["inventory"][name]

    # remove from player inventory
    inventory_change(name, -qty)

    # add to place items
    place_add(name)

    # print a message
    wrap(f"You set down the {name}.")

Part 9.7: Add place_remove()

source code

In this section we’ll be adding an place_remove() function that will remove an item from the current place.

A. Define place_remove()

The place_remove() function will take care of looking up the current place, making sure that the item is in the place, and finally removing the item key from the place list.

1. [ ] Define a place_remove() function that takes one argument key.

2. [ ] Get the current place by calling get_place() and assign it to the variable place.

3. [ ] Check if key is in the current place by calling .get() on place and passing the arguments key and an empty list for the default value.

   • [ ] If so, call .remove() on place["items"] with the key argument

Code

def place_remove(key):
    """Remove an item from the current place."""
    # get the current place
    place = get_place()

    # remove from place
    if key in place.get("items", []):
        place["items"].remove(key)

B. Call place_remove() in do_take()

Now we can call place_remove() anytime we want to remove something from a place. Right now, this only happens in the do_take() function.

1. [ ] Find where you remove the item from the place. Replace those lines with a call to place_remove() and pass the name argument.

2. [ ] You can also remove the line where you get the current place using the get_place() function.

Code

def do_take(args):
    """Pick up an item and add it to inventory."""
    debug(f"Trying to take: {args}")

    # make sure the player typed an item
    if not args:
        error("What do you want to take?")
        return

    # get the item name from arguments
    # and make it lowercase
    name = args[0].lower()

    # make sure the item is in this place
    if not place_has(name):
        error(f"Sorry, I don't see a {name!r} here.")
        return

    # get the item information
    item = get_item(name)

    if not item.get("can_take"):
        error(f"You try to pick up {name!r}, but you find you aren't able to lift it.")
        return

    # add to inventory
    inventory_change(name)

    # remove from place
    place_remove(name)

    wrap(f"You pick up {item['name']} and put it in your pack.")

---

1

https://en.wikipedia.org/wiki/Don%27t_repeat_yourself

2

See help(dict.setdefault) in a python/iPython shell for more information.