Esempio n. 1
0
class AsteroidClash:

    MIN_ASTEROID_DISTANCE = 250

    # Initializing
    def __init__(self) -> None:
        self._init_pygame()
        self.screen = pygame.display.set_mode((800, 600))
        self.background = load_sprite(name='space', with_alpha=False)
        self.bullets = []
        self.asteroids = []
        self.spaceship = Spaceship((400, 300), self.bullets.append)
        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break
            self.asteroids.append(Asteroid(position, self.asteroids.append))

        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ''

    # Defining Main Loop for the game
    def main_loop(self) -> None:
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    # Initializing Pygame
    def _init_pygame(self) -> None:
        pygame.init()
        pygame.display.set_caption('Asteroid Clash')

    # Defining function for handling input
    def _handle_input(self) -> None:
        for event in pygame.event.get():

            # Exiting the game
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                quit()
            elif (self.spaceship and event.type == pygame.KEYDOWN
                  and event.key == pygame.K_SPACE):
                self.spaceship.shoot()

        # Handling Inputs
        is_key_pressed = pygame.key.get_pressed()

        if self.spaceship:
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)
            elif is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()

    # Defining function for getting all game objects
    def _get_game_objects(self):
        game_objects = [*self.asteroids]
        game_objects = [*self.asteroids, *self.bullets]
        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects

    # Defining function for processing game logic
    def _process_game_logic(self) -> None:
        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    self.message = 'YOU LOST!'
                    break

        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)

        for bullet in self.bullets[:]:
            for asteroid in self.asteroids[:]:
                if asteroid.collides_with(bullet):
                    self.asteroids.remove(asteroid)
                    self.bullets.remove(bullet)
                    asteroid.split()
                    break

        if not self.asteroids and self.spaceship:
            self.message = 'YOU WON!'

    # Defining function for drawing elements on screen
    def _draw(self) -> None:
        self.screen.blit(self.background, (0, 0))
        for game_object in self._get_game_objects():
            game_object.draw(self.screen)
        if self.message:
            print_text(self.screen, self.message, self.font)
        pygame.display.flip()
        self.clock.tick(60)
Esempio n. 2
0
class SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

    def __init__(self):
        self._init_pygame()
        self.screen = pygame.display.set_mode((800, 600))
        self.background = load_sprite("space", False)
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ""

        self.asteroids = []
        self.bullets = []
        #self.asteroids = [Asteroid(get_random_position(self.screen)) for _ in range(6)]
        self.spaceship = Spaceship((400, 300), self.bullets.append)

        for _ in range(2):
            while True:
                position = get_random_position(self.screen)
                if position.distance_to(
                        self.spaceship.position) > self.MIN_ASTEROID_DISTANCE:
                    break

            self.asteroids.append(Asteroid(position, self.asteroids.append))

    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("Space Rocks")

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or \
                    (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
                quit()
            elif (self.spaceship and event.type == pygame.KEYDOWN
                  and event.key == pygame.K_SPACE):
                self.spaceship.shoot()
        is_key_pressed = pygame.key.get_pressed()
        if self.spaceship:
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)
            if is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()

    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)
            #self.asteroid.move()

            if self.spaceship:
                for asteroid in self.asteroids:
                    if asteroid.collides_with(self.spaceship):
                        self.spaceship = None
                        self.message = "You lost!"
                        break

            for bullet in self.bullets[:]:
                for asteroid in self.asteroids[:]:
                    if asteroid.collides_with(bullet):
                        self.asteroids.remove(asteroid)
                        self.bullets.remove(bullet)
                        asteroid.split()
                        break

            for bullet in self.bullets[:]:
                if not self.screen.get_rect().collidepoint(bullet.position):
                    self.bullets.remove(bullet)

            if not self.asteroids and self.spaceship:
                self.message = "You won!"

    def _draw(self):
        self.screen.blit(self.background, (0, 0))
        #self.asteroid.draw(self.screen)

        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        if self.message:
            print_text(self.screen, self.message, self.font)

        pygame.display.flip()
        self.clock.tick(60)

    def _get_game_objects(self):
        game_objects = [*self.asteroids, *self.bullets]

        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects
Esempio n. 3
0
class SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

    def __init__(self):
        self._init_pygame()

        # creates a display surface. Images in Pygame are represented by surfaces.
        # Here are a few things to know about them:
        #    x Surfaces can be drawn on one another, allowing you to create complex
        #      scenes from simple pictures.
        #
        #    x There’s one special surface in each Pygame project. That surface represents
        #      the screen and is the one that will eventually be displayed to players.
        #      All other surfaces have to be drawn on this one at some point.
        #      Otherwise, they won’t be shown.
        #
        #    x To create the display surface, your program uses pygame.display.set_mode().
        #      The only argument you pass to this method is the size of the screen,
        #      represented by a tuple of two values: width and height.
        #      In this case, Pygame will create a screen with a width of 800 pixels
        #      and a height of 600 pixels.
        self.screen = pygame.display.set_mode((800, 600))
        self.background = load_sprite("space", False)
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ""

        self.asteroids = []
        self.bullets = []
        self.spaceship = Spaceship((400, 300), self.bullets.append)

        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break
            self.asteroids.append(Asteroid(position, self.asteroids.append))
        # self.asteroid = GameObject(
        #     (400, 300), load_sprite("asteroid"), (1, 0)
        # )

    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):

        # This single line of code is responsible for setting up
        # the amazing features of Pygame.
        # Every time you work with Pygame, you should call pygame.init()
        # at the beginning of your program to make sure
        # that the framework will work correctly.
        pygame.init()
        pygame.display.set_caption("Space Rocks")

    def _handle_input(self):

        #  It happens when someone requests the program to end,
        #  either by clicking Close or by pressing Alt+F4
        #  on Windows and Linux or Cmd+W on macOS. Or Esc
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                quit()
            elif (self.spaceship and event.type == pygame.KEYDOWN
                  and event.key == pygame.K_SPACE):
                self.spaceship.shoot()

        is_key_pressed = pygame.key.get_pressed()

        if self.spaceship:
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)
            if is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()
            elif is_key_pressed[pygame.K_DOWN]:
                self.spaceship.slow_down()

    def _get_game_objects(self):
        game_objects = [*self.asteroids, *self.bullets]

        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects

    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    self.message = "You lost"
                    break

        for bullet in self.bullets[:]:
            for asteroid in self.asteroids[:]:
                if asteroid.collides_with(bullet):
                    self.asteroids.remove(asteroid)
                    self.bullets.remove(bullet)
                    asteroid.split()
                    break

        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)

        if not self.asteroids and self.spaceship:
            self.message = "You won"

    def _draw(self):

        # fills the screen with a color using screen.fill(). The method takes a tuple with three values,
        # representing three base colors: red, green, and blue. Each color value ranges between 0 and 255,
        # representing its intensity. In this example, a tuple of (0, 0, 255) means
        # that the color will consist only of blue, with no traces of red or green.
        # self.screen.fill((0, 0, 255))

        # To display one surface on another in Pygame, you need to call blit()
        # on the surface you want to draw on. This method takes two arguments:
        #   x  The surface that you want to draw
        #   x   The point where you want to draw it
        self.screen.blit(self.background, (0, 0))
        for game_object in self._get_game_objects():
            game_object.draw(self.screen)
        # self.asteroid.draw(self.screen)
        # updates the content of the screen using pygame.display.flip(). Because your game will
        # eventually display moving objects, you’ll call this method every frame to update
        # the display. Because of this, you need to fill your screen with color every frame,
        # as the method will clear the contents generated during the previous frame.
        if self.message:
            print_text(self.screen, self.message, self.font)
        pygame.display.flip()
        self.clock.tick(60)
