Part 12: Read things

In this section we’ll add the read command, which the player can use to read a clue from the book item.

In this section we’ll also start following an approach to coding called TDD, or Test-Driven Development. When following this process, you write your test first, then write the code that makes it pass.

This technique has many advantages. You are forced to be very deliberate about exactly what you are trying to accomplish, which tends to lead to clearer thinking and cleaner code. You can be more confident that your code is working as intended and that it won’t break in the future without you noticing.

Part 12.1: Add command

adventure.py test_game.py

In this section we’ll be adding the read command.

A. In test_game.py define test_do_read()

First we’ll write the test, which we expect to fail.

Demo

1. [ ] Import the do_read function

2. [ ] Add test_do_read() function with one parameter capsys

3. [ ] Call do_read() with an empty list as an argument

4. [ ] Assign the results of capsys.readouterr().out to the variable output

5. [ ] Write an assert statement that checks that the debug message "Trying to read: []" is in output

6. [ ] Run your tests, either at the command line or in VS Code. Since we haven’t written do_read() yet, you will get an error.

Code

from copy import deepcopy

import pytest

import adventure
from adventure import (
    debug,
    do_drop,
    do_read,
    error,
    header,
    inventory_change,
    is_for_sale,
    place_has,
    player_has,
    write,
)

Listing 747 test_game.py

def test_do_read(capsys):
    do_read([])

    output = capsys.readouterr().out

    assert "Trying to read: []" in output, \
        "Debug message should be in output"

B. In adventure.py define do_read()

Now we’ll write the code to make it work.

Demo

1. [ ] Add a do_read() function with one parameter args

2. [ ] In it, use the debug() function to print something like "Trying to read args.".

3. [ ] Run your test again. It should now pass.

Code

Listing 748 adventure.py

def do_read(args):
    """Read an item with a message."""

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

C. In adventure.py modify main()

Finally, we’ll add the code to make the command work in the game.

1. [ ] Add an elif that checks if command is "read".

   • [ ] if so, call do_read() and pass args.

Demo

Code

def main():
    header("Welcome!")

    while True:
        debug(f"You are at: {PLAYER['place']}")

        reply = input(fg.cyan("> ")).strip()
        args = reply.split()

        if not args:
            continue

        command = args.pop(0)
        debug(f"Command: {command!r}, args: {args!r}")

        if command in ("q", "quit", "exit"):
            do_quit()

        elif command in ("shop"):
            do_shop()

        elif command in ("g", "go"):
            do_go(args)

        elif command in ("x", "exam", "examine"):
            do_examine(args)

        elif command in ("l", "look"):
            do_look()

        elif command in ("t", "take", "grab"):
            do_take(args)

        elif command in ("i", "inventory"):
            do_inventory()

        elif command in ("r", "read"):
            do_read(args)

        elif command == "drop":
            do_drop(args)

        elif command == "buy":
            do_buy(args)

        else:
            error("No such command.")
            continue

        # print a blank line no matter what
        print()

Part 12.2: Ensure item

adventure.py test_game.py

In this section we’ll make sure that the player entered the item that they want to read.

Demo

A. In test_game.py modify test_do_read()

Now we’ll add an assertion to check the output for an error message.

1. [ ] Change the name of test_do_read() to test_do_read_no_args()

2. [ ] Add an assertion that checks if "Error What do you want to read?" is in output

3. [ ] Run your test. It should fail.

Demo

Code

Listing 749 test_game.py

def test_do_read_no_args(capsys):
    do_read([])

    output = capsys.readouterr().out

    assert "Trying to read: []" in output, \
        "Debug message should be in output"

    assert "Error What do you want to read?" in output, \
        "User error should be in output"

B. In adventure.py modify do_read()

Now we’ll write the code to make our test pass.

1. [ ] Check if args is falsy. If it is, use the error() function to print an error that says: "What do you want to read?" then return

2. [ ] Run your test again. It should pass.

Demo

Code

Listing 750 test_game.py

def do_read(args):
    """Read an item with a message."""

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

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

Part 12.3: Ensure item is here

adventure.py test_game.py

In this section we’ll make sure the item that the player typed is either in this place or in inventory.

