[Tutor] pygame help with livewires

[Skylar Struble]

ok so its working and drops a normal cow and randomly a green cow but
i want it to be able to tell when you collide with the green cow cause
its gonna be a powerup.

heres the code for my program.

# Pizza Panic
# Player must catch falling pizzas before they hit the ground

from livewires import games, color
import random
hscorefile = open("hscores.txt", 'r')
score = 0
level = 1
pizzascore = 2
stl = 15
lstl = 15
pizza_speed = 1
cook_speed = 4
pizza_drop = 0.5
level_up_drop = 1
highscore = int(hscorefile.read(100000000))
hscorefile.close()
games.init(screen_width = 640, screen_height = 480, fps = 50)

class Pan(games.Sprite):
    """
    A pan controlled by player to catch falling pizzas.
    """
    global score
    image = games.load_image("pan.bmp")

    def __init__(self):
        """ Initialize Pan object and create Text object for score. """
        global level
        global hs
        global score
        super(Pan, self).__init__(image = Pan.image, x =
games.mouse.x, bottom = games.screen.height)

        self.score = games.Text(value = 0, size = 25, color = color.black,
                               top = 5, right = games.screen.width - 10)
        games.screen.add(self.score)
        self.leveltxt = games.Text(value = "level:", size = 25, color
= color.black,
                        top = 5, right = games.screen.width - 580)
        games.screen.add(self.leveltxt)
        self.level = games.Text(value = level, size = 25, color = color.black,
                        top = 5, right = games.screen.width - 566)
        games.screen.add(self.level)
        self.hs = games.Text(value = "Highscore:" + str(highscore),
size = 25, color = color.black,
                top = 5, right = games.screen.width - 320)
        games.screen.add(self.hs)

    def update(self):
        """ Move to mouse x position. """
        self.x = games.mouse.x

        if self.left < 0:
            self.left = 0

        if self.right > games.screen.width:
            self.right = games.screen.width

        self.check_catch()

    def check_catch(self):
        """ Check if catch pizzas. """
        global pizza_drop
        global level
        global score
        global score_to_level
        global cook_speed
        global pizza_speed
        global stl
        global lstl
        global pizzascore
        stl = (lstl *2.5)
        for pizza in self.overlapping_sprites:
            self.score.value = self.score.value + pizzascore
            score = self.score.value
            if self.score.value >= stl:
                lstl = stl
                pizza_drop += 0.2
                self.level.value += 1
                pizza_speed += .25
                pizzascore = pizzascore * 2
                cook_speed += 5
                level = level + 1
                lvlup_message = games.Message(value = "Level " + str(level),
                            size = 90,
                            color = color.red,
                            x = games.screen.width/2,
                            y = games.screen.height/2,
                            lifetime = 2 * games.screen.fps)
                games.screen.add(lvlup_message)
            self.score.right = games.screen.width - 10
            pizza.handle_caught()
class Pizza(games.Sprite):
    """
    A pizza which falls to the ground.
    """
    global pizza_speed
    speed = 1.5
    image = games.load_image("pizza.bmp")

    def __init__(self, x, y = 90):
        """ Initialize a Pizza object. """
        super(Pizza, self).__init__(image = Pizza.image,
                                    x = x, y = y,
                                    dy = pizza_speed)

    def update(self):
        """ Check if bottom edge has reached screen bottom. """
        if self.bottom > games.screen.height:
            self.end_game()
            self.destroy()

    def handle_caught(self):
        """ Destroy self if caught. """
        self.destroy()

    def end_game(self):
        global highscore
        global score
        global name
        """ End the game. """
        if score > highscore:
            hsfile = open("hscores.txt", "w")
            hsfile.write(str(score))
            hsfile.close()
            hs_message = games.Message(value ="New highscore of " + str(score),
                                        size = 45,
                                        color = color.red,
                                        x = games.screen.width/2,
                                        y = games.screen.height/2,
                                        lifetime = 1 * games.screen.fps,
                                        after_death = games.screen.quit)
            games.screen.add(hs_message)
        else:
            end_message = games.Message(value = "game over",
                                        size = 45,
                                        color = color.red,
                                        x = games.screen.width/2,
                                        y = games.screen.height/2,
                                        lifetime = 0 * games.screen.fps,
                                        after_death = games.screen.quit)
            games.screen.add(end_message)


class power_pizza1(games.Sprite):
    """
    A pizza which falls to the ground.
    """
    global pizza_speed
    speed = 1.5
    image = games.load_image("power_pizza1.bmp")

    def __init__(self, x, y = 90):
        """ Initialize a Pizza object. """
        super(power_pizza1, self).__init__(image = power_pizza1.image,
x = x, y = y, dy = pizza_speed)


    def update(self):
        """ Check if bottom edge has reached screen bottom. """
        if self.bottom > games.screen.height:
            self.destroy()

    def handle_caught(self):
        """ Destroy self if caught. """
        self.destroy()
class Chef(games.Sprite):
    """
    A chef which moves left and right, dropping pizzas.
    """
    global cook_speed
    image = games.load_image("chef.bmp")

    def __init__(self, y = 55, speed = 1000, odds_change = 55):
        """ Initialize the Chef object. """
        super(Chef, self).__init__(image = Chef.image,
                                   x = games.screen.width / 2,
                                   y = y,
                                   dx = cook_speed)

        self.odds_change = odds_change
        self.time_til_drop = 0


    def update(self):
        """ Determine if direction needs to be reversed. """
        if self.left < 0 or self.right > games.screen.width:
            self.dx = -self.dx
        elif random.randrange(self.odds_change) == 0:
           self.dx = -self.dx

        self.check_drop()


    def check_drop(self):
        rpp = 5
        """ Decrease countdown or drop pizza and reset countdown. """
        global pizza_drop
        if self.time_til_drop > 0:
            self.time_til_drop -= pizza_drop
        else:
            new_pizza = Pizza(x = random.randrange(40, 600))
            rpp = random.randrange(1, 5)
            if rpp == 3:
                power_pizza = power_pizza1 (x = random.randrange(40, 600))
                games.screen.add(power_pizza)
            else:
                games.screen.add(new_pizza)

            # set buffer to approx 30% of pizza height, regardless of
pizza speed
            self.time_til_drop = int(new_pizza.height * 1.3 / Pizza.speed) + 1


def main():
    """ Play the game. """
    wall_image = games.load_image("wall.jpg", transparent = False)
    games.screen.background = wall_image

    the_chef = Chef()
    games.screen.add(the_chef)

    the_pan = Pan()
    games.screen.add(the_pan)

    games.mouse.is_visible = False

    games.screen.event_grab = True
    games.screen.mainloop()

# start it up!
main()