Exemplo n.º 1
0
class AlienInvasion:
    def __init__(self):
        pygame.init()

        self.settings = Settings()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))

        self.ship = Ship(self)

        pygame.display.set_caption('Alien Invasion')

    def check_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                self.check_keydown_events(event)
            elif event.type == pygame.KEYUP:
                self.check_keyup_events(event)

    def check_keydown_events(self, event):
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = True
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = True
        elif event.key == pygame.K_q:
            sys.exit()

    def check_keyup_events(self, event):
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = False
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = False

    def update_screen(self):
        self.screen.fill(self.settings.background_color)
        self.ship.blitme()

    def run_game(self):
        while True:
            self.check_events()
            self.ship.update()
            self.update_screen()

            pygame.display.flip()
Exemplo n.º 2
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")

    #创建一艘飞船
    ship = Ship(ai_settings,screen)
    bullets = Group()

    #创建一个外星人
    alien = Alien(ai_settings,screen)


    #开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
       # gf.update_bullets(bullets)
        gf.update_screen(ai_settings,screen,ship,alien,bullets)

        bullets.update()
        # gf.update_screen(ai_settings,screen,ship,bullets)

        # 删除已消失的子弹
        for bullet in bullets.copy():
            if bullet.rect.bottom <= 0:
                bullets.remove(bullet)
        print(len(bullets))

        gf.update_screen(ai_settings, screen, ship, alien, bullets)

        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()

        # 每次循环绘制屏幕
        screen.fill(ai_settings.bg_color)
        ship.blitme()
        # 让最近绘制的屏幕可见
        pygame.display.flip()