Esempio n. 4
0
class Meteoroids:

    MIN_METEROID_DIS = 300
    WIDTH = 800
    HEIGHT = 600

    def __init__(self):
        self.score = 0
        self._init_pygame()
        self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
        self.background = load_sprite("space1", False)
        self.background_game_music = load_sound("game_play_music")
        self.game_over_music = load_sound("game_over_music")
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ""
        self.meteroids = []
        self.bullets = []
        self.spaceship = Spaceship((400, 300), self.bullets.append)
        
        for _ in range(4):
            while True:
                pos = get_random_position(self.screen)
                if pos.distance_to(self.spaceship.position) > self.MIN_METEROID_DIS:
                    break
            self.meteroids.append(Meteroid(pos, self.meteroids.append))
        

    def _get_game_objects(self):
        game_objs = [*self.meteroids, *self.bullets]

        if self.spaceship:
            game_objs.append(self.spaceship)

        return game_objs

    def _welcome_screen(self):
        welcome_message = """ PIZZA DOG """
        intro_music = load_sound("welcome_screen_music")
        intro_music.play()
        self.screen.blit(self.background, (0, 0))
        draw_text(self.screen, welcome_message, self.font,  self.WIDTH/2, self.HEIGHT/3)
        draw_text(self.screen, "Press [ENTER] To Begin", self.font,  self.WIDTH/2, (self.HEIGHT/2)+40)
            
        intro = True
        while intro:
            
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    quit()
                elif event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
                    intro_music.stop()
                    intro = False
            pygame.display.flip()


    def game_loop(self):

        #intro_loop
        self._welcome_screen()

        self.background_game_music.play()
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()


    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("Meteriods")


    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (
                event.type == pygame.KEYDOWN and event.key == pygame.K_q
            ):
                quit()
            elif(
                self.spaceship
                and event.type == pygame.KEYDOWN
                and event.key  == pygame.K_SPACE
            ):
                self.spaceship.shoot()

            is_key_pressed = pygame.key.get_pressed()
            
            if self.spaceship:
                if is_key_pressed[pygame.K_RIGHT]:
                    self.spaceship.rotate(clockwise=True)
                elif is_key_pressed[pygame.K_LEFT]:
                    self.spaceship.rotate(clockwise=False)

                if is_key_pressed[pygame.K_UP]:
                    self.spaceship.accelerate()
                elif is_key_pressed[pygame.K_DOWN]:
                    self.spaceship.reverse()

    def _process_game_logic(self):

        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        if self.spaceship:
            for meteroid in self.meteroids:
                if meteroid.collides_with(self.spaceship):
                    self.spaceship.explosion_sound.play()
                    self.background_game_music.stop()
                    self.game_over_music.play()
                    self.spaceship = None
                    self.message = "Game Over... Final Score: " + str(self.score)
                    break

        for bullet in self.bullets[:]:
            for meteroid in self.meteroids[:]:
                if meteroid.collides_with(bullet):
                    meteroid_size = meteroid.size
                    if meteroid_size == 3:
                        self.score += 3 
                    elif meteroid_size == 2:
                        self.score += 2
                    else:
                        self.score += 1 
                    meteroid.explosion_sound.play()   
                    self.meteroids.remove(meteroid)
                    self.bullets.remove(bullet)
                    meteroid.split()
                    break

        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)
        
        if not self.meteroids and self.spaceship:
            self.message = "You Won!"
        
    def _display_score(self):
        current_score = self.font.render("Score: " + str(self.score), 1, Color("white"))
        self.screen.blit(current_score, (self.WIDTH - 10 - current_score.get_width(), 10))

    def _draw(self):
        self.screen.blit(self.background, (0, 0))
        self._display_score()

        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        if self.message:
            print_text(self.screen, self.message, self.font)
            
        pygame.display.flip()
        self.clock.tick(60)
