Esempio n. 1
0
def run_game():
    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Alien Invasion")

    play_button = Button(screen, "Play", "Highscores")

    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings, screen, stats, 'images/highscores.txt',
                    play_button)

    ship = Ship(ai_settings, screen)
    ufo = Group()
    bullets = Group()
    alien_bullets = Group()
    aliens = Group()
    bunkers = Group()

    pygame.mixer.music.load('sounds/winter.wav')
    pygame.mixer.music.play(-1)

    menu = Menu(ai_settings, screen, play_button, aliens, alien_bullets)

    gf.create_ufo(ai_settings, screen, aliens, alien_bullets)

    while True:
        gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
                        aliens, bullets, alien_bullets, bunkers)

        if stats.game_active:
            ship.update()
            gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
                              bullets, alien_bullets, menu, ufo, bunkers)
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
                             bullets, alien_bullets, menu, ufo)
            gf.update_ufo(ai_settings, screen, ufo)
            gf.update_bunker(bunkers)

        gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
                         alien_bullets, menu, ufo, bunkers)
Esempio n. 2
0
def run_game():
    # Initilize game and create a screen object.
    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Space Invaders")

    # Make the Play button.
    play_button = Button(ai_settings, screen, "Play")

    # Create an instance to store game statistics and create a scoreboard.
    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings, screen, stats)

    # Make a ship, a group of bullets, and a group of aliens.
    ship = Ship(ai_settings, screen)
    bullets = Group()
    aliens = Group()
    ufo = Group()
    ebullets = Group()

    # Create the fleet of aliens.
    gf.create_fleet(ai_settings, screen, ship, aliens, ebullets)
    gf.create_ufo(ai_settings, screen, ufo)

    # Start the main loop for the game.
    while True:

        # Watch for keyboard and mouse events.
        gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
                        aliens, bullets, ebullets, ufo)
        if stats.game_active:
            ship.update()
            gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
                              bullets, ufo, ebullets)
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
                             bullets, ufo, ebullets)

        gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
                         play_button, ufo, ebullets)
def run_game():
    # Initialize game and create a screen object
    pygame.init()

    si_settings = Settings()

    screen = pygame.display.set_mode((si_settings.screen_width, si_settings.screen_height))
    pygame.display.set_caption("Space Invaders")

    # Make the Menu and the Play Game and High Scores buttons.
    menu = Menu(si_settings, screen)
    play_button = Button(si_settings, screen, "PLAY GAME", (si_settings.screen_width * 2.75) / 7, (si_settings.screen_height * 5.25) / 7)
    high_scores_button = Button(si_settings, screen, "HIGH SCORES", (si_settings.screen_width * 2.65) / 7, (si_settings.screen_height * 6) / 7)

    # Create an instance to store game statistics and create a scoreboard.
    stats = GameStats(si_settings)
    sb = Scoreboard(si_settings, screen, stats)

    # Make a ship, a group of bullets, and a group of aliens
    ship = Ship(si_settings, screen)
    bullets = Group()
    alienBullets = Group()
    aliens = Group()

    images = ["images/alien1.png", "images/alien2.png", "images/alien3.png"]

    random = randint(0, 10)
    ufo_random = randint(0, 10)
    start_ticks = pygame.time.get_ticks()

    # Create the ufo
    ufo = None

    # Create the fleet of aliens.
    gf.create_fleet(si_settings, screen, ship, aliens, images)

    # Load the background music
    # bg_music = pygame.mixer.music("audio/background_music.mp3")

    # Start the main loop for the game
    while True:
        # Watch for keyboard and mouse events.
        gf.check_events(si_settings, screen, stats, sb, menu, play_button, high_scores_button, ship, aliens, bullets, alienBullets, images)

        if stats.game_active:
            seconds = int((pygame.time.get_ticks() - start_ticks) / 1000)
            if seconds - previous_time == random:
                gf.fire_back(si_settings, screen, aliens, alienBullets)
                previous_time = seconds
                random = randint(5, 10)
            if seconds - ufo_previous_time == ufo_random:
                ufo = gf.create_ufo(si_settings)
                ufo_previous_time = seconds
                ufo_random = randint(20, 30)
                print("UFO Random: " + str(ufo_random) + "    Seconds: " + str(seconds) + "   UFO Previous Time: " + str(ufo_previous_time))
            ship.update()
            gf.update_bullets(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images)
            gf.update_aliens(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images, (seconds - previous_time), ufo)
        else:
            previous_time = int(pygame.time.get_ticks() / 1000)
            ufo_previous_time = int(pygame.time.get_ticks() / 1000)

        gf.update_screen(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, menu, play_button, high_scores_button)
