Part 14: Dragons

In this section we will add a cave with a three headed dragon and the command to pet them.

Part 14.1: Add command

adventure.py test_game.py

In this section we’ll add the pet command.

Demo

A. In test_game.py define test_do_pet()

First we’ll write the test which we expect to fail. It will just test that when you call do_pet() a debug message is printed.

Need help?

1. [ ] Import the do_pet function

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

3. [ ] Call do_pet() 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 pet: []" is in output

6. [ ] Run your tests. They should fail.

Code

Listing 788 test_game.py

from adventure import (
    debug,
    do_drop,
    do_read,
    do_pet,
    error,
    header,
    health_change,
    inventory_change,
    is_for_sale,
    place_has,
    player_has,
    place_add,
    wrap,
    write,
    MAX_HEALTH,
)

Listing 789 test_game.py

def test_do_pet(capsys):
    # WHEN: You call do_pet()
    do_pet([])
    output = capsys.readouterr().out

    # THEN: A debug message should be printed
    assert "Trying to pet: []" in output

B. In adventure.py define do_pet()

Now we’ll add the do_pet() function to our game. It should print a debug message like Trying to pet:

Need help?

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

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

3. [ ] Run your tests again. They should now pass.

do_pet()

Listing 790 adventure.py

def do_pet(args):
    """Pet dragons"""

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

C. In adventure.py modify main(): add pet

Finally, add the code in main() so that when the player types "pet", the do_pet() function will be called.

Need help?

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

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

main()

Listing 791 adventure.py in main()

        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)

        elif command == "pet":
            do_pet(args)

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

Part 14.2: Is petting allowed?

adventure.py test_game.py

In this section we’ll check to make sure petting is allowed in the current place.

Demo

A. In test_game.py define test_do_pet_cant_pet()

In this section we’ll write a test_do_pet_cant_pet() function. It should check that if the player tries to pet something when in a place where they aren’t allowed (as defined by the place dictionary "can" list), they’ll see an error message.

Need help?

1. GIVEN: The player is in a place where they can’t pet anything

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be an empty list.

2. WHEN: They try to pet something

…

• [ ] Call do_pet() with a list containing any string

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

3. THEN: An error message should be printed

…

• [ ] assert that an error message like "You can't do that" is in output

4. Run your tests. They should fail.

test_do_pet_cant_pet()

Listing 792 test_game.py

def test_do_pet_cant_pet(capsys):
    # GIVEN: The player is in a place where they can't pet anything
    adventure.PLAYER["place"] = "nowhere"
    adventure.PLACES["nowhere"] = {
        "name": "The Void",
        "can": [],
    }

    # WHEN: They try to pet something
    do_pet(["red", "dragon"])
    output = capsys.readouterr().out

    # THEN: An error message should be printed
    assert "You can't do that" in output

B. In adventure.py modify do_pet(): can pet

Now we’ll modify do_pet() function to check that if the current place is not able to use the pet command (as defined by the place dictionary "can" list) an error message will be printed and the function will return.

Need help?

1. [ ] Use the place_can() function to check if the place can "pet". If not:

   • [ ] Print an error message like "You can't do that here."

   • [ ] return

do_pet()

Listing 793 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

C. In adventure.py modify PLACES

Now update the PLACES dictionary to add a cave where you can pet a dragon, and modify your other places so that you can get to it.

Need help?

1. [ ] Add a place called cave with the "can" key set to a list that includes the string "pet"

2. [ ] Modify the "east", "west", "north", and "south" key(s) of your other places so that the player can get to the cave.

PLACES

Listing 794 adventure.py

PLACES = {
    "home": {
        "key": "home",
        "name": "Your Cottage",
        "east": "town-square",
        "description": "A cozy stone cottage with a desk and a neatly made bed.",
        "items": ["desk", "book"],
    },
    "town-square": {
        "key": "town-square",
        "name": "The Town Square",
        "west": "home",
        "east": "woods",
        "north": "market",
        "description": (
            "A large open space surrounded by buildings with a burbling "
            "fountain in the center."
        ),
    },
    "market": {
        "key": "market",
        "name": "The Market",
        "south": "town-square",
        "items": ["elixir", "dagger"],
        "can": ["shop", "buy"],
        "description": (
            "A tidy store with shelves full of goods to buy. A wooden hand "
            "painted menu hangs on the wall."
        ),
    },
    "woods": {
        "key": "woods",
        "name": "The Woods",
        "east": "hill",
        "west": "town-square",
        "description": (
            "A dirt road meanders under a canopy of autumn leaves in brilliant "
            "hues of gold and crimson.",

            "You hear a stream burbling somewhere out of sight. Leaves crunch "
            "under your feet on the sun dappled forest floor.",

            "You see an ancient moss-covered hollow tree, its gnarled and twisted "
            "branches looming over you. On the opposite side, a fallen log juts "
            "partway into the road.",
        ),
        "items": [],
    },
    "hill": {
        "key": "hill",
        "name": "A grassy hill",
        "west": "woods",
        "south": "cave",
        "description": (
            "A winding path leads up the slope of a grassy hill. The air is "
            "warm here.",
            "At the top of the hill, you see that the path continues to the "
            "down to the south. In that direction you can make out a cave by "
            "the shore of a lake."
        ),
        "items": [],
    },
    "cave": {
        "key": "cave",
        "name": "A cave",
        "north": "hill",
        "description": (
            "Your footsteps echo as you step into the vast cavern.",
            "Shafts of sunlight slice through the gloom, playing against the "
            "landscape of glittering treasure.",
            "Resting atop a mound of gold, a collosal dragon rests curled up snugly. "
            "Its three enormous heads snore softly, each in turn.",
        ),
        "items": [],
        "can": ["pet"],
    },
}

