Esempio n. 1
0
    def gameLoop(self):
        """Pętla gry właściwej."""
        self.sound_start.stop()
        self.sound_game.play()

        self.clock = pygame.time.Clock()
        self.delta = 0.0
        self.max_tps = 100.0

        self.exit = False
        self.gameover = False

        while not self.exit:

            #dzięlki temu zapewniam tą samą szybkość obiektów niezależnie od możliwości danego komputera
            self.delta += self.clock.tick() / 1000.0

            while self.delta > 1 / self.max_tps:
                self.delta -= 1 / self.max_tps

                for event in pygame.event.get():
                    if event.type == pygame.QUIT:
                        self.exit = True
                    elif event.type == pygame.KEYDOWN:
                        if event.key == pygame.K_ESCAPE:
                            self.exit = True
                        if event.key == pygame.K_SPACE:
                            self.ball.y_velocity = -4
                            self.ball.x_velocity = 0

                keys = pygame.key.get_pressed()
                if keys[pygame.K_LEFT]:
                    self.paddle.rect.x += -self.paddle.speed
                if keys[pygame.K_RIGHT]:
                    self.paddle.rect.x += self.paddle.speed
                elif keys[pygame.K_p]:
                    self.sound_game.stop()
                    self.pause()
                    self.clock = pygame.time.Clock()

                #przegrana
                if self.ball.rect.centery > self.screen_height - self.check:
                    Functions.reset_ball(self)
                    self.sound_game.stop()
                    if self.live_counter == 1:
                        self.sound_loose.play()
                        self.gameover = True
                    else:

                        self.ball.rect.top = self.screen_height - 100
                        self.ball.rect.centerx = self.screen_width / 2
                        self.paddle.rect.left = int(self.screen_width / 2 -
                                                    self.paddle_width / 2)
                        self.paddle.rect.top = int(self.screen_height - 30)
                        self.sound_game.play()
                        time.sleep(1)

                    self.live_counter -= 1

                self.update()

                #zderzenie piłki i bloków
                for hit in pygame.sprite.groupcollide(self.BallSprite,
                                                      self.BlocksSprite, 0, 1):
                    self.sound_killed_bricks.play()
                    self.ball.y_velocity = -self.ball.y_velocity
                self.killed_blocks = self.counter - len(self.BlocksSprite)

                #przspieszenie deski po zderzeniu pilki z rozszerzeniem
                for hit in pygame.sprite.groupcollide(self.BallSprite,
                                                      self.AddSpeedSprite, 0,
                                                      1):
                    self.ball.y_velocity = -self.ball.y_velocity
                    self.paddle.speed = 10

                # przspieszenie deski po zderzeniu pilki z rozszerzeniem
                for hit in pygame.sprite.groupcollide(
                        self.BallSprite, self.SubstractSpeedSprite, 0, 1):
                    self.ball.y_velocity = -self.ball.y_velocity
                    self.paddle.speed = 4

                #zwycięstwo
                if len(self.BlocksSprite) == 0:
                    self.sound_game.stop()
                    self.sound_victory.play()
                    self.live_counter = 3
                    Pages.victory(self)

                # zderzenie piłki i deski
                for hit in pygame.sprite.groupcollide(self.PaddleSprite,
                                                      self.BallSprite, 0, 0):

                    self.sound_bounced_ball.play()

                    # ustawienie różnych kątów odbicia piłki w zależności od miejsca jej odbicia na desce
                    if (self.paddle.get_pos() - self.paddle_width * 0.1
                        ) <= self.ball.get_pos() <= (self.paddle.get_pos() +
                                                     self.paddle_width * 0.1):
                        self.ball.x_velocity = 0
                        self.ball.y_velocity = -Functions.calculate_velocity(
                            self,
                            self.start_vel_y**2 + self.ball.x_velocity**2, 0)

                    elif self.paddle.get_pos() - self.paddle_width * 0.5 - (
                            self.ball_width /
                            2) < self.ball.get_pos() < self.paddle.get_pos(
                            ) - self.paddle_width * 0.3:
                        self.ball.x_velocity = -self.start_vel_x
                        self.ball.y_velocity = -self.ball.y_velocity

                    elif self.paddle.get_pos(
                    ) + self.paddle_width * 0.3 <= self.ball.get_pos(
                    ) < self.paddle.get_pos() + self.paddle_width * 0.5 + (
                            self.ball_width / 2):
                        self.ball.x_velocity = self.start_vel_x
                        self.ball.y_velocity = -self.ball.y_velocity

                    elif self.paddle.get_pos(
                    ) - self.paddle_width * 0.3 <= self.ball.get_pos(
                    ) < self.paddle.get_pos() - self.paddle_width * 0.1:
                        self.ball.x_velocity = -2
                        self.ball.y_velocity = Functions.calculate_velocity(
                            self, self.velocity, -2)
                        self.ball.y_velocity = -self.ball.y_velocity

                    elif self.paddle.get_pos(
                    ) + self.paddle_width * 0.1 < self.ball.get_pos(
                    ) < self.paddle.get_pos() + self.paddle_width * 0.3:
                        self.ball.x_velocity = 2
                        self.ball.y_velocity = Functions.calculate_velocity(
                            self, self.velocity, 2)
                        self.ball.y_velocity = -self.ball.y_velocity

                self.screen.fill(self.black)

                self.draw()

                #wysświetla wynik
                Functions.score(self, self.killed_blocks, self.counter)
                Functions.lives(self, self.live_counter)

                pygame.display.update()

                #pętla obsługująca przegraną
                while self.gameover == True:
                    self.sound_game.stop()

                    self.screen.fill(self.grey)
                    Functions.message(self,
                                      "Game over",
                                      self.white,
                                      y_displace=-50,
                                      size="large")
                    Functions.message(self,
                                      "Press M back to menu, or Q to quit",
                                      self.white,
                                      y_displace=50)
                    pygame.display.update()

                    for event in pygame.event.get():
                        if event.type == pygame.QUIT:
                            pygame.quit()
                            quit()
                        if event.type == pygame.KEYDOWN:
                            if event.key == pygame.K_q:
                                self.exit = True
                                self.gameover = False

                            if event.key == pygame.K_m:
                                Game()

                            if event.key == pygame.K_ESCAPE:
                                pygame.quit()
                                quit()

        Functions.invite(self)