Demo

A. In test_game.py define test_do_read_missing_item()

In this section we’ll write a new test to make sure that the item is either in this place or in inventory.

Demo

1. [ ] Add test_do_read_missing_item() function with the parameter capsys

2. [ ] Call do_read() with a list and a any string that is not an item key for an argument

3. [ ] Assign the results of capsys.readouterr().out to the variable output

4. [ ] Write an assert statement that checks that the debug message "Trying to read: []" is in output

5. [ ] Write an assert statement that checks that the message "Sorry, I don't know what this is'" is in output

6. [ ] Run your test. It should fail.

Code

Listing 751 test_game.py

def test_do_read_missing_item(capsys):
    do_read(["missing"])

    output = capsys.readouterr().out

    assert "Trying to read: ['missing']" in output, \
        "Debug message should be in output"

    assert "Error Sorry, I don't know what this is: 'missing'" in output, \
        "User error should be in output"

B. In adventure.py modify do_read()

Now we’ll add the code to make the test pass.

Demo

1. [ ] assign the first item of the args list to the variable name and make it lowercase

2. [ ] Write an if statement that checks if either the place or player has the item. If not:

   • [ ] Use the error() function to print a message like: "Sorry, I don't know what this is: name'"

   • [ ] return

3. [ ] Run your test again. It should pass.

Code

Listing 752 adventure.py

def do_read(args):
    """Read an item with a message."""

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

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

    # 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

Part 12.4: Ensure item is readable

adventure.py test_game.py

In this section we’ll make sure that the item the player wants to be read can, in fact, be read.

Demo

A. In test_game.py define test_do_read_unreadable_item()

In this section we’ll be adding a test for when the player tries to read an item that cannot be read. It should:

• [ ] Add a fake unreadable item dictionary to the current place. An item is readable if it has a "message" key, so for a fake item all we really need is an empty dictionary.

• [ ] Call do_read() with the arguments that would be passed to it if the player had typed "read FAKE_THING".

• [ ] Check the output for the appropriate error message

Demo

1. [ ] import the place_add function

2. [ ] Add test_do_read_unreadable_item() function with the parameter capsys

3. [ ] Add a fake item to adventure.ITEMS with the key of your choice

4. [ ] Use the place_add() function to add your fake item to the current place

5. [ ] Call do_read() with a list containing your new key as the argument

6. [ ] Assign the results of capsys.readouterr().out to the variable output

7. [ ] Write an assert statement that checks that the message "Sorry, I don't can't read 'key'" is in output

8. [ ] Run your test. It should fail.

Code

Listing 753 test_game.py

def test_do_read_unreadable_item(capsys):
    adventure.ITEMS["your mind"] = {"name": "Your mind"}
    place_add("your mind")

    do_read(["your mind"])
    output = capsys.readouterr().out

    assert "Error Sorry, I can't read 'your mind'" in output, \
        "User error should be in output"

B. In adventure.py modify do_read()

Now we’ll write the code to make the test pass.

Demo

1. [ ] Use the get_item() function to get the item dictionary and assign it to the variable item

2. [ ] Check if the "message" key is in the item dictionary. If not:

   • [ ] Use the error() function to print an error message like: "Sorry, I can't read 'name'"

   • [ ] return

3. [ ] Run your test again. It should pass.

Code

Listing 754 adventure.py

def do_read(args):
    """Read an item with a message."""

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

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

    # 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)

    # make sure it is an item you can read
    if "writing" not in item:
        error(f"Sorry, I can't read {name!r}.")
        return

Part 12.5: Read things

adventure.py test_game.py

In this section we’ll finally provide a readable item and the read command will read it.

A. In test_game.py define test_do_read_in_place()

In this section we’ll write a new test where we’ll set up a fake item with "message" and "title" keys containing the text to be read and add it to the current place. Then we’ll call do_read()and check for the expected output.

Demo

1. [ ] Add a function test_do_read_in_place()

2. [ ] Create a dictionary representing a fake item item with the keys "title" and "message" and whatever text you’d like for the values.

3. [ ] Use the place_add() function to add it to the current place