Part 14.3: Ensure args

adventure.py test_game.py

In this section we’ll make sure that the player typed what they want to pet, or print an error if they didn’t.

Demo

A. In test_game.py define test_do_pet_no_args()

In this section we’ll write a test_do_pet_no_args() function. It should check that if the player does not type anything after "pet", they’ll see an error message.

Need help?

1. GIVEN: The player is in a place where they can pet things

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be a list containing the string "pet"

2. WHEN: the player types “pet” with no arguments

…

• [ ] Call do_pet() with an empty list

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

3. THEN: an error message should be printed

…

• [ ] assert that an error message like "What do you want to pet" is in output

4. Run your tests. They should fail.

test_do_pet_no_args()

Listing 795 test_game.py

def test_do_pet_no_args(capsys):
    # GIVEN: The player is in a place where they can pet things
    adventure.PLAYER["place"] = "somewhere"
    adventure.PLACES["somewhere"] = {
        "name": "Somewhere out there",
        "can": ["pet"],
    }

    # WHEN: the player types "pet" with no arguments
    do_pet([])
    output = capsys.readouterr().out

    # THEN: an error message should be printed
    assert "What do you want to pet" in output

B. In adventure.py modify do_pet(): ensure args

Need help?

1. [ ] Check if args is empty. If so:

   • [ ] Print an error message like "What do you want to pet?"

   • [ ] return

do_pet()

Listing 796 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

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

Part 14.4: Ensure color

adventure.py test_game.py

This command is a little different from previous commands, because we want the player to be able to type a few different things.

We expect the player to type something like:

pet red dragon

But we would also accept:

pet red dragon head

Or:

pet red head

Or even:

pet red

Demo

So we’ll need to make sure that the player typed something in addition to "dragon" and "head" and that it is a valid color.

A. In test_game.py define test_do_pet_no_color()

In this section we’ll write a test_do_pet_no_color() test. It should check that the player typed something in addition to "dragon" and/or "head".

Need help?

1. GIVEN: The player is in a place where they can pet things

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be a list containing the string "pet"

2. WHEN: the player types “pet” without typing a color

…

• [ ] Call do_pet() with a list containing the words "dragon" and/or "head"

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

3. THEN: an error message should be printed

…

• [ ] assert that an error message like "What do you want to pet" is in output

4. Run your tests. They should fail.

test_do_pet_no_color()

Listing 797 test_game.py

def test_do_pet_no_color(capsys):
    # GIVEN: The player is in a place where they can pet things
    adventure.PLAYER["place"] = "somewhere"
    adventure.PLACES["somewhere"] = {
        "name": "Somewhere out there",
        "can": ["pet"],
    }

    # WHEN: the player types "pet" with only the words "dragon" and/or "head"
    do_pet(["dragon", "head"])
    output = capsys.readouterr().out

    # THEN: an error message should be printed
    assert "What do you want to pet" in output

B. In adventure.py modify do_pet(): remove ignored args

To support extra words like "dragon" and "head", we’re simply going to remove them from args.

If we do this before we check to make sure that args is not empty, then we’ll get the same error message if they type pet as when they type pet dragon.

Need help?

Do this before the line with if not args:

1. [ ] Make a list of allowed words like ["dragon", "head"] and iterate over it. For each one:

   • [ ] Check if the word is in args. If so:

     • [ ] Remove it from args

2. [ ] Run your tests. They should pass.

do_pet()

Listing 798 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

    # remove the expected words from args
    for word in ["dragon", "head"]:
        if word in args:
            args.remove(word)

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

C. In test_game.py define test_do_pet_invalid_color()

We’ll add a new test test_do_pet_invalid_color() to make sure the color is valid. We’ll use a global variable adventure.COLORS to store the list of valid colors.

Need help?

1. GIVEN: There are three colors of dragon heads

…

• [ ] Assign adventure.COLORS to a list of colors

1. AND: The player is in a place where they can pet things

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be an empty list.

2. WHEN: They try to pet a dragon with a color that doesn’t exist

…

• [ ] Call do_pet() with a list containing the a word that is not a color

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

3. THEN: an error message should be printed

…

• [ ] assert that an error message like "I don't see that dragon" is in output

4. Run your tests. They should fail.

test_do_pet_invalid_color()

Listing 799 test_game.py

def test_do_pet_invalid_color(capsys):
    # GIVEN: There are three colors of dragon heads
    adventure.COLORS = ["red", "green", "blue"]

    # AND: The player is in a place where they can pet dragons
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"],
    }

    # WHEN: They try to pet a dragon with a color that doesn't exist
    do_pet(["purple"])
    output = capsys.readouterr().out

    # THEN: An error message should be printed
    assert "I don't see a dragon" in output

D. In adventure.py add COLORS

At the top of your script where your other global variables are, add a new global variable COLORS and set it to a list with three colors in it.