def run_game():
    # Initialize pygame, settings, and create a screen object
    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Alien Invasion")

    # Make an instance of Play button and high scores button
    play_button = Play(ai_settings, screen, "Play Space Invaders")
    high_scores = HighScore(ai_settings, screen, "High Scores")
    home_button = Back(ai_settings, screen, "Back to Home")
    main_menu = Menu(ai_settings, screen)

    # Create an instance to store game statistics and create a scoreboard
    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings, screen, stats)

    # Make a ship, group of bullets, and group of aliens
    ship = Ship(ai_settings, screen)
    bullets = Group()
    alien1 = Group()
    alien2 = Group()
    alien3 = Group()
    bunkers = Group()
    ufo = Group()

    # Create a fleet of aliens
    gf.create_fleet(ai_settings=ai_settings,
                    screen=screen,
                    ship=ship,
                    alien1=alien1,
                    alien2=alien2,
                    alien3=alien3)

    # Create bunkers
    gf.create_bunker_row(ai_settings=ai_settings,
                         screen=screen,
                         bunkers=bunkers)

    # Set up sounds
    pygame.mixer.music.load('sounds/bg_music.wav')
    music_playing = False

    # Start the main loop for the game
    while True:
        if not music_playing:
            pygame.mixer.music.play(-1, 0.0)
            music_playing = True
        gf.check_events(ai_settings=ai_settings,
                        screen=screen,
                        main_menu=main_menu,
                        stats=stats,
                        sb=sb,
                        play_button=play_button,
                        high_scores=high_scores,
                        home_button=home_button,
                        ship=ship,
                        alien1=alien1,
                        alien2=alien2,
                        alien3=alien3,
                        bullets=bullets)
        if stats.game_active:
            gf.create_ufo(ai_settings=ai_settings, screen=screen, ufo=ufo)
            ship.update()
            gf.update_bullets(ai_settings=ai_settings,
                              screen=screen,
                              stats=stats,
                              sb=sb,
                              ship=ship,
                              alien1=alien1,
                              alien2=alien2,
                              alien3=alien3,
                              bullets=bullets,
                              bunkers=bunkers,
                              ufo=ufo)
            gf.update_aliens(ai_settings=ai_settings,
                             screen=screen,
                             stats=stats,
                             sb=sb,
                             ship=ship,
                             alien1=alien1,
                             alien2=alien2,
                             alien3=alien3,
                             ufo=ufo,
                             bullets=bullets,
                             bunkers=bunkers,
                             music_playing=music_playing)

        gf.update_screen(ai_settings=ai_settings,
                         screen=screen,
                         stats=stats,
                         sb=sb,
                         ship=ship,
                         bunkers=bunkers,
                         alien1=alien1,
                         alien2=alien2,
                         alien3=alien3,
                         ufo=ufo,
                         bullets=bullets,
                         main_menu=main_menu,
                         high_scores=high_scores)