Exemplo n.º 3
0
def run_game():
    """初始化"""
    pygame.init()
    '''
    """设置背景和桌面"""
    screen = pygame.display.set_mode((1360,760))

    """设置背景颜色"""
    bg_color = (230,230,230)
    '''
    """设置标题"""
    pygame.display.set_caption("Aline Invasion")

    ai_setting = Settings()
    screen = pygame.display.set_mode(
        (ai_setting.screen_width, ai_setting.screen_height))

    ship = Ship(screen)
    stats = GameStats(ai_setting)

    bullets = Group()
    bullet_one = Bullet(ai_setting, screen, ship)

    alien = Alien(ai_setting, screen)
    aliens = Group()
    alien.create_fleet(ai_setting, screen, aliens, ship)

    play_button = Button(ai_setting, screen, "Play!")

    while True:
        """游戏没有结束前,一直运行"""
        """控制飞船移动"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()

            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_RIGHT:
                    ship.move_right = True
                if event.key == pygame.K_LEFT:
                    ship.move_left = True
                if event.key == pygame.K_UP:
                    ship.move_up = True
                if event.key == pygame.K_DOWN:
                    ship.move_down = True
                if event.key == pygame.K_SPACE:
                    bullet_one.bullet_space = True
                if event.key == pygame.K_q:
                    sys.exit()
                if event.key == pygame.K_k:
                    stats.game_active = True
                    stats.ships_left = ai_setting.ship_limit

            elif event.type == pygame.KEYUP:
                if event.key == pygame.K_RIGHT:
                    ship.move_right = False
                if event.key == pygame.K_LEFT:
                    ship.move_left = False
                if event.key == pygame.K_UP:
                    ship.move_up = False
                if event.key == pygame.K_DOWN:
                    ship.move_down = False
                if event.key == pygame.K_SPACE:
                    bullet_one.bullet_space = False

            elif event.type == pygame.MOUSEBUTTONDOWN:
                if not stats.game_active:
                    mouse_x, mouse_y = pygame.mouse.get_pos()
                    play_button.check_paly_button(ai_setting, stats,
                                                  play_button, mouse_x,
                                                  mouse_y)
        """让最近绘制的屏幕可见"""
        screen.fill(ai_setting.bg_color)

        if stats.game_active:
            if stats.ships_left > 0:
                bullet_one.fire_bullet(ai_setting, screen, ship, bullets)
                bullet_one.update_bullets(bullets, aliens)
                aliens.draw(screen)
                ship.update(ai_setting.ship_speed_factor)
                ship.blitme()
                alien.update_aliens(ai_setting, aliens, ship, screen, stats,
                                    bullets)
                if len(aliens) == 0:
                    bullets.empty()
                    alien.create_fleet(ai_setting, screen, aliens, ship)

        if not stats.game_active:
            pygame.mouse.set_visible(True)
            play_button.draw_button()
        """
        bullets.update()
        for bullet in bullets.sprites():
            bullet.draw_bullet()
        for bullet in bullets.copy():
            if bullet.rect.bottom <= 0:
                bullets.remove(bullet)
                """

        #alien.biltme()
        pygame.display.flip()
Exemplo n.º 4
0
class TargetPractice:

    """The class to manage game assets and behavior. """

    def __init__(self):
        """Initialize the game and create the resources. """
        pygame.init()
        self.settings = Settings()

        self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
        self.screen_rect = self.screen.get_rect()

        self.settings.screen_width = self.screen.get_rect().width
        self.settings.screen_height = self.screen.get_rect().height

        pygame.display.set_caption("Target Practice")

        self.stats = Stats(self)

        self.ship =Ship(self)
        self.rockets = pygame.sprite.Group()
        self.play_button = rectangle(self)
        self.play_but = p_button(self, "Click to Play")

    def _check_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                self._check_keydown_events(event)
            elif event.type == pygame.KEYUP:
                self._check_keyup_events(event)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self.check_play_button(mouse_pos)

    def _check_rect_edges(self):
        if self.play_button._check_edges():
            self._change_rect_direction()

    def fire_rocket(self):
        if len(self.rockets) <= self.settings.rockets_allowed:
            new_rocket = Rocket(self)
            self.rockets.add(new_rocket)

    def check_play_button(self, mouse_pos):
        #Start a new game when the player clicks Play.
        button_clicked = self.play_but.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            #Reset the game settings
            self.stats.reset_stats()
            self.stats.game_active = True

            self.rockets.empty()

            self.ship.center_ship

            pygame.mouse.set_visible(False)

    def update_rockets(self):
        self.rockets.update()
        for rocket in self.rockets.copy():
            if rocket.rect.right >= self.screen_rect.right:
                self.rockets.remove(rocket)

            self._check_rocket_rect_collisions()

    def target_hit(self):
        self.settings.enhanced_settings()
        self.rockets.empty()
        self.ship.center_ship()
        sleep(0.5)



    def _check_rocket_rect_collisions(self):
        if pygame.sprite.spritecollideany(self.play_button, self.rockets):
            self.target_hit()

    def _change_rect_direction(self):
        self.settings.rect_direction *= -1

    def _check_keydown_events(self, event):
        if event.key == pygame.K_UP:
            self.ship.moving_top = True

        elif event.key == pygame.K_DOWN:
            self.ship.moving_down = True

        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self.fire_rocket()

    def _check_keyup_events(self, event):
        if event.key == pygame.K_UP:
            self.ship.moving_top = False
        elif event.key == pygame.K_DOWN:
            self.ship.moving_down = False

    def _run_game(self):
        """Start the main loop of the game. """
        while True:
            self._check_events()
            if self.stats.game_active:
                self.ship.update()
                self.update_rockets()
                self.update_rect()
            self._update_screen()

    def update_rect(self):
        self._check_rect_edges()
        self.play_button.update()

    def _update_screen(self):
        self.screen.fill(self.settings.bg_color)
        self.ship.blitme()
        for rocket in self.rockets.sprites():
            rocket.draw_rocket()
        self.play_button.draw_button()

        if not self.stats.game_active:
            self.play_but.draw_button()
        pygame.display.flip()
Exemplo n.º 5
0
class AlienInvasion:
    """"Overall class to manage game assets and behavior."""
    def __init__(self):
        """"Initialize the game and create game resources"""
        pygame.init()
        self.settings = Settings()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_height, self.settings.screen_width))
        # full screen settings
        # self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
        # self.settings.screen_width = self.screen.get_rect().width
        # self.settings.screen_height = self.screen.get_rect().height
        pygame.display.set_caption("Alien invasion")
        # Create an instance to store game statistics.
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()
        self._create_fleet()
        self.play_button = Button(self, "Play")

    def run_game(self):
        """"Start the main loop for the game"""
        while True:
            self._check_events()
            if self.stats.game_active:
                self.ship.update()
                self._update_bullets()
                self._update_aliens()

            self._update_screen()

            # Get rid of bullets that have gone off screen

    def _check_events(self):
        """Respond to keypress and mouse events"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)
            elif event.type == pygame.KEYDOWN:
                self._check_keydown_events(event)
            elif event.type == pygame.KEYUP:
                self._check_keyup_events(event)

    def _check_play_button(self, mouse_pos):
        """"Start a new game when player clicks play"""
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            # Reset the game stats
            self.settings.initialize_dynamic_settings()
            self.stats.reset_stats()
            self.stats.game_active = True
            self.sb.prep_score()
            self.sb.prep_level()
            self.sb.prep_ships()
            # Get rid of any remaining game assets
            self.aliens.empty()
            self.bullets.empty()
            # Create new fleet and center ship
            self._create_fleet()
            self.ship.center_ship()
            # Hide mouse cursor
            pygame.mouse.set_visible(False)

    def _check_keydown_events(self, event):
        """Respond to keypresses. """
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = True
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = True
        elif event.key == pygame.K_SPACE:
            self._fire_bullet()

    def _check_keyup_events(self, event):
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = False
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = False
        elif event.key == pygame.K_q:
            sys.exit()

    def _fire_bullet(self):
        """Create a new bullet and add it to the bullets group."""
        if len(self.bullets) < self.settings.bullets_allowed:
            new_bullet = Bullet(self)
            self.bullets.add(new_bullet)

    def _create_fleet(self):
        """Create a fleet of Aliens"""
        # create an alien and find the number of aliens in a row
        # spacing between the aliens is equal to one alien width
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        available_space_x = self.settings.screen_width - (2 * alien_width)
        number_aliens_x = available_space_x // (2 * alien_width)

        # determine number of rows of aliens that fit on screen
        ship_height = self.ship.rect.height
        available_space_y = (self.settings.screen_height - (3 * alien_height) -
                             ship_height)
        number_rows = available_space_y // (2 * alien_height)

        # create fleet of aliens
        for row_number in range(number_rows):
            for alien_number in range(number_aliens_x):
                self._create_alien(alien_number, row_number)

    def _create_alien(self, alien_number, row_number):
        """create an alien and place it in row """
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        alien.x = alien_width + 2 * (alien_width * alien_number)
        alien.rect.x = alien.x
        alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
        self.aliens.add(alien)

    def _check_fleet_edges(self):
        """Respond appropriately if any aliens have reached an edge"""
        for alien in self.aliens.sprites():
            if alien.check_edges():
                self._change_fleet_direction()
                break

    def _change_fleet_direction(self):
        """Drop the entire fleet and change the fleet's direction"""
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.fleet_drop_speed
        self.settings.fleet_direction *= -1

    def _update_screen(self):
        """Updates images on the screen, and flips to new screen"""
        self.screen.fill(self.settings.bg_color)
        self.ship.blitme()
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()
        self.aliens.draw(self.screen)
        self.sb.show_score()
        # Draw play button if game is inactive
        if not self.stats.game_active:
            self.play_button.draw_button()
        pygame.display.flip()

    def _update_bullets(self):
        """Update position of bullets and gets rid of old bullets"""
        # Update bullet positions
        self.bullets.update()
        # Get rid of bullets that have gone off screen
        for bullet in self.bullets.copy():
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)
        # print(f" bullets generated : {len(self.bullets)}")
        self._check_bullet_alien_collision()

    def _check_bullet_alien_collision(self):
        # Check for bullet alien collisions
        collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
                                                True, True)
        # check if all aliens in fleet destroyed
        if collisions:
            for aliens in collisions.values():
                self.stats.score += self.settings.alien_points * len(aliens)
            self.sb.prep_score()
            self.sb.prep_high_score()
        if not self.aliens:
            # Destroy existing bullets and create new fleet
            self.bullets.empty()
            self._create_fleet()
            self.settings.increase_speed()
            # Increase level.
            self.stats.level += 1
            self.sb.prep_level()

    def _update_aliens(self):
        """ Check if the fleet is at an edge,
        Update the positions of all aliens in the fleet
        """
        self._check_fleet_edges()
        self.aliens.update()
        # Look for alien ship collisions
        if pygame.sprite.spritecollideany(self.ship, self.aliens):
            self._ship_hit()

        # Look for aliens hitting the bottom of the screen
        self._check_aliens_bottom()

    def _ship_hit(self):
        """Respond to ship being hit by an alien """
        if self.stats.ships_left > 0:
            # Decrement ships left and update scoreboard
            self.stats.ships_left -= 1
            self.sb.prep_ships()
            # Get rid of any remaining aliens and bullets
            self.aliens.empty()
            self.bullets.empty()
            # Create a new fleet and center the ship
            self._create_fleet()
            self.ship.center_ship()
            # Pause
            sleep(0.5)
        else:
            self.stats.game_active = False
            pygame.mouse.set_visible(True)

    def _check_aliens_bottom(self):
        """Check if any aliens have reached the bottom of the screen"""
        screen_rect = self.screen.get_rect()
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= screen_rect.bottom:
                # Treat this the same as if the got hit.
                self._ship_hit()
                break