COLORS

Listing 800 adventure.py

import textwrap

from console import fg, fx
from console.progress import ProgressBar
from console.screen import sc
from console.utils import clear_line

WIDTH = 45

MARGIN = 2

DEBUG = True

MAX_HEALTH = 100

BAR = ProgressBar(
    total=(MAX_HEALTH + 0.1),
    width=(WIDTH - len("Health") - len("100%")),
    clear_left=False,
)

# ## Game World Data #########################################################

COLORS = ["red", "black", "silver"]

E. In adventure.py modify do_pet(): ensure valid color

We can now assume that anything left in the args list is the color. We’ll check that it is in the COLORS list, or print an error message if it is not.

Need help?

1. [ ] Assign the first item from args to the variable color

2. [ ] Check to make sure that color is in the list of COLORS. If not:

   • [ ] Print an error message like: "I don't see a dragon head that looks like that."

   • [ ] return

do_pet()

Listing 801 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

    # remove the expected words from args
    for word in ["dragon", "head"]:
        if word in args:
            args.remove(word)

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

    color = args[0].lower()

    # make sure they typed in a real color
    if color not in COLORS:
        error("I don't see a dragon that looks like that.")
        return

Part 14.5: Pick a dragon

adventure.py test_game.py

In this section we’ll randomly pick a dragon mood and print a debug message about it.

We’ll make a global list DRAGONS to store information about each dragon in dictionaries. We’ll add more to this later, but for now each dictionary just needs a single key "mood" with a string for the dragon’s mood, for example "cheerful".

Demo

Then when the player pets one of the dragon’s heads, randomly select one of the dragon dictionaries and print a debug message that says which dragon was selected.

A. In test_game.py define test_do_pet_cheerful_dragon()

In this section we’ll start a test for when the player pets a cheerful dragon head and simply assert that a debug message was printed.

In order to make sure we always get the cheerful dragon in the test, we’ll set COLORS and DRAGONS to only contain one color and dragon dictionary respectively.

Need help?

1. GIVEN: The player is in a place where they can pet a dragon

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be a list containing the string "pet"

2. AND: There is one color of dragon heads

…

• [ ] Assign adventure.COLORS to a list containing one color

3. AND: There is one dragon

…

• [ ] Assign adventure.DRAGONS to a list containing one dictionary. The dictionary should have the key "mood" and the string "cheerful" for the value.

4. WHEN: The player pets that head

…

• [ ] Call do_pet() with a list that contains the same color that is in COLORS

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

5. THEN: A debug message should print

…

• [ ] assert that an debug message like "You picked the dragon's cheerful red head." is in output

6. Run your tests. They should fail.

test_do_pet_cheerful_dragon()

Listing 802 test_game.py

def test_do_pet_cheerful_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["red"]

    # AND: There is one dragon
    adventure.DRAGONS = [
        {"mood": "cheerful"}
    ]

    # WHEN: The player pets that head
    do_pet(["red", "dragon"])
    output = capsys.readouterr().out

    # THEN: A debug message should print
    assert "You picked the cheerful red dragon." in output

B. At the top of adventure.py: import random

In order to randomly select a dragon dictionary from DRAGONS we’ll need to import the random module.

Need help?

1. [ ] import the random module

Code

Listing 803 adventure.py

import random
import textwrap

from console import fg, fx
from console.progress import ProgressBar
from console.screen import sc

C. At the top of adventure.py: add DRAGONS

Add the global variable DRAGONS and assign it to a list where each item is a dictionary containing information about each of the dragon’s heads. For now each dictionary will only have one key "mood".

Add three dragon dictionaries for the moods "cheerful", "grumpy" and "lonely".

Need help?

1. [ ] Create global variable DRAGONS and assign it to a list. The list should contain:

   • [ ] Three dictionaries. Each dictionary should contain:

     • [ ] The key "mood" and string with the mood of that dragon, ie "cheerful"

COLORS

Listing 804 adventure.py

COLORS = ["red", "black", "silver"]

DRAGONS = [
    {"mood": "cheerful"},
    {"mood": "grumpy"},
    {"mood": "lonely"},
]

PLAYER = {
    "place": "home",
    "inventory": {"gems": 50},
    "health": MAX_HEALTH,
}

D. In adventure.py modify do_pet()

In this section we’ll randomly select one of the dragons from DRAGONS using the random.choice() function. We’ll add the "color" that the player selected to that dictionary, then print a debug message with information about the dragon.

Need help?

1. [ ] Call random.choice() with the argument DRAGONS and assign it to the variable dragon.

2. [ ] Set dragon["color"] to color

3. [ ] Print a debug message like "You picked the dragon's MOOD COLOR head."

do_pet()

Listing 805 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

    # remove the expected words from args
    for word in ["dragon", "head"]:
        if word in args:
            args.remove(word)

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

    color = args[0].lower()

    # make sure they typed in a real color
    if color not in COLORS:
        error("I don't see a dragon that looks like that.")
        return

    # get the dragon info for this color
    dragon = random.choice(DRAGONS)
    dragon["color"] = color

    debug(f"You picked the {dragon['mood']} {dragon['color']} dragon.")

Part 14.6: Treasure

adventure.py test_game.py

In this section we’re going to write the code so that some of the dragons will give the player gems.