4. [ ] Call do_read() with the key for your fake item

5. [ ] Assign the results of capsys.readouterr().out to the variable output

6. [ ] Write an assert statement that the title is in output

7. [ ] Write an assert statement that the message is in output

8. [ ] Run your test. It should fail.

Code

Listing 755 test_game.py

def test_do_read_in_place(capsys):
    title = "After studying your palm I see..."
    message = "The break in your line of fate may indicate a change in location or career"

    adventure.ITEMS["your palm"] = {
        "name": "Your palm",
        "writing": {
            "title": title,
            "message": message,
        },
    }

    place_add("your palm")

    do_read(["your palm"])
    output = capsys.readouterr().out

    assert "After studying your palm I see..." in output, \
        "The writing title {title!r} should be in output"

    assert "The break in your line of fate" in output, \
        "The writing message {message!r} should be in output"

B. In adventure.py modify do_read()

Now we’ll write the code to actually read the item.

Demo

1. [ ] If the "title" key exists in the item dictionary, Use the header() function to print that value. Otherwise print something like "It reads...".

2. [ ] Use the wrap() function to print the "message" value from the item dictionary.

Code

Listing 756 adventure.py

def do_read(args):
    """Read an item with a message."""

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

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

    # 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)

    # make sure it is an item you can read
    if "writing" not in item:
        error(f"Sorry, I can't read {name!r}.")
        return

    # get the information to read
    writing = item["writing"]

    # print the item header
    header(writing["title"])

    # print the quantity message
    wrap(writing.get("message"))

C. Modify ITEMS: add to "book"

Now we’ll finally give the player something to read.

1. [ ] In the "book" dictionary in ITEMS, add the key "title" with whatever text you’d like

2. [ ] In the "book" dictionary in ITEMS, add the key "message" with whatever text you’d like

Demo

Code

Listing 757 adventure.py

    "book": {
        "key": "book",
        "can_take": True,
        "name": "a book",
        "description": (
            "A hefty leather-bound tome open to an interesting passage."
        ),
        "writing": {
            "title": (
                "The book is open to a page that reads:"
            ),
            "message": (
                "At the edge of the woods is a cave that is home to a three "
                "headed dragon, each with a different temperament. "

                "Legend says that if you happen upon the dragon sleeping, the "
                "brave may pet one of its three heads. "

                "Choose the right head and you will be rewarded with great "
                "fortunes. "

                "But beware, choose poorly and it will surely mean your doom! "
            ),
        },
    },

D. In test_game.py define test_do_read_in_inventory()

Can you write a test_do_read_in_inventory() function on your own, to test that you can read a book if it is in your inventory but not in the current place?

Code

Listing 758 test_game.py

def test_do_read_in_inventory(capsys):
    title = "After studying the leaves I see..."
    message = "Your future is uncertain."

    adventure.ITEMS["tea leaves"] = {
        "name": "Tea Leaves",
        "writing": {
            "title": title,
            "message": message,
        },
    }

    inventory_change("tea leaves")

    do_read(["tea leaves"])
    output = capsys.readouterr().out

    assert "After studying the leaves I see..." in output, \
        "The writing title {title!r} should be in output"

    assert "Your future is uncertain" in output, \
        "The writing message {message!r} should be in output"

Part 12.6: Indent message

adventure.py test_game.py

In this section we’re going to indent the message part of the text an extra level.

Demo

A. In test_game.py modify test_do_read_in_inventory()

In this section we’re going to modify our test_do_read_in_inventory() function to test that the message has been indented an extra level.

1. [ ] Call .splitlines() on output and assign it to the variable lines

2. [ ] Write an assert statement that checks if the last item in lines equals your fake items message with 4 spaces at the beginning. (Assuming your message is short enough.)

3. [ ] Run your test. It should fail.

Demo

Tip

When you run pytest at the command line, you can run a single test by adding ::test_name after the filename. For example, here I used pytest test_game.py::test_do_read_in_inventory.

Code

Listing 759 test_game.py

