7.05 project.md rewrite. Use if you want to.

[jdonwells]

I found the project.md for the Unit 7 project hard to use. So I rewrote it. Presented here for comment or reuse. It should be noted that I added a fifth lesson to Unit 7 covering Double Dispatch. #390

---

Project 7: Pokemon

Overview

In this project, we will be creating a basic implementation of a Pokemon game. This project will use objects. The Pokemon classes, the Player classes, and the Attack class. We will be using a type of Double Dispatch instead of a game loop.

You will be given most of the game code. You will then need to finish it. Because most of the code is already done you should expect to read the code and figure out how it works more than type in new code. To understand the starter code you may need to make a model of it.

Game Play and Rules

Begining the Game

• Before the battle begins, Ask the user for a name.
• Ask the user to choose 3 Pokemon from a list of 9 available.
• Each Pokemon will have a name, a type, maximum health, and attack power. (See the Pokemon section for details.)
• Each Pokemon is unique and can only be chosen once.
• From the 3 Pokemon chosen, ask the user to select one Pokemon to use as the current Pokemon.
• Generate Computer's Hand randomly. The computer must choose 3 from the remaining 6 Pokemon. Also without duplicates.
• The computer will randomly select a pokemon to be the current Pokemon.

The Game

• The current Pokemon will be able to attack, heal, and also take damage.
• On each turn the user or computer can either attack (a), heal (h), switch (s), or show the current status of all Pokemon (p). (The computer doesn't need to choose p.)
• a, h, or s consume one turn. p does not consume a turn. After printing the status the player will be asked to make another choice.
• At the end of each turn test if the other player has lost the game. Print an appropriate message and stop the game.
• A player has lost if all their Pokemon are out of health (health <= 0).
• Here is what each of the 4 actions does.
  • switch: Lists the stats (name, health, and attack power) of all 3 Pokemon the player has. Asks the user which Pokemon they would like to switch to.
  • Pokemon: Lists all the stats of all the Pokemon held by both players.
  • Heal: adds 20 hp to the current Pokemon. This may not exceed the original health maximum.
  • attack: lists all attacks of the current Pokemon. Prompts the user to pick an attack. Damage is then calculated and applied to the other player.
• Damage is calculated as follows.
  • 0 if the attack misses. Use the accuracy percentage to randomly determine hit and miss.
  • Maximum damage is the Pokemon's attack power times the Attack's attack power percentage. Divide by 100 if appropriate and round to an int.
  • Randomly choose an integer damage between 1 and maximum damage. randint() is a good way to do that.
  • Increase damage by 50% based on pokemon type. Each Pokemon is strong against another Pokemon but weak to yet another Pokemon. This mechanic is similar to Rock Paper Scissors.
    • Grass attacking water adds extra damage.
    • Water attacking fire adds extra damage.
    • Fire attacking grass adds extra damage.
• If a Pokemon is knocked out (health <= 0) the player will be forced to choose switch as their next turn. This is not a free turn.

Pokemon Status report

The Pokemon status (p) report should look something like this:

Joe attacking with Bulbasaur
Pokemon are:
   Bulbasaur (grass) with health 60 and attack 40.
   Charmander (fire) with health 30 and attack 70.
   Poliwag (water) with health 50 and attack 50.

Lysandre attacking with Ninetails
Pokemon are:
   Ninetails (fire) with health 50 and attack 50.
   Oddish (grass) with health 50 and attack 50.
   Bellsprout (grass) with health 40 and attack 60.

Player Joe your move.

Ending the Game

• The game ends when one player has no Pokemon with health remaining.
• Print the Pokemon status like the p command.
• Print a message reporting which player has won.

Computer Player

The computer player will select between three of the four commands available. Pokemon status (p) makes no sense for a computer player to choose. 2/3 of the time the computer player should attack. 1/6 of the time the computer should heal and 1/6 of the time the computer should switch pokemon.

You can implement the above probabilities by simply using choice(['a', 'a', 'a', 'a', 'h', 's'] and treating that as a command choice. If the computer player decides to switch (s) do not allow the choice of a knocked-out Pokemon.

Pokemon

There are 9 Pokemon. 3 Pokemon of each of the 3 types:

1. Grass Type:

   • Bulbasoar: 60 health, 40 attack power
   • Bellsprout: 40 health, 60 attack power
   • Oddish: 50 health, 50 attack power

2. Fire Type:

   • Charmander: 30 health, 70 attack power
   • Ninetails: 50 health, 50 attack power
   • Ponyta: 40 health, 60 attack power

3. Water Type:

   • Squirtle: 80 health, 20 attack power
   • Psyduck: 70 health, 30 attack power
   • Polywag: 50 health, 50 attack power

Pokemon Attacks

All Pokemon of the same type have the same set of attacks. Each attack has attributes name, attack power percentage, and accuracy percentage.

Grass Type

All grass types have the following attacks:

• Leaf Storm: 150% Power, 33% accurate.
• Mega Drain: 50% Power, 100% accurate.
• Razor Leaf: 100% Power, 50% accurate.
• Grass Type is 1.5x stronger against Water Type.

Fire Type

All fire types have the following attacks:

• Ember: 50% Power, 100% accurate.
• Fire Punch: 70% Power, 70% accurate.
• Flame Wheel: 100% Power, 50% accurate.
• Fire Type is 1.5x stronger against Grass.

Water Type

All fire types have the following attacks:

• Bubble: 50% Power, 100% accurate.
• Hydro Pump: 200% Power, 25% accurate.
• Surf: 100% Power, 50% accurate.
• Water Type is 1.5x stronger against Fire Types.

Your assignment

You will receive some starter code. You will receive 370 lines of code. You will need to add about 70 lines of code to finish the game.

You will need to implement these things:

• Create the WaterType and FireType Pokemon classes. You are given the GrassType to use as an example.
• Create the Computer subclass (child class) of the Player class. You will need the same methods as the User subclass of Player. But there is a fundamental difference in how these two classes will choose commands. The User class asks for input. The Computer class should use choice() and/or randint() to make decisions.
• Add instances of 3 FireType and 3 WaterType Pokemon to the pocket_monsters list of available Pokemon. These additional Pokemon are described in the Pokemon section above.
• Finish the make_a_move() method of the Player class to call all 4 commands based on player choice. Both User and Computer should use this same method.
• You can copy the starter code into your IDE and run it. You should be able to get something like this to know you have copied and pasted all the code correctly:

`;-.          ___,
  `.`\_...._/`.-"`
    \        /      ,
    /()   () \    .' `-._
   |)  .    ()\  /   _.'
   \  -'-     ,; '. <
    ;.__     ,;|   > \
   / ,    / ,  |.-'.-'
  (_/    (_/ ,;|.<`
    \    ,     ;-`
     >   \    /
    (_,-'`> .'
         (_,'

Your name? Joe
Enter the number for your pokemon choice.
1. Bulbasaur (grass) with health 60 and attack 40.
2. Bellsprout (grass) with health 40 and attack 60.
3. Oddish (grass) with health 50 and attack 50.
Choose? 1
Enter the number for your pokemon choice.
1. Bellsprout (grass) with health 40 and attack 60.
2. Oddish (grass) with health 50 and attack 50.
Choose? 2
Enter the number for your pokemon choice.
1. Bellsprout (grass) with health 40 and attack 60.
Choose? 1
Who will attack?
Enter the number for your pokemon choice.
1. Bulbasaur (grass) with health 60 and attack 40.
2. Oddish (grass) with health 50 and attack 50.
3. Bellsprout (grass) with health 40 and attack 60.
Choose? 1
Traceback (most recent call last):
  File "main.py", line 369, in <module>
    start_game()
  File "main.py", line 365, in start_game
    user.take_a_turn_against(computer)
NameError: name 'computer' is not defined

If you don't get this far then try to copy and paste the entire starter code again.

Starter Code

"""
My Pokemon game.
"""

from random import randint, choice

"""
A Player will be of type user or computer.
You could have a user play against the computer or
two players depending on which you instantiate.
You could also have two computer players fight.
"""

class Player():
    def __init__(self, name):
        self.name = name
        self.pokemon = []
        self.choose_3_pokemon()
        self.choose_attacker()

    def __str__(self):
        return self.name

    def take_a_turn_against(self, other_player):
        print() # skip a line to make it legible
        self.your_move(other_player)
        if not other_player.game_over():
            other_player.take_a_turn_against(self)
        else:
            show_pokemon()
            print(str(self) + " wins the game.")

    def make_a_move(self, move, other_player):
        if move == 'p':
            # showing current Pokemon status. This doesn't cost a turn.
            show_pokemon()
            self.your_move(other_player)
            
        else:
            # recursively ask for a different move.
            print("I don't know that one.")
            self.your_move(other_player)

    def game_over(self):
        return (
            self.pokemon[0].dead() and
            self.pokemon[1].dead() and
            self.pokemon[2].dead()
        )

    # Three different commands a player can choose.
    # attack and heal are redirected to the Pokemon.
    # If attacking Pokemon has been knocked out force a switch.
    # A forced switch stills costs a turn.
    def switch(self):
        self.choose_attacker()
        print(str(self) + " chooses " + self.attacker_name())

    def attack(self, other_player):
        if self.attacker.dead():
            print(
                "Sorry " + str(self) +
                ", your Pokemon was knocked out. You must switch."
            )
            self.switch()
        else:
            type = self.choose_attack()
            self.attacker.attack(type, other_player)

    def heal(self):
        if self.attacker.dead():
            print(
                "Sorry " + str(self) +
                ", your Pokemon was knocked out. You must switch."
            )
            self.switch()
        else:
            self.attacker.heal(self, 20)

    # redirect damage taken to the active Pokemon
    def fire_damage(self, damage):
        self.attacker.fire_damage(damage)

    def grass_damage(self, damage):
        self.attacker.grass_damage(damage)

    def water_damage(self, damage):
        self.attacker.water_damage(damage)

    # active Pokemon name, just the name.
    def attacker_name(self):
        return self.attacker.attacker_name()


"""
User type players will always ask for choices and commands.
"""

class User(Player):
    def your_move(self, other_player):
        print("Player " + self.name + " your move.")
        move = input("Attack (a), heal (h), switch (s) or Pokemon status (p)?")
        self.make_a_move(move, other_player)

    def choose_3_pokemon(self):
        for i in range(3):
            monster = choose_pokemon(pocket_monsters)
            self.pokemon.append(monster)
            pocket_monsters.remove(monster)

    def choose_attacker(self):
        print("Who will attack?")
        self.attacker = choose_pokemon(self.pokemon)

    def choose_attack(self):
        print("Choose your attack!")
        return choose_attack(self.attacker.attack_types())


"""
Computer players will just randomly take action.
They might not be intelligent actions, just actions.
"""




"""
Pokemon!!! The Pokemon class does almost everything.
Subclasses are of types grass, fire, or water.
Each type has different abilities.
"""

class Pokemon():
    def __init__(self, health, attack_power, name):
        self.health = health
        self.max_health = health
        self.attack_power = attack_power
        self.name = name
        self.init_attacks()

    def __str__(self):
        return (
            self.name + " (" +
            self.type + ") with health " +
            str(self.health) + " and attack " +
            str(self.attack_power) + "."
        )

    # just the name no stats
    def attacker_name(self):
        return self.name

    def attack_types(self):
        return self.attacks

    def dead(self):
        return self.health == 0

    # Pokemon will only heal or attack. Players must switch them.
    def heal(self, player, healing):
        self.health = min(self.health + healing, self.max_health)
        print(str(player) + " heals " + self.attacker_name() + ".")

    def attack(self, attack, other_player):
        print(
            self.attacker_name() + " attacking " +
            other_player.attacker_name() + " with " +
            attack.name + "."
        )
        damage = attack.calculate_damage(self.attack_power)
        self.do_damage_to(other_player, damage)
        

    # Rock, paper, scissors style of extra damage. Each Pokemon type is
    # stronger against one other type.
    def normal_damage(self, damage):
        self.health = max(self.health - damage, 0)
        print(str(damage) + " damage done to " + self.attacker_name())

    def extra_damage(self, amount):
        damage = round(amount * 1.5)
        self.health = max(self.health - damage, 0)
        print(
            str(damage) + " including extra damage done to " +
            self.attacker_name()
        )

    # default is normal damage for all types of attackers
    def grass_damage(self, amount):
        self.normal_damage(amount)

    def fire_damage(self, amount):
        self.normal_damage(amount)

    def water_damage(self, amount):
        self.normal_damage(amount)


""" Grass type Pokemon has leaf attacks and is weak to fire damage."""

class GrassType(Pokemon):
    type = 'grass'

    def init_attacks(self):
        self.attacks = [
            Attack("Leaf Storm", 150, 33),
            Attack("Mega Drain", 50, 100),
            Attack("Razor Leaf", 100, 50)
        ]

    # Grass Pokemon always do grass damage
    def do_damage_to(self, other_player, amount):
        other_player.grass_damage(amount)

    # Override default to do extra damage if fire attacks me
    def fire_damage(self, amount):
        self.extra_damage(amount)


"""Water type Pokemon has water attacks and is weak to fire damage."""


"""Fire type Pokemon has fire attacks and is weak to water damage."""


"""
We are going to make objects to represent attacks.
Damage calculations and hit/miss are done here.
"""

class Attack():
    """Attacks do the damage calculation."""
    def __init__(self, name, power, accuracy):
        self.name = name
        self.power_percent = power
        self.accuracy = accuracy

    def __str__(self):
        return (
            self.name + " with " +
            str(self.power_percent) + "% of attack power and " +
            str(self.accuracy) + "% chance to hit."
        )

    def calculate_damage(self, attack_power):
        if randint(1, 100) <= self.accuracy:
            max_damage = round(attack_power * self.power_percent / 100)
            return randint(1, max_damage)
        else:
            # Ha Ha missed me
            return 0


"""
User interface functions.
Choose a pokemon. Choose an attack.
"""

def choose_pokemon(pokemon):
    """Choose one of several Pokemon."""
    index = 1
    print("Enter the number for your pokemon choice.")
    for monster in pokemon:
        print(str(index) + ". " + str(monster))
        index = index + 1
    index = int(input("Choose? "))
    if index < 1 or index > len(pokemon):
        print("Not a valid number.")
        return choose_pokemon(pokemon)
    elif pokemon[index - 1].dead():
        print("That Pokemon is already knocked out, choose another.")
        return choose_pokemon(pokemon)
    else:
        return pokemon[index - 1]


def choose_attack(attacks):
    """Choose one of three attacks."""
    index = 1
    print("Enter the number for your attack choice.")
    for attack in attacks:
        print(str(index) + ". " + str(attack))
        index = index + 1
    index = int(input("Choose? "))
    if index < 1 or index > len(attacks):
        print("Not a valid number.")
        return choose_attack(attacks)
    else:
        return attacks[index - 1]


# a fourth command is to show the current status
def show_pokemon():
    show_title()
    print(str(user) + " attacking with " + user.attacker_name())
    print("Pokemon are:")
    for monster in user.pokemon:
        print("   " + str(monster))
    print()
    print(str(computer) + " attacking with " + computer.attacker_name())
    print("Pokemon are:")
    for monster in computer.pokemon:
        print("   " + str(monster))
    print()


def show_pikachu():
    """Some ASCII art."""
    print("""
`;-.          ___,
  `.`\_...._/`.-"`
    \        /      ,
    /()   () \    .' `-._
   |)  .    ()\  /   _.'
   \  -'-     ,; '. <
    ;.__     ,;|   > \\
   / ,    / ,  |.-'.-'
  (_/    (_/ ,;|.<`
    \    ,     ;-`
     >   \    /
    (_,-'`> .'
         (_,'
""")


def show_title():
    print("""
                                  ,'\\
    _.----.        ____         ,'  _\   ___    ___     ____
_,-'       `.     |    |  /`.   \,-'    |   \  /   |   |    \  |`.
\      __    \    '-.  | /   `.  ___    |    \/    |   '-.   \ |  |
 \.    \ \   |  __  |  |/    ,','_  `.  |          | __  |    \|  |
   \    \/   /,' _`.|      ,' / / / /   |          ,' _`.|     |  |
    \     ,-'/  /   \    ,'   | \/ / ,`.|         /  /   \  |     |
     \    \ |   \_/  |   `-.  \    `'  /|  |    ||   \_/  | |\    |
      \    \ \      /       `-.`.___,-' |  |\  /| \      /  | |   |
       \    \ `.__,'|  |`-._    `|      |__| \/ |  `.__,'|  | |   |
        \_.-'       |__|    `-._ |              '-.|     '-.| |   |
                                `'                            '-._|
          """)

"""
Call start_game to initialize and get the players to take turns.
Right now we are set up for one user and one computer player.
You can change that if you want.
"""
def start_game():
    """Start the Pokemon game."""
    global pocket_monsters, user, computer
    show_pikachu()
    pocket_monsters = [
        GrassType(60, 40, 'Bulbasaur'),
        GrassType(40, 60, 'Bellsprout'),
        GrassType(50, 50, 'Oddish'),
    ]

    user = User(input("Your name? "))
    #computer = Computer("Lysandre")
    user.take_a_turn_against(computer)


# Get this game started.
start_game()

Testing Your Computer Player

Because both User and Computer players have the same method names (Polymorphism). You can have two computer controlled players battle each other. You can do that easily by instantiating two Computer players and telling them to fight!

    #user = User(input("Your name? "))
    user = Computer("Pikachu") # You can make this game play itself.
    computer = Computer("Lysandre")
    user.take_a_turn_against(computer)

Look through the ouput and see if you find anything that looks wrong. Fix all the bugs you find then try to battle your computer player yourself.

Additional Things to Do

If you finish everything early you can make your computer player even smarter. Look for heuristics (expert level rule of thumb). Things like switching to a Pokemon that does extra damage to the player's chosen Pokemon. If the user has a Pokemon that is almost knocked out choose an attack that is more likely to hit. When choosing your 3 Pokemon, choose Pokemon that are strong against the user's 3 chosen Pokemon. There are many more. Add them and see how smart your computer player can get.

---

The code I expect them to create looks like this:

"""
My Pokemon game.
"""

from random import randint, choice

"""
A Player will be of type user or computer. 
You could have a user play against the computer or 
two players depending on which you instatiate.
You could also have two computer players fight.
"""

class Player():
    def __init__(self, name):
        self.name = name
        self.pokemon = []
        self.choose_3_pokemon()
        self.choose_attacker()

    def __str__(self):
        return self.name

    def take_a_turn_against(self, other_player):
        print() # skip a line to make it legible
        self.your_move(other_player)
        if not other_player.game_over():
            other_player.take_a_turn_against(self)
        else:
            show_pokemon()
            print(str(self) + " wins the game.")

    def make_a_move(self, move, other_player):
        if move == 'a':
            print(str(self) + " chooses to attack.")
            self.attack(other_player)
            
        elif move == 'h':
            print(str(self) + " chooses to heal " + self.attacker_name() + ".")
            self.heal()
            
        elif move == 's':
            print(str(self) + " chooses to switch Pokemon.")
            self.switch()
            
        elif move == 'p':
            # showing current Pokemon status. This doesn't cost a turn.
            show_pokemon()
            self.your_move(other_player)
            
        else:
            # recursively ask for a different move.
            print("I don't know that one.")
            self.your_move(other_player)

    def game_over(self):
        return (
            self.pokemon[0].dead() and 
            self.pokemon[1].dead() and 
            self.pokemon[2].dead()
        )

    # Three different commands a player can choose.
    # attack and heal are redirected to the Pokemon.
    # If attacking Pokemon has been knocked out force a switch.
    # A forced switch stills costs a turn.
    def switch(self):
        self.choose_attacker()
        print(str(self) + " chooses " + self.attacker_name())

    def attack(self, other_player):
        if self.attacker.dead():
            print(
                "Sorry " + str(self) +
                ", your Pokemon was knocked out. You must switch."
            )
            self.switch()
        else:
            type = self.choose_attack()
            self.attacker.attack(type, other_player)

    def heal(self):
        if self.attacker.dead():
            print(
                "Sorry " + str(self) +
                ", your Pokemon was knocked out. You must switch."
            )
            self.switch()
        else:
            self.attacker.heal(self, 20)

    # redirect damage taken to the active Pokemon
    def fire_damage(self, damage):
        self.attacker.fire_damage(damage)

    def grass_damage(self, damage):
        self.attacker.grass_damage(damage)

    def water_damage(self, damage):
        self.attacker.water_damage(damage)

    # active Pokemon name, just the name.
    def attacker_name(self):
        return self.attacker.attacker_name()


"""
User type players will always ask for choices and commands.
"""

class User(Player):
    def your_move(self, other_player):
        print("Player " + self.name + " your move.")
        move = input("Attack (a), heal (h), switch (s) or Pokemon status (p)?")
        self.make_a_move(move, other_player)

    def choose_3_pokemon(self):
        for i in range(3):
            monster = choose_pokemon(pocket_monsters)
            self.pokemon.append(monster)
            pocket_monsters.remove(monster)

    def choose_attacker(self):
        print("Who will attack?")
        self.attacker = choose_pokemon(self.pokemon)

    def choose_attack(self):
        print("Choose your attack!")
        return choose_attack(self.attacker.attack_types())


"""
Computer players will just randomly take actions.
They might not be intelligent actions, just actions.
"""

class Computer(Player):
    def your_move(self, other_player):
        print("Player " + self.name + " next move.")
        self.make_a_move(choice(['a', 'a', 'a', 'a', 'h', 's']), other_player)

    def choose_3_pokemon(self):
        for i in range(3):
            monster = choice(pocket_monsters)
            self.pokemon.append(monster)
            pocket_monsters.remove(monster)

    def choose_attacker(self):
        self.attacker = choice(self.pokemon)
        if self.attacker.health <= 0:
            self.choose_attacker()

    def choose_attack(self):
        return choice(self.attacker.attack_types())


"""
Pokemon!!! The Pokemon class does almost everything.
Subclasses are of types grass, fire, or water.
Each type has different abilities.
"""

class Pokemon():
    def __init__(self, health, attack_power, name):
        self.health = health
        self.max_health = health
        self.attack_power = attack_power
        self.name = name
        self.init_attacks()

    def __str__(self):
        return (
            self.name + " (" + 
            self.type + ") with health " +
            str(self.health) + " and attack " + 
            str(self.attack_power) + "."
        )

    # just the name no stats
    def attacker_name(self):
        return self.name

    def attack_types(self):
        return self.attacks

    def dead(self):
        return self.health == 0

    # Pokemon will only heal or attack. Players must switch them.
    def heal(self, player, healing):
        self.health = min(self.health + healing, self.max_health)
        print(str(player) + " heals " + self.attacker_name() + ".")

    def attack(self, attack, other_player):
        print(
            self.attacker_name() + " attacking " + 
            other_player.attacker_name() + " with " + 
            attack.name + "."
        )
        damage = attack.calculate_damage(self.attack_power)
        self.do_damage_to(other_player, damage)
        

    # Rock, paper, scissors style of extra damage. Each Pokemon type is
    # stronger against one other type.
    def normal_damage(self, damage):
        self.health = max(self.health - damage, 0)
        print(str(damage) + " damage done to " + self.attacker_name())

    def extra_damage(self, amount):
        damage = round(amount * 1.5)
        self.health = max(self.health - damage, 0)
        print(
            str(damage) + " including extra damage done to " + 
            self.attacker_name()
        )

    # default is normal damage for all types of attackers
    def grass_damage(self, amount):
        self.normal_damage(amount)

    def fire_damage(self, amount):
        self.normal_damage(amount)

    def water_damage(self, amount):
        self.normal_damage(amount)


""" Grass type Pokemon has leaf attacks and is weak to fire damage."""

class GrassType(Pokemon):
    type = 'grass'

    def init_attacks(self):
        self.attacks = [
            Attack("Leaf Storm", 150, 33),
            Attack("Mega Drain", 50, 100),
            Attack("Razor Leaf", 100, 50)
        ]

    # Grass Pokemon always do grass damage
    def do_damage_to(self, other_player, amount):
        other_player.grass_damage(amount)

    # Override default to do extra damage if fire attacks me
    def fire_damage(self, amount):
        self.extra_damage(amount)


"""Water type Pokemon has water attacks and is weak to fire damage."""

class WaterType(Pokemon):
    type = 'water'

    def init_attacks(self):
        self.attacks = [
            Attack("Surf", 100, 50),
            Attack("Bubble", 50, 100),
            Attack("Hydro Pump", 200, 25)
        ]

    # Water Pokemon always do water damage
    def do_damage_to(self, other_player, amount):
        other_player.water_damage(amount)

    # Override default to do extra damage if grass attacks me
    def grass_damage(self, amount):
        self.extra_damage(amount)


"""Fire type Pokemon has fire attacks and is weak to water damage."""

class FireType(Pokemon):
    type = 'fire'

    def init_attacks(self):
        self.attacks = [
            Attack("Ember", 50, 100),
            Attack("Fire Punch", 70, 70),
            Attack("Flame Wheel", 100, 50)
        ]

    # Fire Pokemon always do fire damage
    def do_damage_to(self, other_player, amount):
        other_player.fire_damage(amount)

    # Override default to do extra damage if water attacks me
    def water_damage(self, amount):
        self.extra_damage(amount)


"""
We are going to make objects to represent attacks. 
Damage calculations and hit/miss are done here.
"""

class Attack():
    """Attacks do the damage calculation."""
    def __init__(self, name, power, accuracy):
        self.name = name
        self.power_percent = power
        self.accuracy = accuracy

    def __str__(self):
        return (
            self.name + " with " + 
            str(self.power_percent) + "% of attack power and " + 
            str(self.accuracy) + "% chance to hit."
        )

    def calculate_damage(self, attack_power):
        if randint(1, 100) <= self.accuracy:
            max_damage = round(attack_power * self.power_percent / 100)
            return randint(1, max_damage)
        else:
            # Ha Ha missed me
            return 0


"""
User interface functions. 
Choose a pokemon. Choose an attack.
"""

def choose_pokemon(pokemon):
    """Choose one of several Pokemon."""
    index = 1
    print("Enter the number for your pokemon choice.")
    for monster in pokemon:
        print(str(index) + ". " + str(monster))
        index = index + 1
    index = int(input("Choose? "))
    if index < 1 or index > len(pokemon):
        print("Not a valid number.")
        return choose_pokemon(pokemon)
    elif pokemon[index - 1].dead():
        print("That Pokemon is already knocked out, choose another.")
        return choose_pokemon(pokemon)
    else:
        return pokemon[index - 1]


def choose_attack(attacks):
    """Choose one of three attacks."""
    index = 1
    print("Enter the number for your attack choice.")
    for attack in attacks:
        print(str(index) + ". " + str(attack))
        index = index + 1
    index = int(input("Choose? "))
    if index < 1 or index > len(attacks):
        print("Not a valid number.")
        return choose_attack(attacks)
    else:
        return attacks[index - 1]


# a fourth command is to show the current status
def show_pokemon():
    show_title()
    print(str(user) + " attacking with " + user.attacker_name())
    print("Pokemon are:")
    for monster in user.pokemon:
        print("   " + str(monster))
    print()
    print(str(computer) + " attacking with " + computer.attacker_name())
    print("Pokemon are:")
    for monster in computer.pokemon:
        print("   " + str(monster))
    print()


def show_pikachu():
    """Some ASCII art."""
    print("""
`;-.          ___,
  `.`\_...._/`.-"`
    \        /      ,
    /()   () \    .' `-._
   |)  .    ()\  /   _.'
   \  -'-     ,; '. <
    ;.__     ,;|   > \\
   / ,    / ,  |.-'.-'
  (_/    (_/ ,;|.<`
    \    ,     ;-`
     >   \    /
    (_,-'`> .'
         (_,'
""")


def show_title():
    print("""
                                  ,'\\
    _.----.        ____         ,'  _\   ___    ___     ____
_,-'       `.     |    |  /`.   \,-'    |   \  /   |   |    \  |`.
\      __    \    '-.  | /   `.  ___    |    \/    |   '-.   \ |  |
 \.    \ \   |  __  |  |/    ,','_  `.  |          | __  |    \|  |
   \    \/   /,' _`.|      ,' / / / /   |          ,' _`.|     |  |
    \     ,-'/  /   \    ,'   | \/ / ,`.|         /  /   \  |     |
     \    \ |   \_/  |   `-.  \    `'  /|  |    ||   \_/  | |\    |
      \    \ \      /       `-.`.___,-' |  |\  /| \      /  | |   |
       \    \ `.__,'|  |`-._    `|      |__| \/ |  `.__,'|  | |   |
        \_.-'       |__|    `-._ |              '-.|     '-.| |   |
                                `'                            '-._|
          """)

"""
Call start_game to initialize and get the players taking turns.
Right now we are set up for one user and one computer player.
You can change that if you want.
"""
def start_game():
    """Start the Pokemon game."""
    global pocket_monsters, user, computer
    show_pikachu()
    pocket_monsters = [
        GrassType(60, 40, 'Bulbasaur'),
        GrassType(40, 60, 'Bellsprout'),
        GrassType(50, 50, 'Oddish'),
        FireType(30, 70, 'Charmainder'),
        FireType(50, 50, 'Ninetails'),
        FireType(40, 60, 'Ponyta'),
        WaterType(80, 20, 'Squirtle'),
        WaterType(70, 30, 'Psyduck'),
        WaterType(50, 50, 'Poliwag')
    ]

    user = User(input("Your name? "))
    computer = Computer("Lysandre")
    user.take_a_turn_against(computer)


# Get this game started.
start_game()