In order to do this we’ll add a "treasure" key to some of the dragon dictionaries DRAGONS. The value will be a tuple containing the minimum and maximum possible gems that a particular dragon might give.

Demo

Then in the do_pet() function we’ll retrieve the range of possible treasure from the dragon dictionary, randomly pick a number in that range, then add that amount the player gems and print a message to tell the player what happened.

A. In test_game.py modify test_do_pet_cheerful_dragon()

In this section we’ll modify the test_do_pet_cheerful_dragon() test to add the "treasure" key to the single dictionary in DRAGONS, and a tuple containing two numbers (the minimum and maximum possible treasure) as the value.

Then we’ll need to check that the number if gems in the player’s inventory was increased.

Need help?

1. Modify AND: There is one dragon

…

• [ ] Add a "treasure" key to the dragon dictionary in DRAGONS for

  • [ ] The key should be "treasure"

  • [ ] The value should a tuple with two numbers representing the minimum and maximum possible treasure. ie (10, 20).

Tip

If we want to know the exact treasure amount you can use the same number for the minimum and maximum, for example: (10, 10).

2. After WHEN add AND: The player has some gems

…

• [ ] Set the "gems" in PLAYER inventory to a number

3. After THEN add AND: The player should get treasure

…

• [ ] assert that the gems in PLAYER inventory is more than it was before

4. After THEN add AND: The player should see a message about what happened

…

• [ ] assert a message like "gave you GEMS gems" is in output

5. Run your tests. They should fail.

test_do_pet_cheerful_dragon()

Listing 806 test_game.py

def test_do_pet_cheerful_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["red"]

    # AND: There is one dragon who gives you treasure
    adventure.DRAGONS = [{
        "mood": "cheerful",
        "treasure": (10, 10),
    }]

    # AND: The player has some gems
    adventure.PLAYER["inventory"] = {"gems": 10}

    # WHEN: The player pets that head
    do_pet(["red", "dragon"])
    output = capsys.readouterr().out

    # THEN: A debug message should print
    assert "You picked the cheerful red dragon." in output

    # AND: The player should get treasure
    assert adventure.PLAYER["inventory"]["gems"] == 20

    # AND: The player should see a message about what happened
    assert "10 gems" in output

B. In adventure.py modify DRAGONS

Modify the dragon dictionaries in the DRAGONS list to add "treasure" tuples for the "cheerful" and "lonely" dragons.

Need help?

• [ ] Add a "treasure" key to the single dictionary in DRAGONS list for the "cheerful" and "lonely" dragons

  • [ ] The key should be "treasure"

  • [ ] The value should a tuple with two numbers representing the minimum and maximum amount of treasure. ie (10, 20).

DRAGONS

Listing 807 adventure.py

DRAGONS = [
    {
        "mood": "cheerful",
        "treasure": (3, 15),
    },
    {
        "mood": "grumpy",
    },
    {
        "mood": "lonely",
        "treasure": (8, 25),
    },
]

B. In adventure.py modify do_pet()

In this section we’ll retrieve the range of possible treasure from the dragon dictionary (if the "treasure" key exists) then use the two numbers in the random.randint() function to get the number of gems to give the player.

Then we’ll add that number of gems to the player’s inventory and print a message about it.

See also

For how to pass all iterable items as arguments to a function see Functions > Unpacking.

Need help?

1. [ ] Use the .get() method on the dragon dictionary to get the value for the "treasure" key and assign the result to possible_treasure. Since not all dragons will have the "treasure" key, use the second argument in .get() to set the default value to (0, 0).

2. [ ] Pass the minimum and maximum numbers from possible_treasure as arguments to the random.randint() function and assign the results to dragon["gems"].

3. [ ] Use the inventory_change() function to add dragon["gems"] to the players inventory.

4. [ ] Print a message like: "The dragon's MOOD head gave you GEMS gems."

do_pet()

Listing 808 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

    # remove the expected words from args
    for word in ["dragon", "head"]:
        if word in args:
            args.remove(word)

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

    color = args[0].lower()

    # make sure they typed in a real color
    if color not in COLORS:
        error("I don't see a dragon that looks like that.")
        return

    # get the dragon info for this color
    dragon = random.choice(DRAGONS)
    dragon["color"] = color

    debug(f"You picked the dragon's {dragon['mood']} {dragon['color']} head.")

    # calculate the treasure
    possible_treasure = dragon.get("treasure", (0, 0))
    dragon["gems"] = random.randint(*possible_treasure)

    # add the treasure to the players inventory
    inventory_change("gems", dragon["gems"])

    # print a message about gems
    if dragon["gems"]:
        write(f"The dragon's {dragon['mood']} head gave you {dragon['gems']} gems.")

Part 14.7: Damage

adventure.py test_game.py

In this section we’re going to write the code so that some of the dragons will cause the player damage.

In order to do this we’ll add a "damage" key to some of the dragon dictionaries DRAGONS. The value will be a tuple containing the minimum and maximum possible damage that a particular dragon might cause.

Demo

Then in the do_pet() function we’ll retrieve the range of possible damage from the dragon dictionary, randomly pick a number in that range, then subtract that amount the player health and print a message to tell the player what happened.

A. In test_game.py modify test_do_pet_cheerful_dragon()