def test_do_read_in_inventory(capsys):
    title = "After studying the leaves I see..."
    message = "Your future is uncertain."

    adventure.ITEMS["tea leaves"] = {
        "name": "Tea Leaves",
        "writing": {
            "title": title,
            "message": message,
        },
    }

    inventory_change("tea leaves")

    do_read(["tea leaves"])
    output = capsys.readouterr().out
    lines = output.splitlines()

    assert "After studying the leaves I see..." in output, \
        "The writing title {title!r} should be in output"

    assert lines[-1] == "      Your future is uncertain.", \
        "The writing message {message!r} should be indented an extra level."

B. In test_game.py define test_wrap()

Before we change any code in do_read(), we’re actually going to modify the wrap() function to optionally add indentation. And since we don’t have any tests for wrap() yet, we’ll one before we change it.

Since we’re testing pre-existing behavior here, this is one we’ll expect to pass.

Demo

1. [ ] Add a function test_wrap() that takes one parameter capsys

2. [ ] Call wrap() with a string that is longer than the WIDTH in your game.

3. [ ] Assign the results of capsys.readouterr().out to the variable output

4. [ ] Call .splitlines() on output and assign it to the variable lines

5. [ ] Write an assert statement that tests that the length of lines is greater than 1

6. [ ] Write an assert statement that tests that output contains the first few words of the text argument.

7. [ ] Write an assert statement that tests that output ends with the last few words of the text argument, followed by a newline.

8. [ ] Make sure that each string in lines starts with two, and no more than two, spaces.

9. [ ] Run your test. It should pass.

Code

Listing 760 test_game.py

def test_wrap(capsys):
    wrap(
        "I pass through many Me's in the course of my day, "
        "each one selfish with his time. The Lying-in-Bed "
        "me and the Enjoying-the-Hot-Shower Me are particularly "
        "selfish. The Late Me loathes the pair of them."
    )
    output = capsys.readouterr().out
    lines = output.splitlines()

    assert "I pass through" in output, \
        "wrap() should print the text indented."

    assert output.endswith("pair of them.\n"), \
        "wrap() should print the text"

    assert len(lines) > 1, "wrap() should break long text onto multiple lines"

    assert all([line.startswith("  ") for line in lines]), \
        "wrap() should indent all lines"

    assert all([line[2] != " " for line in lines]), \
        "wrap() should indent all lines 2 spaces"

C. In test_game.py define test_wrap_with_indent()

Now that we have the normal wrap() behavior tested, we’ll add a (failing) test for the new behavior with the optional indent parameter we will be adding.

This is going to be nearly identical to the test_wrap() function, except we’ll be adding the keyword argument indent=2 when we call wrap(), then testing that the lines are indented to 4 spaces instead of 2.

Demo

1. [ ] Add a function test_wrap_with_indent() that takes one parameter capsys

2. [ ] Call wrap() with a string that is longer than the WIDTH in your game, followed by a keyword argument indent with a value of 2.

3. [ ] Assign the results of capsys.readouterr().out to the variable output

4. [ ] Call .splitlines() on output and assign it to the variable lines

5. [ ] Write an assert statement that tests that the length of lines is greater than 1

6. [ ] Write an assert statement that tests that output contains the first few words of the text argument.

7. [ ] Write an assert statement that tests that output ends with the last few words of the text argument, followed by a newline.

8. [ ] Make sure that each string in lines starts with four, and no more than four, spaces.

9. [ ] Run your test. (Or however many extra spaces you would like.) It should fail.

Code

Listing 761 test_game.py

def test_wrap_with_indent(capsys):
    wrap(
        "To the absolutist in every craftsman, "
        "each imperfection is a failure; "
        "to the practitioner, obsession with "
        "perfection seems a perception for failure.",
        indent=2,
    )
    output = capsys.readouterr().out
    lines = output.splitlines()

    assert "To the absolutist" in output, \
        "wrap() should print the text."

    assert output.endswith("perception for failure.\n"), \
        "wrap() should print the text"

    assert len(lines) > 1, "wrap() should break long text onto multiple lines"

    assert all([line.startswith("    ") for line in lines]), \
        "wrap() should indent all lines"

    assert all([line[4] != " " for line in lines]), \
        "wrap() should indent all lines 4 spaces"

D. In adventure.py modify wrap()