Exemplo n.º 6
0
class AlienInvasion:
    '''Main class, base of the program'''
    def __init__(self):
        '''initialize game and resources'''
        pygame.init()
        self.settings = Settings()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))

        self.stats = Game_stats(self)
        self.score = Scoreboard(self)

        pygame.display.set_caption("Alien Invasion")

        # ship
        self.ship = Ship(self)

        # bullets
        self.bullets = pygame.sprite.Group()

        # alien
        self.aliens = pygame.sprite.Group()

        self._create_invasion()

        #control
        self.play_button = Button(self, "Play")

    # helper method - start with _(underscore)

    def _update_screen(self):
        # basic redraw
        self.screen.fill(self.settings.bg_color)
        self.ship.blitme()
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()

        self.aliens.draw(self.screen)

        #draw score
        self.score.show_score()

        #Draw button if game is inactive
        if not self.settings.game_active:
            self.play_button.draw_button()

        # make most recent screen visible
        pygame.display.flip()

    def _check_events(self):
        '''keyboard and mouse events'''
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                self._check_keyDown(event)
            elif event.type == pygame.KEYUP:
                self._check_keyUP(event)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_position = pygame.mouse.get_pos()
                self._check_play_button(mouse_position)

    def _check_keyUP(self, event):
        if event.key == pygame.K_a or event.key == pygame.K_d:
            self.ship.moving = False
            self.ship.moving_x = 0

    def _check_keyDown(self, event):
        if event.key == pygame.K_ESCAPE:
            sys.exit(0)

        elif event.key == pygame.K_SPACE:
            if len(self.bullets) < self.settings.bullets_allowed:
                self._fire_bullet()

        if event.key == pygame.K_d:
            # move ship to the right
            self.ship.moving = True
            self.ship.moving_x = self.settings.ship_speed
        if event.key == pygame.K_a:
            # move ship to the left
            self.ship.moving = True
            self.ship.moving_x = -self.settings.ship_speed

    def _check_play_button(self, mouse_position):
        '''start new game when player clicks play'''
        if self.play_button.rect.collidepoint(
                mouse_position) and not self.settings.game_active:
            self._game_reset()

            self.settings.game_active = True
            #hide mouse cursor
            pygame.mouse.set_visible(False)

    def _game_reset(self):
        '''Reset game'''
        self.stats.reset_stats()
        self.settings.init_dynamic_settings()
        self.score.prep_score()
        self.score.prep_level()
        self.score.prep_ships()
        # get rid of previous game objects
        self.aliens.empty()
        self.bullets.empty()
        self._create_invasion()
        self.ship.center_ship()

    def _fire_bullet(self):
        '''create bullet and add it to bullets'''
        self.bullets.add(Bullet(self))

    def _remove_obsole_bullets(self):
        '''remove obsolete bullets and aliens if hit'''
        for bullet in self.bullets:
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)

    def _alien_bullet_collision(self):
        #Check for bullet sthat have hit aliens
        collisions = pygame.sprite.groupcollide(
            self.bullets, self.aliens, self.settings.bullet_single_kill, True)

        if collisions:
            for alien in collisions.values():
                self.stats.score += self.settings.alien_points * len(alien)
                self.score.prep_score()
                self.score.check_high_score()

    def _create_alien(self, alien_number, row_number):
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        alien.rect.y = alien_height + 2 * alien_height * row_number
        self.aliens.add(alien)

    def _create_invasion(self):
        '''create fleet of invading aliens'''
        # settings for fleet
        test_alien = Alien(self)
        alien_width, alien_height = test_alien.rect.size
        available_space_x = self.settings.screen_width - (2 * alien_width)
        num_of_aliens_x = available_space_x // (
            2 *
            alien_width) + 1  # +1 is my correction - remove if game too hard
        available_space_y = self.settings.screen_height - (3 * alien_height)
        num_of_aliens_y = available_space_y // (
            2 * alien_height) - self.settings.alien_buffer_zone

        for row_number in range(num_of_aliens_y):
            for alien_number in range(num_of_aliens_x):
                self._create_alien(alien_number, row_number)

    def _update_aliens(self):
        '''
        Check if fleet hits an edge, then update alien position
        '''
        self._check_fleet_edges()
        self.aliens.update()
        self._alien_ship_collision()
        self._check_aliens_landed()

    def _alien_ship_collision(self):
        '''check if aliens hit the ship'''
        if pygame.sprite.spritecollideany(self.ship, self.aliens):
            self._ship_hit()

    def _ship_hit(self):
        '''Ship has been hit logic'''
        #remove ship life if you can
        if self.stats.ship_left > 0:
            self.stats.ship_left -= 1
            self.score.prep_ships()
            # reset game state
            self.aliens.empty()
            self._reset_state()
            self.ship.center_ship()
            #pause game for a bit
            sleep(self.settings.hit_freeze_time)
        else:
            self._game_over()

    def _check_fleet_edges(self):
        '''Respond if any alien hit an edge'''
        for alien in self.aliens.sprites():
            if alien.check_edges():
                self._change_fleet_direction()
                break

    def _change_fleet_direction(self):
        '''Drop fleet and change direction'''
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.alien_speed_vertical

        self.settings.alien_moving_right = not self.settings.alien_moving_right

    def _code_relentless_horde(self):
        if not self.aliens:
            self._reset_state()
            self.settings.increase_speed()
            self.stats.level += 1
            self.score.prep_level()

    def _check_aliens_landed(self):
        '''check if aliens reached bottom of screen'''
        screen_rect = self.screen.get_rect()
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= screen_rect.bottom:
                self._ship_hit()
                break

    def _reset_state(self):
        '''Destroy bullets, reset aliens'''
        self.bullets.empty()
        self._create_invasion()

    def _update_game_state(self):
        self._remove_obsole_bullets()
        self._alien_bullet_collision()
        self._code_relentless_horde()

    def _game_over(self):
        self.settings.game_active = False
        self.stats.save_high_score(self.stats.high_score)
        pygame.mouse.set_visible(True)

    def run(self):
        '''Main loop'''
        while True:
            self._check_events()

            if self.settings.game_active:
                self.ship.update()
                self.bullets.update()
                self._update_game_state()
                self._update_aliens()
            self._update_screen()