In this section we’ll modify the test_do_pet_cheerful_dragon() test to make sure that the player’s health does not change.

Need help?

1. After WHEN add AND: The player has a certain amount of health

…

• [ ] Set “health” value in the PLAYER dictionary to a number like 90

2. After THEN add AND: The player’s health should be the same

…

• [ ] Assert that PLAYER["health"] is the same as it was before

3. Run your tests. They should pass.

test_do_pet_cheerful_dragon()

Listing 809 test_game.py

def test_do_pet_cheerful_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["red"]

    # AND: There is one dragon who gives you treasure
    adventure.DRAGONS = [{
        "mood": "cheerful",
        "treasure": (10, 10),
    }]

    # AND: The player has some gems
    adventure.PLAYER["inventory"] = {"gems": 10}

    # AND: The player has a certain amount of health
    adventure.PLAYER["health"] = 90

    # WHEN: The player pets that head
    do_pet(["red", "dragon"])
    output = capsys.readouterr().out

    # THEN: A debug message should print
    assert "You picked the cheerful red dragon." in output

    # AND: The player should get treasure
    assert adventure.PLAYER["inventory"]["gems"] == 20

    # AND: The player's health should be the same
    assert adventure.PLAYER["health"] == 90

    # AND: The player should see a message about what happened
    assert "10 gems" in output

B. In test_game.py define test_do_pet_cranky_dragon()

In this section we’ll define the test_do_pet_cranky_dragon() test. It will be very similar to test_do_pet_cheerful_dragon(), except in the DRAGONS dictionary we’ll add a dragon dictionary that has a "damage" key with a tuple of two negative numbers and we’ll assert that PLAYER["health"] has decreased.

Need help?

1. GIVEN: The player is in a place where they can pet a dragon

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be a list containing the string "pet"

2. AND: There is one color of dragon heads

…

• [ ] Assign adventure.COLORS to a list containing one color

3. AND: There is one dragon who causes damage

…

• [ ] Assign adventure.DRAGONS to a list containing one dictionary that contains:

  • [ ] the key "mood" and the string "cranky" for the value.

  • [ ] the key "damage" and a tuple with two negative numbers for the value

4. AND: The player has a certain amount of health

…

• [ ] Set "health" in the PLAYER dictionary to a number greater than 0 and less than 100

5. AND: The player has some gems

…

• [ ] Set "gems" in the PLAYER["inventory"] dictionary to a positive number

6. WHEN: The player pets that head

…

• [ ] Call do_pet() with a list that contains the same color that is in COLORS

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

7. THEN: A debug message should print

…

• [ ] assert that an debug message like "You picked the dragon's cranky red head." is in output

8. AND: The player’s health should be reduced

…

• [ ] assert that the PLAYER["health"] is less than it was before

9. AND: The player’s gems should not be changed

…

• [ ] assert that the PLAYER["inventory"]["gems"] is the same as it was before

10. AND: The player should see a message about what happened

…

• [ ] assert that an debug message like "caused you DAMAGE" damage is in output

11. Run your tests. They should fail.

test_do_pet_cranky_dragon()

Listing 810 test_game.py

def test_do_pet_cranky_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["red"]

    # AND: There is one dragon who causes damage
    adventure.DRAGONS = [{
        "mood": "cranky",
        "damage": (-10, -10),
    }]

    # AND: The player has a certain amount of health
    adventure.PLAYER["health"] = 100

    # AND: The player has some gems
    adventure.PLAYER["inventory"] = {"gems": 10}

    # WHEN: The player pets that head
    do_pet(["red", "head"])
    output = capsys.readouterr().out

    # THEN: A debug message should print
    assert "You picked the cranky red dragon." in output

    # AND: The player's health should be reduced
    assert adventure.PLAYER["health"] == 90

    # AND: The player's gems should not be changed
    assert adventure.PLAYER["inventory"]["gems"] == 10

    # AND: The player should see a message about what happened
    assert "-10 damage" in output

C. In adventure.py modify DRAGONS

Modify the dragon dictionaries in the DRAGONS list to add "damage" tuples for the "cranky" and "lonely" dragons.

Need help?

• [ ] Add a "damage" key to the single dictionary in DRAGONS list for the "cranky" and "lonely" dragons

  • [ ] The key should be "damage"

  • [ ] The value should a tuple with two numbers representing the minimum and maximum amount of damage. ie (-20, -10).

DRAGONS

Listing 811 adventure.py

DRAGONS = [
    {
        "mood": "cheerful",
        "treasure": (3, 15),
    },
    {
        "mood": "grumpy",
        "damage": (-15, -3),
    },
    {
        "mood": "lonely",
        "treasure": (8, 25),
        "damage": (-25, -8),
    },
]

D. In adventure.py modify do_pet()

In this section we’ll retrieve the range of possible damage from the dragon dictionary (if the "damage" key exists) then use the two numbers in the random.randint() function to get the number of gems to give the player.

Then we’ll add that number of gems to the player’s inventory and print a message about it.

Need help?

1. [ ] Use the .get() method on the dragon dictionary to get the value for the "damage" key and assign the result to possible_damage. Since not all dragons will have the "damage" key, use the second argument in .get() to set the default value to (0, 0).

2. [ ] Pass the minimum and maximum numbers from possible_damage as arguments to the random.randint() function and assign the results to dragon["health"].

