[Tutor] How to create delay in game

[Nicholas Perito]

Hello,

I new to programming and this is my first post. I'm learning Python via 
"Python Programming for the Absolute Beginner" by Michael Dawson. I've 
written a pong game  into which I want to insert a delay between sprite 
initializations. Right now, if an "Atom" sprite reaches the bottom of 
the screen, the next Atom sprite appears immediately. Instead, when the 
sprite reaches the bottom, I want the message "Two (or One) atoms left!" 
to appear for it's lifetime before the next Atom sprite appears. I've 
tried to create a delay by making it crunch numbers, but that hasn't 
worked well.

Anyway, the code is below, and the place where I want to create a delay 
is marked. Oh, and constructive criticism of the code is welcome--I'm 
not too sensitive.

Thanks a lot to anyone who can help!

(It's called 'Atom Pong' because I had a cool graphic)

# Atom Pong
# Nic Perito 11/06

import random
from livewires import games, color

SCREEN_WIDTH = 1000
SCREEN_HEIGHT = 700
THE_SCREEN = games.Screen(SCREEN_WIDTH, SCREEN_HEIGHT)
life = 3

class Atom(games.Sprite):
    """ Atom image """
     
    image = games.load_image("atom.jpg")
    def __init__(self, screen, x, y, dx, dy):
        """ Initialize atom object. """
        self.init_sprite(screen = screen, x = x, y = y,
                             dx = dx, dy = dy, image = Atom.image)

    def moved(self):
        """ Reverse a velocity component if edge of screen reached. """
        global life
        dx, dy = self.get_velocity()
        self.rotate_by(3)
        if self.get_right() > SCREEN_WIDTH:
            self.set_right(SCREEN_WIDTH)
            self.set_velocity(-dx, dy)
        if self.get_left() < 0:
            self.set_left(0)
            self.set_velocity(-dx, dy)
        if self.get_top() < 0:
            self.set_velocity(dx, -dy)
        if self.get_bottom() > SCREEN_HEIGHT:
            self.destroy()
            life -= 1
            if life == 0:
                self.game_over()
               
            if life == 2:
                games.Message(screen = self.screen,
                      x = 150, y = 20,
                      text = "Two atoms left!", size = 40, color = 
color.yellow,
                      lifetime = 200)
                #HERE'S WHERE I WANT A DELAY
                Atom(self.screen, x = (SCREEN_WIDTH - 76), y = 76,
                        dx = 6, dy = 5)

            if life == 1:
                games.Message(screen = self.screen,
                      x = 150, y = 45,
                      text = "One atom left!", size = 40, color = 
color.yellow,
                      lifetime = 200)
                #HERE'S WHERE I WANT A DELAY
                Atom(self.screen, x = 76, y = 76,
                        dx = 6, dy = 6)
           
    def handle_deflect(self):
        """ Deflect atom. """
        dx, dy = self.get_velocity()
        self.set_velocity(dx + random.randrange(2,4), -dy)

    def game_over(self):
        """ End the game. """
        # destroy all game objects except the Text object (player's score)
        for game_object in self.screen.all_objects():
            if not isinstance(game_object, games.Text):
                game_object.destroy()
               
        # show 'Game Over' for 250 mainloop() cycles
        games.Message(screen = self.screen,
                      x = SCREEN_WIDTH/2, y = 400,
                      text = "Game Over", size = 90, color = color.red,
                      lifetime = 500, after_death = self.screen.quit)

class Bonus(games.Sprite):
    """ Atom bonus image """
    image = games.load_image("bonus.jpg")
    def __init__(self, screen, x, y, dx, dy):
        """ Initialize atom object. """
        self.init_sprite(screen = screen, x = x, y = y,
                             dx = dx, dy = dy, image = Bonus.image)

    def moved(self):
        """ Reverse a velocity component if edge of screen reached. """
        dx, dy = self.get_velocity()
        self.rotate_by(-3)
        if self.get_right() > SCREEN_WIDTH or self.get_left() < 0:
            self.set_velocity(-dx, dy)
        if self.get_top() < 0:
            self.set_velocity(dx, -dy)
        if self.get_bottom() > SCREEN_HEIGHT:
            self.destroy()
    def handle_deflect(self):
        """ Deflect atom. """
        dx, dy = self.get_velocity()
        self.set_velocity(dx, -dy)


class Paddle(games.Sprite):
    """
    A paddle controlled by player to 'deflect' atoms.
    """
    image = games.load_image("paddle.jpg", transparent = False)

    def __init__ (self, screen, x, y):
        """ Initialize paddle object. Create a Text object for player's 
score. """
        self.init_sprite(screen = screen, x = x, y = y, image = 
Paddle.image)
        self.score_value = 0
        self.score_text = games.Text(screen = self.screen, x = 
SCREEN_WIDTH/2, y = 20,
                                     text = "Score: 0", size = 25, color 
= color.white)

    def moved(self):
        """ Move paddle to mouse x position. """
        x, y = self.get_pos()

        if self.screen.is_pressed(games.K_RIGHT):
            x += 9

        if self.screen.is_pressed(games.K_LEFT):
            x -= 9

        self.move_to(x,y)

       
        if self.get_left() < 0:
            self.set_left(0)
        if self.get_right() > SCREEN_WIDTH:
            self.set_right(SCREEN_WIDTH)
        self.check_for_impact()

    def check_for_impact(self):
        """ Check if paddle hits atoms. """
        for atom in self.overlapping_objects():
            self.handle_deflect()
            atom.handle_deflect()

    def handle_deflect(self):
        """ Increase and display score. """

        bonus = []
        for i in range(0, 5000, 50):
            bonus.append(i)
        self.score_value += 10
        self.score_text.set_text("Score: " + str(self.score_value))
        if self.score_value in bonus:
            Bonus(self.screen, x = random.randrange(800)+ 76, y = 76,
                  dx = random.randrange(10)+2, dy = random.randrange(3)+ 2)
           
            games.Message(screen = self.screen,
                      x = SCREEN_WIDTH/2, y = 300,
                      text = "BONUS!", size = 90, color = color.red,
                      lifetime = 50)
          
   


   


def main():     
    my_screen = THE_SCREEN
    my_screen.mouse_visible(False)
    background_image = games.load_image("black.jpg", transparent = False)
    my_screen.set_background(background_image)

   
    Atom(screen = my_screen, x = 76, y = 76,
          dx = 6, dy = 5)

   
    Paddle(screen = my_screen, x = SCREEN_WIDTH/2, y = 690)
   

    my_screen.mainloop()

# start program
main()