Esempio n. 5
0
def run_game():
    """initialize game and create a screen object"""
    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Space Invaders")

    screen.fill([255, 255, 255])
    test = pygame.image.load("images/startup_image.png")
    screen.blit(test, [0, 0])
    pygame.display.flip()

    high_score = HighScore(screen)
    main_intro = False
    score_list_open = False
    while not main_intro:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    main_intro = True
                elif event.key == pygame.K_s:
                    main_intro = True
                    score_list_open = True

    if score_list_open:
        high_score.scores()
        pygame.display.flip()

    while score_list_open:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    score_list_open = False

    play_button = Button(ai_settings, screen, "Play")
    # create an instance to store game statistics
    stats = GameStats(ai_settings)
    # Create an instance to store game statistics and create a scoreboard.
    sb = Scoreboard(ai_settings, screen, stats)

    # make a ship, group of bullets, and a group of aliens
    ship = Ship(ai_settings, screen)
    # make a group to store bullets in
    bullets = Group()
    alien_bullets = Group()
    aliens = Group()
    aliens_b = Group()
    aliens_c = Group()
    ufos = Group()
    bunk = Group()

    bunker1 = Bunker(screen)
    bunker1.create_bunker(50, 600)
    bunk.add(bunker1)
    bunker2 = Bunker(screen)
    bunker2.create_bunker(250, 600)
    bunk.add(bunker2)
    bunker3 = Bunker(screen)
    bunker3.create_bunker(450, 600)
    bunk.add(bunker3)

    # create the fleet of aliens
    gf.create_fleet(ai_settings, screen, aliens)
    gf.create_b_fleet(ai_settings, screen, ship, aliens_b)
    gf.create_c_fleet(ai_settings, screen, ship, aliens_c)
    gf.create_ufo(ai_settings, screen, ufos)

    # start the main loop for the game
    while True:
        # watch for keyboard and mouse events
        gf.check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, aliens_b, aliens_c,
                        bullets, alien_bullets)
        if stats.game_active:
            ship.update()
            gf.random_ufo(ai_settings, screen, ufos)
            # gf.update_ufo(ufos)
            gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens, aliens_b, aliens_c, bullets)
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens, aliens_b, aliens_c, bullets)
            gf.update_alien_bullets(ai_settings, screen, stats, sb, ship, alien_bullets)
            gf.random_alien_shoot(ai_settings, screen, ship, alien_bullets, aliens)
            gf.check_alien_bullet_ship_collisions(ai_settings, screen, stats, sb, ship, aliens, aliens_b, aliens_c,
                                                  bullets, alien_bullets)
            gf.check_bullet_ufo_collisions(ai_settings, screen, stats, sb, bullets, ufos)
            gf.check_bunker_collisions(bullets, alien_bullets, bunk)
            if ufos.__len__() > 0:
                for ufo in ufos.copy():
                    ufo.move()
                    if ufo.rect.x > 600:
                        ufos.remove(ufo)

        bullets.update()
        alien_bullets.update()

        gf.update_screen(ai_settings, screen, ship, stats, sb, aliens, aliens_b, aliens_c, bullets,
                         play_button, alien_bullets, ufos, bunk)
def run_game():
    # Initializes background setting needed to run properly
    pygame.init()

    # Initializes settings
    ai_settings = Settings()

    # Creates a display window where all of the game's graphic elements are drawn
    # The numbers represent the dimensions of the window
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Alien Invasion")

    # Delay time
    delay = 0
    timer = random.randint(400, 1001)

    # Create an instance to store game statistics amd create a scoreboard
    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings, screen, stats)

    # Makes a ship, group of bullets, alien bullets, group of aliens, and ufos
    ship = Ship(ai_settings, screen, stats)
    bunkers = Group()
    bullets = Group()
    aliens_1 = Group()
    aliens_2 = Group()
    aliens_3 = Group()
    alien_bullets = Group()
    ufo = Group()

    # Make the play button that also contains the startup screen
    play_button = Button(screen, "Play", ai_settings, alien_bullets, stats)
    score_button = ScoreButton(screen, "High Scores", ai_settings)
    back_button = ScoreButton(screen, "Back (B)", ai_settings)

    # Starts the main loop for the game
    while True:
        # Checks for any type of event
        gf.check_events(ai_settings, screen, stats, sb, play_button, score_button, ship, aliens_1,
                        aliens_2, aliens_3, ufo, bullets, alien_bullets, bunkers)

        # Creates a new UFO at a random interval
        # Delay to prevent too many from spawning at once
        if delay == timer:
            gf.create_ufo(ai_settings, screen, ufo, alien_bullets, stats)
            # plays ufo sound
            ai_settings.ufo_sound.play()
            delay = 0
            timer = random.randint(700, 1001)
        else:
            delay += 1

        # Runs the game is active
        if stats.game_active:
            ship.update()

            gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3,
                              ufo, bullets, alien_bullets, bunkers)
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3,
                             ufo, bullets, alien_bullets, bunkers)
            gf.update_ufo(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3,
                          ufo, bullets, alien_bullets, bunkers)
        # Manages the screen updates
        gf.update_screen(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3, ufo,
                         bullets, alien_bullets, bunkers, play_button, score_button, back_button)