3. [ ] Use the health_change() function to subtract dragon["health"] from the players health.

4. [ ] Print a message like: "The dragon's MOOD head caused you HEALTH damage."

do_pet()

Listing 812 adventure.py

def do_pet(args):
    """Pet dragons"""

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

    # make sure they are somewhere they can pet dragons
    if not place_can("pet"):
        error("You can't do that here.")
        return

    # remove the expected words from args
    for word in ["dragon", "head"]:
        if word in args:
            args.remove(word)

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

    color = args[0].lower()

    # make sure they typed in a real color
    if color not in COLORS:
        error("I don't see a dragon that looks like that.")
        return

    # get the dragon info for this color
    dragon = random.choice(DRAGONS)
    dragon["color"] = color

    debug(f"You picked the dragon's {dragon['mood']} {dragon['color']} head.")

    # calculate the treasure
    possible_treasure = dragon.get("treasure", (0, 0))
    dragon["gems"] = random.randint(*possible_treasure)

    # calculate the damage
    possible_damage = dragon.get("damage", (0, 0))
    dragon["health"] = random.randint(*possible_damage)

    # add the treasure to the players inventory
    inventory_change("gems", dragon["gems"])

    # reduce health
    health_change(dragon["health"])

    # print a message about gems
    if dragon["gems"]:
        write(f"The dragon's {dragon['mood']} head gave you {dragon['gems']} gems.")

    # print a message about damage
    if dragon["health"]:
        write(f"The dragon's {dragon['mood']} head causes you {dragon['health']} damage.")

E. In test_game.py define test_do_pet_lonely_dragon()

In this section we’ll define the test_do_pet_lonely_dragon() test. It will be just like combining the test for a "cheerful" dragon and a "cranky" dragon.

That is, the dragon dictionary in DRAGONS should have both "treasure" and "damage".

Need help?

1. GIVEN: The player is in a place where they can pet a dragon

…

• [ ] Change PLAYER to put the player in a fake place

• [ ] Add a matching fake place dictionary to PLACES. The "can" key should be a list containing the string "pet"

2. AND: There is one color of dragon heads

…

• [ ] Assign adventure.COLORS to a list containing one color

3. AND: There is one dragon who causes damage and gives treasure

…

• [ ] Assign adventure.DRAGONS to a list containing one dictionary that contains:

  • [ ] the key "mood" and the string "cranky" for the value.

  • [ ] the key "treasure" and a tuple with two positive numbers for the value

  • [ ] the key "damage" and a tuple with two negative numbers for the value

4. AND: The player has a certain amount of health

…

• [ ] Set "health" in the PLAYER dictionary to a number greater than 0 and less than 100

5. AND: The player has some gems

…

• [ ] Set "gems" in the PLAYER["inventory"] dictionary to a positive number

6. WHEN: The player pets that head

…

• [ ] Call do_pet() with a list that contains the same color that is in COLORS

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

7. THEN: A debug message should print

…

• [ ] assert that an debug message like "You picked the dragon's lonely red head." is in output

8. AND: The player’s health should be reduced

…

• [ ] assert that the PLAYER["health"] is less than it was before

9. AND: The player should get treasure

…

• [ ] assert that the PLAYER["inventory"]["gems"] is more than it was before

10. AND: The player should see a message about what happened

…

• [ ] assert that an debug message like samp"caused you {HEALTH}" damage is in output

11. Run your tests. They should pass.

test_do_pet_lonely_dragon()

Listing 813 test_game.py

def test_do_pet_lonely_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["blue"]

    # AND: There is one dragon who gives treasure and causes damage
    adventure.DRAGONS = [{
        "mood": "lonely",
        "damage": (-10, -10),
        "treasure": (20, 20),
    }]

    # AND: The player has a certain amount of health
    adventure.PLAYER["health"] = 100

    # AND: The player has a certain number of gems
    adventure.PLAYER["gems"] = 10

    # WHEN: The player pets that head
    do_pet(["blue", "head"])
    output = capsys.readouterr().out

    # THEN: A debug message should print
    assert "You picked the lonely blue dragon." in output

    # AND: The player's health should be reduced
    assert adventure.PLAYER["health"] == 90

    # AND: The player should get treasure
    assert adventure.PLAYER["inventory"]["gems"] > 10

    # AND: The player should see a message about what happened
    assert "20 gems" in output
    assert "-10 damage" in output

Part 14.8: Pet the dragon

adventure.py test_game.py

In this section we’ll add a description of what happens when you pet a dragon’s head, pausing between each line to give it a sense of drama.

Demo

A. At the top of adventure.py: import sleep from time

In order to add a pause for effect in between lines in the action description, we’ll need to import the sleep function from the time module.

Need help?

1. [ ] import the sleep function from the time module

Code

Listing 814 adventure.py

from time import sleep

from console import fg, fx
from console.progress import ProgressBar

B. At the top of adventure.py: add DELAY

At the top of your script where your other global variables are, add a new global variable DELAY and set it to a number that will be the number of seconds to pause for effect.

Need help?

1. [ ] Set DELAY to a number like 1

DELAY

Listing 815 adventure.py

WIDTH = 45

MARGIN = 2

DEBUG = True

DELAY = 1.25