Esempio n. 5
0
class SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

    def __init__(self):
        self._init_pygame()
        self.screen = screenSize(1000, 700)
        self.background = load_sprite("space", False)
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ""
        self.destroyed_small = 0
        self.score = 0
        self.scoretext = self.font.render("Score = " + str(self.score), 1,
                                          (255, 0, 0))

        file = 'C://Users//ActionICT//PycharmProjects//Asteroids//assets//music//jlbrock44_-_Stars_Below_Us.mp3'
        pygame.init()
        pygame.mixer.init()
        pygame.mixer.music.load(file)
        pygame.mixer.music.play(
            -1)  # If the loops is -1 then the music will repeat indefinitely.

        self.asteroids = []
        self.bullets = []
        self.spaceship = Spaceship((400, 300), self.bullets.append)

        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break

            self.asteroids.append(Asteroid(position, self.asteroids.append))

    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("Space Rocks")

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                quit()
            elif (self.spaceship and event.type == pygame.KEYDOWN
                  and event.key == pygame.K_SPACE):
                self.spaceship.shoot()

        is_key_pressed = pygame.key.get_pressed()

        if self.spaceship:
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)
            if is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()

    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)
        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    #Sound('C:/Users/ActionICT/PycharmProjects/Asteroids/assets/sounds/Blastwave_FX_BankSafeExplosion_HV.37.mp3').play()
                    self.message = FinalScreen.PROTOTYPE_FINAL_DISPLAY.format(
                        FinalScreen.LOST_MESSAGE,
                        FinalScreen.MESSAGE_ESC_OR_CONTINUE) + ' ' + str(
                            self.score)
                    break

        for bullet in self.bullets[:]:
            for asteroid in self.asteroids[:]:
                if asteroid.collides_with(bullet):
                    if asteroid.size == 1:
                        Sound(
                            'C:/Users/ActionICT/PycharmProjects/Asteroids/assets/sounds/firework_explosion_001.mp3'
                        ).play()
                        self.destroyed_small += 1
                        if self.destroyed_small == 4:
                            while True:
                                position = get_random_position(self.screen)
                                if (position.distance_to(
                                        self.spaceship.position) >
                                        self.MIN_ASTEROID_DISTANCE):
                                    break
                            self.destroyed_small = 0
                            self.asteroids.append(
                                Asteroid(position, self.asteroids.append))
                    elif asteroid.size == 3:
                        Sound(
                            'C:/Users/ActionICT/PycharmProjects/Asteroids/assets/sounds/zapsplat_explosion_large.mp3'
                        ).play()
                    else:
                        Sound(
                            'C:/Users/ActionICT/PycharmProjects/Asteroids/assets/sounds/boom.mp3'
                        ).play()
                    self.asteroids.remove(asteroid)
                    self.bullets.remove(bullet)
                    asteroid.split()
                    self.score += 10
                    break

        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)

        if not self.asteroids and self.spaceship:
            self.message = FinalScreen.PROTOTYPE_FINAL_DISPLAY.format(
                FinalScreen.WON_MESSAGE, FinalScreen.MESSAGE_ESC_OR_CONTINUE)

    def _draw(self):
        self.screen.blit(self.background, (0, 0))
        # self.spaceship.draw(self.screen)
        # self.asteroid.draw(self.screen)
        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        self.screen.blit(self.scoretext, (500, 10))
        self.scoretext = self.font.render("Score = " + str(self.score), 1,
                                          (255, 0, 0))

        pygame.display.flip()

        if self.message:
            test_label = makeLabel(self.message,
                                   60,
                                   400,
                                   300,
                                   fontColour="red",
                                   font='juiceitc',
                                   background='clear')

            moveLabel(test_label,
                      test_label.rect.topleft[0] - test_label.rect.width / 2,
                      test_label.rect.topleft[1] - test_label.rect.height / 2)

            self.screen.fill("black")

            showLabel(test_label)

            pygame.mixer.music.stop()

            while True:
                for event in pygame.event.get():
                    if event.type == pygame.QUIT or (
                            event.type == pygame.KEYDOWN and
                        (event.key == pygame.K_ESCAPE)):
                        quit()
                    elif (event.type == pygame.KEYDOWN
                          and event.key == pygame.K_RETURN):
                        hideLabel(test_label)
                        self.__init__()
                        self.main_loop()

        self.clock.tick(60)

    def _get_game_objects(self):
        game_objects = [*self.asteroids, *self.bullets]

        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects
Esempio n. 6
0
class SpaceRocks:
    # Class variables
    MIN_ASTEROID_DISTANCE = 250

    # Constructor for instance of our gameplay handler classs
    def __init__(self):
        # Call a private initialization method
        self._init_pygame()
        self.screen = pygame.display.set_mode((800, 600))
        self.background = load_sprite("space", False)
        self.clock = pygame.time.Clock()  # Ensure stable FPS
        self.font = pygame.font.Font(None, 64)
        self.message = ""

        self.asteroids = []
        self.bullets = []
        self.spaceship = Spaceship((400, 300), self.bullets.append)

        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break

            self.asteroids.append(Asteroid(position, self.asteroids.append))

    # Main game loop happening in three parts: handle inputs,
    # process game logic, and then draw to the screen
    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    # Private initialization method
    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("Space Rocks")

    # Handle inputs, using the arrow keys and space bar
    def _handle_input(self):
        # Get the events from pygame module
        for event in pygame.event.get():
            # Allow user to quit the game
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                quit()
            elif (self.spaceship and event.type == pygame.KEYDOWN
                  and event.key == pygame.K_SPACE):
                self.spaceship.shoot()

        # Get dictionary of pressed keys
        is_key_pressed = pygame.key.get_pressed()

        # If the spaceship isn't destroyed
        if self.spaceship:
            # Rotate the ship object appropriately
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)

            # Accelerate the ship
            if is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()

    # handle the game logic, account for collisions, etc.
    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        # Check for collisions of spaceship with asteroids
        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    self.message = "You lost!"
                    break

        # Check for collisions of bullets with asteroids
        for bullet in self.bullets[:]:
            for asteroid in self.asteroids[:]:
                if asteroid.collides_with(bullet):
                    self.asteroids.remove(asteroid)
                    self.bullets.remove(bullet)
                    asteroid.split()
                    break

        # Remove bullets which are off the screen
        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)

        if not self.asteroids and self.spaceship:
            self.message = "You won!"

    # Update the game drawing
    def _draw(self):
        self.screen.blit(self.background, (0, 0))
        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        if self.message:
            print_text(self.screen, self.message, self.font)

        pygame.display.flip()
        self.clock.tick(60)  # Set the frame rate to 60 FPS

    # Helper method to get all the game objects
    def _get_game_objects(self):
        game_objects = [*self.asteroids, *self.bullets]
        if self.spaceship:
            game_objects.append(self.spaceship)
        return game_objects
Esempio n. 7
0
class SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

    def __init__(self):
        self._init_pygame()
        self.screen = pygame.display.set_mode((800, 600))
        self.background = load_sprite("space", False)
        self.clock = pygame.time.Clock()

        self.asteroids = []
        self.spaceship = Spaceship((400, 300))

        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break

            self.asteroids.append(Asteroid(position))

    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("Space Rocks")

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                quit()

        is_key_pressed = pygame.key.get_pressed()

        if self.spaceship:
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)
            if is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()

    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    break

    def _draw(self):
        self.screen.blit(self.background, (0, 0))

        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        pygame.display.flip()
        self.clock.tick(60)

    def _get_game_objects(self):
        game_objects = [*self.asteroids]

        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects
Esempio n. 8
0
class SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

    def __init__(self):
        self._init_pygame()
        # Adjust Screen Size
        self.screen = pygame.display.set_mode((800, 600))
        # Customize Game Background
        self.background = load_sprite("industrial-background", False)
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ""

        self.asteroids = []
        self.bullets = []
        # Adjust player starting position: Spaceship((x, y))
        # Center of screen: (400, 300)
        # Far left center of screen: (20, 300)
        self.spaceship = Spaceship((100, 490), self.bullets.append)

        # Adjust number fo initial spawned asteroids: for _ in range(x)
        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break

            self.asteroids.append(Asteroid(position, self.asteroids.append))

    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("COVID Destroyer")

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                quit()
            elif (self.spaceship and event.type == pygame.KEYDOWN
                  and event.key == pygame.K_SPACE):
                self.spaceship.shoot()

        is_key_pressed = pygame.key.get_pressed()

        if self.spaceship:
            if is_key_pressed[pygame.K_RIGHT]:
                self.spaceship.rotate(clockwise=True)
            elif is_key_pressed[pygame.K_LEFT]:
                self.spaceship.rotate(clockwise=False)
            if is_key_pressed[pygame.K_UP]:
                self.spaceship.accelerate()

    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    self.message = "GAME OVER"
                    break

        for bullet in self.bullets[:]:
            for asteroid in self.asteroids[:]:
                if asteroid.collides_with(bullet):
                    self.asteroids.remove(asteroid)
                    self.bullets.remove(bullet)
                    asteroid.split()
                    break

        # Bullets automatically destroyed and don't return when screen is left:
        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)

        # Asteroids automatically destroyed and don't return when screen is left:
        for asteroid in self.asteroids[:]:
            if not self.screen.get_rect().collidepoint(asteroid.position):
                self.asteroids.remove(asteroid)

        # Logic dictating enemy sprites bounce off top and bottom screen
        # if asteroid.bottom >= HEIGHT or asteroid.top <= 0:
        #     asteroid.direction = dx, -dy

        # Game message if all enemy sprites destroyed
        if not self.asteroids and self.spaceship:
            self.message = "WINNER"

    def _draw(self):
        self.screen.blit(self.background, (0, 0))

        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        if self.message:
            print_text(self.screen, self.message, self.font)

        pygame.display.flip()
        self.clock.tick(60)

    def _get_game_objects(self):
        game_objects = [*self.asteroids, *self.bullets]

        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects
Esempio n. 9
0
class SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

    def __init__(self):
        self._init_pygame()
        self.screen = pygame.display.set_mode((800, 600))
        self.background = load_sprite("space", False)
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 64)
        self.message = ""

        self.asteroids = []
        self.bullets = []
        self.spaceship = Spaceship((400, 300), self.bullets.append)

        for _ in range(6):
            while True:
                position = get_random_position(self.screen)
                if (position.distance_to(self.spaceship.position) >
                        self.MIN_ASTEROID_DISTANCE):
                    break

            self.asteroids.append(Asteroid(position, self.asteroids.append))

    def main_loop(self):
        clock = pygame.time.Clock()
        clock.tick(120)
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("AstroBit")
        global rm
        rm = Read_Microbit()
        rm.start()

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
                                             and event.key == pygame.K_ESCAPE):
                pygame.quit()
                quit()
                rm.terminate()
                rm.join()
            elif (q.get().startswith("shot")):
                self.spaceship.shoot()

        if self.spaceship:
            if q.get().startswith("right"):
                self.spaceship.rotate(clockwise=True)
            elif q.get().startswith("left"):
                self.spaceship.rotate(clockwise=False)
            if q.get().startswith("up"):
                self.spaceship.accelerate()
            if q.get().startswith("down"):
                self.spaceship.decelerate()
            if q.get().startswith("shot"):
                self.spaceship.shoot()
        q.task_done()

    def _process_game_logic(self):
        for game_object in self._get_game_objects():
            game_object.move(self.screen)

        if self.spaceship:
            for asteroid in self.asteroids:
                if asteroid.collides_with(self.spaceship):
                    self.spaceship = None
                    self.message = "You lost!"
                    break

        for bullet in self.bullets[:]:
            for asteroid in self.asteroids[:]:
                if asteroid.collides_with(bullet):
                    self.asteroids.remove(asteroid)
                    self.bullets.remove(bullet)
                    asteroid.split()
                    break

        for bullet in self.bullets[:]:
            if not self.screen.get_rect().collidepoint(bullet.position):
                self.bullets.remove(bullet)

        if not self.asteroids and self.spaceship:
            self.message = "You won!"

    def _draw(self):
        self.screen.blit(self.background, (0, 0))

        for game_object in self._get_game_objects():
            game_object.draw(self.screen)

        if self.message:
            print_text(self.screen, self.message, self.font)

        pygame.display.flip()
        self.clock.tick(60)

    def _get_game_objects(self):
        game_objects = [*self.asteroids, *self.bullets]

        if self.spaceship:
            game_objects.append(self.spaceship)

        return game_objects