We’re finally ready to modify the wrap() function to handle indention for us.

1. [ ] Add an optional indent parameter to wrap with a default value of 1

2. [ ] When calculating margin, multiply the existing value by indent

3. [ ] Run your test_wrap_with_indent() test. It should pass.

4. [ ] Run your test_wrap() test. It should pass.

Demo

Tip

When you run pytest at the command line, you can use the -k KEYWORD flag to run all tests with names that contain KEYWORD. For example, here I use pytest test_game.py -k test_wrap to run both test_wrap() and test_wrap_with_indent(), but no other tests.

Code

Listing 762 test_game.py

def wrap(text, indent=1):
    """Print wrapped and indented text."""

    # calculate the indentation
    margin = (MARGIN * " ") * indent

    # wrap the text
    paragraph = textwrap.fill(
        text,
        WIDTH,
        initial_indent=margin,
        subsequent_indent=margin,
    )

    # print the wrapped text
    print(paragraph)

E. In adventure.py modify do_read()

Now we’re finally ready to modify our do_read() function to use the new indent keyword argument in wrap().

1. [ ] When you print the item message by calling wrap() add a keyword argument indent with a value of 2. (Or more, to your taste. Just be sure you update your test.)

2. [ ] Run your test_do_read_in_inventory test. It should pass.

3. [ ] Run all your tests. They should pass.

Demo

Code

Listing 763 test_game.py

def do_read(args):
    """Read an item with a message."""

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

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

    # 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)

    # make sure it is an item you can read
    if "writing" not in item:
        error(f"Sorry, I can't read {name!r}.")
        return

    # get the information to read
    writing = item["writing"]

    # print the item header
    header(writing["title"])

    # print the item message
    wrap(writing.get("message"), indent=3)

Part 12.7: Allow for stanzas

adventure.py test_game.py

In this section we’ll add functionality to break up a long message (in particular, our book message) into multiple stanzas.

To accomplish this, we’ll modify wrap() so that for its text argument it can take either a string or an iterable (a tuple or a list) of strings. If text is a string, it should print just the same as it does now. If text is a tuple or a list, each item should be wrapped separately and printed with a blank line between each one.

Demo

A. In test_game.py modify test_do_read_in_place()

In this section we’ll modify the test_do_read_in_place() test so that the "message" in our fake item is either a tuple or a list, where each item represents a stanza. Then we’ll add an assert statement to check that there are two "\n" before one of our stanzas.

We’ll leave the test_do_read_in_inventory() test alone, which will make sure that it still works if message is a string.

Demo

1. [ ] Modify the value corresponding to the "message" key in your fake item dictionary to be either a tuple or a list of strings with multiple items.

2. [ ] Add an assert statement that checks to make sure that output contains two blank lines, followed by the number of indentation spaces, followed by the first few words of one of your message items.

3. [ ] Run the test. It should fail.

Code

Listing 764 test_game.py

def test_do_read_in_place(capsys):
    title = "After studying your palm I see..."
    message = (
        "The break in your line of fate may indicate "
        "a change in location or career.",

        "You have more than one life line, which may "
        "indicate you are a cat",
    )

    adventure.ITEMS["your palm"] = {
        "name": "Your palm",
        "title": title,
        "message": message,
    }

    place_add("your palm")

    do_read(["your palm"])
    output = capsys.readouterr().out

    assert "After studying your palm I see..." in output, \
        "The writing title {title!r} should be in output"

    assert "The break in your line of fate" in output, \
        "The writing message {message!r} should be in output"

    assert "\n\n      You have more than" in output, \
        "When message is an iterable, there should be two lines between each item"

B. In test_game.py define test_wrap_with_iterable()

Once again, the real heavy lifting will be done in the wrap() function. So before we write any code we’ll write a new wrap() test for when text is an iterable.

Demo

1. [ ] Add a function test_wrap_with_iterable() with one parameter capsys

2. [ ] Set the variable message to a list or a tuple of strings. (Consider using a few lyrics of a short song or rhyme.)

3. [ ] Call the wrap() function with the argument message

4. [ ] Assign the results of capsys.readouterr().out to the variable output