MAX_HEALTH = 100

C. Modify do_pet(): add action description with delay

In this section we’re going to add a description of what happens when the player pets the dragon’s head. To make it a little more exciting, we’ll split the description onto multiple strings in a tuple. Something like:

• "You slowly creep forward..."

• "...gingerly reach out your hand..."

• "...and gently pat the dragon's COLOR head."

• "..."

• "He blinks sleepy eyes and peers at you..."

Before printing the messages about gems and damage, we’ll iterate over the sentences tuple. In each iteration we’ll print a blank line, print the string, and call sleep() with the argument DELAY.

Finally we’ll print one blank line at the end.

Need help?

1. [ ] Create a tuple (or list) assigned to sentences that contains the three strings from above.

2. [ ] Above the messages about gems and damage are printed, use a for loop to iterate over sentences with the variable text. In each iteration:

   • [ ] Print a blank line.

   • [ ] Use the write() function to print text.

   • [ ] Call sleep() with the argument DELAY.

3. [ ] Print a blank line.

4. [ ] Play your game and see how it looks!

do_pet()

Listing 816 adventure.py: do_pet()

    # get the dragon info for this color
    dragon = random.choice(DRAGONS)
    dragon["color"] = color

    debug(f"You picked the dragon's {dragon['mood']} {dragon['color']} head.")

    # calculate the treasure
    possible_treasure = dragon.get("treasure", (0, 0))
    dragon["gems"] = random.randint(*possible_treasure)

    # calculate the damage
    possible_damage = dragon.get("damage", (0, 0))
    dragon["health"] = random.randint(*possible_damage)

    # add the treasure to the players inventory
    inventory_change("gems", dragon["gems"])

    # reduce health
    health_change(dragon["health"])

    sentences = (
        "You slowly creep forward...",
        "...gingerly reach out your hand...",
        f"...and gently pat the dragon's {color} head.",
        "...",
        "He blinks sleepy eyes and peers at you...",
    )

    for text in sentences:
        print()
        write(text)
        sleep(DELAY)

    print()

    # print a message about gems
    if dragon["gems"]:
        write(f"The dragon's {dragon['mood']} head gave you {dragon['gems']} gems.")

    # print a message about damage
    if dragon["health"]:
        write(f"The dragon's {dragon['mood']} head causes you {dragon['health']} damage.")

D. At the top of test_game.py: set adventure.DELAY

If you were to run your tests now, you would find that all of the test_do_pet_* tests run an awful lot slower. That’s because do_pet() calls sleep() in the tests just like it does in the game.

To avoid this problem, simply set adventure.DELAY to 0 near the top of your test file. Unlike the changes that we make in a GIVEN portion of a test, we only need to set adventure.DELAY once. Put it just under where you assign all of the *_STATE global variables.

Need help?

1. [ ] Find where you assign PLAYER_STATE, DEBUG_STATE, etc. Just under that set adventure.DELAY to 0

2. [ ] Run your tests. They should pass and be as fast as usual.

Code

Listing 817 test_game.py

def setup_module(module):
    """Initialize global state variables. Should be run once."""
    global PLAYER_STATE, PLACES_STATE, ITEMS_STATE, DEBUG_STATE

    PLAYER_STATE = deepcopy(adventure.PLAYER)
    PLACES_STATE = deepcopy(adventure.PLACES)
    ITEMS_STATE = deepcopy(adventure.ITEMS)
    DEBUG_STATE = True
    adventure.DELAY = 0

Part 14.9: Better messages

adventure.py test_game.py

In this section we’ll make nicer and more detailed messages for when each dragon causes damage or gives treasure.

To do this we’ll add a "message" key to each dragon dictionary in DRAGONS, which will have the end of the message for a value.

Demo

For example, say we want the message to be:

"The happy green dragon thinks you're great and gives you 100 gems!"

Then the "message" value would be:

"thinks you're great and gives you {gems} gems!"

It’s important to note that value should contain the f-string style variables {gems} and/or {damage}, but it should not actually be an f-string.

That way we can attach it to the beginning of the message in do_pet(), then call the .format() method on the resulting string to fill in all the variable values.

A. Modify test_do_pet_*_dragon(): add "message" to DRAGONS

In this section we’ll modify the three test_do_pet_*_dragon() tests to add the "message" key to the single dictionary in DRAGONS with the value bing a string that contains the f-string style variables {gems} and/or {health}.

Need help?

1. Modify AND: There is one dragon who gives you treasure

…

• [ ] Add the key "message" to the single dictionary in DRAGONS with the value:

  • [ ] A string that is not an f-string but contains the f-string style variables {gems} and/or {health}.

    It should be the part of the message that comes after "The dragon's MOOD COLOR head" and describes what the dragon does after the player pets it.

2. Run your tests. They should pass.

test_do_pet_cheerful_dragon()

Listing 818 test_game.py

def test_do_pet_cheerful_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["red"]

    # AND: There is one dragon who gives you treasure
    adventure.DRAGONS = [{
        "mood": "cheerful",
        "treasure": (10, 10),
        "message": "likes you and gives you {gems} gems.",
    }]

test_do_pet_cranky_dragon()

Listing 819 test_game.py