Exemplo n.º 7
0
class AlienInvasion:
    def __init__(self):
        pygame.init()
        self.settings = Settings()
        self.screen = pygame.display.set_mode((1000, 800), pygame.FULLSCREEN)
        self.settings.screen_height = self.screen.get_rect().height
        self.settings.screen_width = self.screen.get_rect().width
        pygame.display.set_caption("Alien Invasion")
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.bg_color = self.settings.bg_color
        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()
        self._create_fleet()
        self.play_button = Button(self, "Play")

    def run_game(self):
        while True:
            self._check_events()
            if self.stats.game_active:
                self.ship.update()
                self._update_bullets()
                self._update_aliens()
            self._update_screen()

    def _update_bullets(self):
        self.bullets.update()
        for bullet in self.bullets.copy():
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)
        self._check_bullet_alien_collisions()

    def _check_bullet_alien_collisions(self):
        collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
                                                True, True)
        if collisions:
            for aliens in collisions.values():
                self.stats.score += self.settings.alien_points * len(aliens)
            self.stats.score += self.settings.alien_points
            self.sb.prep_score()
            self.sb.check_high_score()
        if not self.aliens:
            self.bullets.empty()
            self._create_fleet()
            self.settings.increase_speed()
            self.stats.level += 1
            self.sb.prep_level()

    def _update_screen(self):
        self.screen.fill(self.bg_color)
        self.ship.blitme()
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()
        self.aliens.draw(self.screen)
        self.sb.show_score()
        if not self.stats.game_active:
            self.play_button.draw_button()
        pygame.display.flip()

    def _check_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()

            elif event.type == pygame.KEYDOWN:
                self._check_keydown_events(event)

            elif event.type == pygame.KEYUP:
                self._check_keyup_events(event)

            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)

    def _check_keydown_events(self, event):
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = True
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = True
        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self._fire_bullet()

    def _check_keyup_events(self, event):
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = False
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = False

    def _fire_bullet(self):
        if len(self.bullets) < self.settings.bullets_allowed:
            new_bullet = Bullet(self)
            self.bullets.add(new_bullet)

    def _create_fleet(self):
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        alien_width = alien.rect.width
        available_space_x = self.settings.screen_width - (2 * alien_width)
        number_aliens_x = available_space_x // (2 * alien_width)

        ship_height = self.ship.rect.height
        available_space_y = (self.settings.screen_height - (3 * alien_height) -
                             ship_height)
        number_rows = available_space_y // (2 * alien_height)

        for row_number in range(number_rows):
            for alien_number in range(number_aliens_x):
                self._create_alien(alien_number, row_number)

    def _create_alien(self, alien_number, row_number):
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
        self.aliens.add(alien)

    def _update_aliens(self):
        self._check_fleet_edges()
        self.aliens.update()
        if pygame.sprite.spritecollideany(self.ship, self.aliens):
            self._ship_hit()
        self._check_aliens_bottom()

    def _check_fleet_edges(self):
        for alien in self.aliens.sprites():
            if alien.check_edges():
                self._change_fleet_directions()
                break

    def _change_fleet_directions(self):
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.fleet_drop_speed
        self.settings.fleet_direction *= -1

    def _ship_hit(self):
        if self.stats.ships_left > 0:
            self.stats.ships_left -= 1
            self.sb.prep_ships()
            self.aliens.empty()
            self.bullets.empty()
            self._create_fleet()
            self.ship.center_ship()
            sleep(0.5)
        else:
            self.stats.game_active = False
            pygame.mouse.set_visible(True)

    def _check_aliens_bottom(self):
        screen_rect = self.screen.get_rect()
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= screen_rect.bottom:
                self._ship_hit()
                break

    def _check_play_button(self, mouse_pos):
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            self.settings.initialize_dynamic_settings()
            self.stats.reset_stats()
            self.stats.game_active = True
            self.sb.prep_score()
            self.sb.prep_level()
            self.sb.prep_ships()
            self.aliens.empty()
            self.bullets.empty()
            self._create_fleet()
            self.ship.center_ship()
            pygame.mouse.set_visible(False)