5. [ ] Write an assert statement that makes sure part of one of our message items is in output

6. [ ] Write an assert statement to make sure that a parenthesis is not in output if message is a tuple, or that a square bracket is not in output if message is a list. This is to make sure that we are not mistakenly printing the entire iterable instead of each string in the iterable.

7. [ ] Add an assert statement that checks to make sure that output contains two blank lines, followed by the number of indentation spaces, followed by the first few words of one of your message items.

8. [ ] Run the test. It should fail.

Code

Listing 765 test_game.py

def test_wrap_with_iterable(capsys):
    message = (
        "The exercise for centering oneself is a simple one.",

        "Stop thinking of what you intend to do. Stop thinking of what you "
        "have just done. Then stop thinking that you have stopped thinking of "
        "those things.",

        "Then you will find the now. The time that stretches eternal, and is "
        "really the only time there is.",
    )
    wrap(message)

    output = capsys.readouterr().out

    assert "The exercise for centering oneself" in output, \
        "wrap() should print the text."

    assert "(" not in output, \
        "wrap() should not contain parenthesis representing a tuple"

    assert "\n\n  Stop thinking" in output, \
        "There should be two newlines between each printed message item"

C. In adventure.py modify wrap()

Now we are ready to change the wrap() function.

First we’ll turn text into a one-item iterable if it was a string, that way we always have something that we can safely iterate over.

Then we’ll iterate over each string in our new text iterable, wrap it the same way we already do, and append it to a list called blocks.

Finally, we’ll print the blocks list with two "\n" between each one.

Demo

Note

We don’t need to make any changes to do_read() for this feature, since it already calls wrap() with whatever was in the item dictionary for "message". So once you’re done with this, all your tests should pass.

1. [ ] Write an if statement to check if text is a string using the isinstance() function.

   • [ ] If so, make a list or tuple containing text and assign it to the same variable, text.

2. [ ] Make an empty list and assign it to the variable blocks

3. [ ] Use a for loop to iterate over text using the variable name stanza

   • [ ] Indent the line(s) where you assign paragraph to be inside your for loop

   • [ ] In your call to textwrap.fill(), instead of use stanza for the first argument instead of text.

   • [ ] Append paragraph to blocks

4. [ ] You can either:

   • [ ] Use argument unpacking to send all of the items in the blocks list as separate arguments to the print() function, and the keyword argument sep to print two newlines between each argument.

   • [ ] Join the blocks list using two newlines as the delimiter, then print the result.

5. [ ] Run your test_wrap_with_iterable() test. It should pass.

6. [ ] Run your test_do_read_in_place() test. It should pass.

7. [ ] Run all your tests. They should pass.

Code

Listing 766 adventure.py

def wrap(text, indent=1):
    """Print wrapped and indented text."""

    # calculate the indentation
    margin = (MARGIN * " ") * indent

    # if a string was passed, turn it into a single item tuple
    if isinstance(text, str):
        text = (text,)

    # make an empty list for the wrapped blocks
    blocks = []

    # iterate over items
    for stanza in text:

        # wrap the text
        paragraph = textwrap.fill(
            stanza,
            WIDTH,
            initial_indent=margin,
            subsequent_indent=margin,
        )

        blocks.append(paragraph)

    # print the wrapped text
    print(*blocks, sep="\n\n")

D. In adventure.py modify ITEMS

Finally, change the "message" in your "book" item to be a list or a tuple of strings.

And now that we’re all literate, feel free to scatter scrolls, signs and sticky notes all over your game!

Code

Listing 767 adventure.py

    "book": {
        "key": "book",
        "can_take": True,
        "name": "a book",
        "description": (
            "A hefty leather-bound tome open to an interesting passage."
        ),
        "title": (
            "The book is open to a page that reads:"
        ),
        "message": (
            "At the edge of the woods is a cave that is home to a three "
            "headed dragon, each with a different temperament. ",

            "Legend says that if you happen upon the dragon sleeping, the "
            "brave may pet one of its three heads. ",

            "Choose the right head and you will be rewarded with great "
            "fortunes. ",

            "But beware, choose poorly and it will surely mean your doom!",
        ),
    },