def test_do_pet_cranky_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["red"]

    # AND: There is one dragon who causes damage
    adventure.DRAGONS = [{
        "mood": "cranky",
        "damage": (-10, -10),
        "message": "pushes you away causing you {health} damage",
    }]

test_do_pet_lonely_dragon()

Listing 820 test_game.py

def test_do_pet_lonely_dragon(capsys):
    # GIVEN: The player is in a place where they can pet a dragon
    adventure.PLAYER["place"] = "cave"
    adventure.PLACES["cave"] = {
        "name": "A cave",
        "can": ["pet"]
    }

    # AND: There is one color of dragon heads
    adventure.COLORS = ["blue"]

    # AND: There is one dragon who gives treasure and causes damage
    adventure.DRAGONS = [{
        "mood": "lonely",
        "damage": (-10, -10),
        "treasure": (20, 20),
        "message": "throws {gems} gems at you causing you {health} damage",
    }]

B. In adventure.py modify DRAGONS: add "message"

Modify the dragon dictionaries in the DRAGONS list to add "message" string for all three dragons.

Need help?

• [ ] Add the key "message" to the all three dragon dictionaries in DRAGONS with the value:

  • [ ] A string that is not an f-string but contains the f-string style variables {gems} and/or {health}.

    It should be the part of the message that comes after "The dragon's MOOD COLOR head " and describes what the dragon does after the player pets it.

DRAGONS

Listing 821 adventure.py

DRAGONS = [
    {
        "mood": "cheerful",
        "treasure": (3, 15),
        "message": "thinks you're adorable! He gives you {gems} gems!"
    },
    {
        "mood": "grumpy",
        "damage": (-15, -3),
        "message": (
            "wants to be left alone. The heat from his mighty sigh "
            "singes your hair, costing you {health} in health."
        ),
    },
    {
        "mood": "lonely",
        "treasure": (8, 25),
        "damage": (-25, -8),
        "message": (
            "is just SO happy to see you! He gives you a whopping "
            "{gems} gems! Then he hugs you, squeezes you, and calls "
            "you George... costing you {health} in health."
        )
    },
]

C. Modify do_pet(): print the message

See also

• String Formatting > str.format() method

• Functions > Unpacking > Mappings – for how to pass all dictionary key value pairs as keyword arguments to a function see

Now we’ll combine the beginning of the message "The dragon's {mood} {color} head " with the string from dragon["message"].

Since the dragon dictionary already has the information about mood, color, and gems and/or health, we can call .format() on the resulting string and pass the whole dictionary as keyword arguments. That will fill in all those variables with their corresponding values from the dictionary.

Then we can replace the lines where we print the two old messages with a line printing the new message, wrapped.

Need help?

1. [ ] Remove the lines where you print the messages about gems and damage.

2. [ ] Concatonate the string "The dragon's {mood} {color} head " with dragon["message"] and assign the result to the variable tpl.

3. [ ] Call the .format() method on tpl and pass all key-value pairs from the dragon dictionary as keyword arguments. Assign the result to text.

4. [ ] Use the wrap() function to print text.

5. [ ] Run your tests. They should pass.

do_pet()

Listing 822 adventure.py: do_pet()

    # get the dragon info for this color
    dragon = random.choice(DRAGONS)
    dragon["color"] = color

    debug(f"You picked the dragon's {dragon['mood']} {dragon['color']} head.")

    # calculate the treasure
    possible_treasure = dragon.get("treasure", (0, 0))
    dragon["gems"] = random.randint(*possible_treasure)

    # calculate the damage
    possible_damage = dragon.get("damage", (0, 0))
    dragon["health"] = random.randint(*possible_damage)

    # add the treasure to the players inventory
    inventory_change("gems", dragon["gems"])

    # reduce health
    health_change(dragon["health"])

    sentences = (
        "You slowly creep forward...",
        "...gingerly reach out your hand...",
        f"...and gently pat the dragon's {color} head.",
        "...",
        "He blinks sleepy eyes and peers at you...",
    )

    for text in sentences:
        print()
        write(text)
        sleep(DELAY)

    print()

    # generate the message
    tpl = "The dragon's {mood} {color} head " + dragon["message"]
    text = tpl.format(**dragon)
    wrap(text)

Part 14.10: Add dragon

adventure.py test_game.py

Finally, we’ll add the dragon itself as an item in your cave so the player can examine it to find out the colors of each dragon head.

Demo

A. In adventure.py modify ITEMS

In your ITEMS dictionary, add a "dragon" key. Use the global variable COLORS in the description to list the colors of the dragon heads.

ITEMS

Listing 823 adventure.py

    "dragon": {
        "key": "dragon",
        "name": "a three-headed dragon",
        "description": (
            f"A colossal dragon with heads of {', '.join(COLORS[0:-1])}, "
            f"and {COLORS[2]}."
        ),
    },

B. In adventure.py modify PLACES

COLORS

Listing 824 adventure.py

    "cave": {
        "key": "cave",
        "name": "A cave",
        "north": "hill",
        "description": (
            "Your footsteps echo as you step into the vast cavern.",
            "Shafts of sunlight slice through the gloom, playing against the "
            "landscape of glittering treasure.",
            "Resting atop a mound of gold, a colossal dragon rests curled up snugly. "
            "Its three enormous heads snore softly, each in turn.",
        ),
        "items": ["dragon"],
        "can": ["pet"],
    },