Exemplo n.º 8
0
class AlienInvasion:
    def __init__(self):

        #initialize game
        pygame.init()

        #icon
        self.icon = pygame.image.load('images/icon.png')

        pygame.display.set_icon(self.icon)

        #screen size
        self.screen = pygame.display.set_mode((800, 600))

        #ships object
        self.ship = Ship(self)

        self.bullet = Bullets(self)
        #game name
        pygame.display.set_caption('my game')

        #background image
        self.background = pygame.image.load('images/background.png')

        #load ship sound when moving
        self.accelarate = pygame.mixer.Sound('music/accelarate.wav')

    def _updateScreen(self):

        self.bullet.shootBullet()

        self.ship.update()

        pygame.display.flip()

    def _keyDownEvents(self, event):

        #play sound when ship is moving

        self.accelarate.play()

        #makes sure the ship does not disappear

        if event.key == pygame.K_RIGHT:

            #moves the ship on the x axsis

            self.ship.moving_right = True

        if event.key == pygame.K_LEFT:

            self.ship.moving_left = True

        if event.key == pygame.K_UP:

            self.ship.moving_up = True

        if event.key == pygame.K_q:

            self.bullet.shoot = True

    def _keyUpEvents(self, event):
        #stop sound when key up

        self.accelarate.stop()

        if event.key == pygame.K_RIGHT:

            self.ship.moving_right = False

        if event.key == pygame.K_LEFT:

            self.ship.moving_left = False

        if event.key == pygame.K_UP:

            self.ship.moving_up = False

    def run_game(self):

        while True:

            self.screen.fill((212, 215, 210))

            self.screen.blit(self.background, (0, 0))

            self.ship.blitme()

            self.bullet.drawBullet()

            for event in pygame.event.get():

                if event.type == pygame.QUIT:

                    sys.exit()

                elif event.type == pygame.KEYDOWN:
                    self._keyDownEvents(event)

                elif event.type == pygame.KEYUP:
                    self._keyUpEvents(event)

            self._updateScreen()