Example #1
0
    def __init__(self, stage, pos_x, pos_y, circle_mass, radius, circle_elasticity, color):
        Ball.__init__(self, stage, pos_x, pos_y, circle_mass, radius, circle_elasticity, color)
        self.circle.collision_type = 1
        self.point_value = 0

        self.gun_bullet = pygame.image.load(self.stage.graphics_path + "gunbullet.png").convert_alpha()
        self.cannon_bullet = pygame.image.load(self.stage.graphics_path + "cannonbullet.png").convert_alpha()        
Example #2
0
 def __init__(self, x = 0.0, y = 0.0):
     Ball.__init__(self, x, y)
     if Bar.image is None:
         # This is the first time loading the sprite,
         # so we need to load the image data
         Bar.image = pg.image.load(os.path.join("data","bar.png")).convert()
         Bar.image.set_colorkey(0)
     self.image = Bar.image
     (self.rect.w, self.rect.h) = (self.image.get_rect().w, self.image.get_rect().h)
     self.infiniteMass = True
     self.moveable = False
Example #3
0
    def __init__(self, x, y):
        pygame.sprite.Sprite.__init__(self)
        Ball.__init__(self, x, y, 25, pygame.color.Color("Red"))
        self.image = pygame.transform.smoothscale(pygame.image.load("images/donkey_kong.png").convert_alpha(),
                                                  (self.radius*2, self.radius*2))

        self.vel = Vector(0, 0)
        self.mass = 1
        self.update_rect()
        self.colliding = False
        self.lives = 5
        self.angle = -90
        self.power = 50
Example #4
0
    def __init__(self, x, y, thrower):
        pygame.sprite.Sprite.__init__(self)
        Ball.__init__(self, x, y, 10, pygame.color.Color("Yellow"))
        self.init_image = pygame.transform.smoothscale(
            pygame.image.load("images/banana.png").convert_alpha(),
            (self.radius * 2, self.radius * 2))
        self.image = self.init_image

        self.vel = Vector(0, 0)
        self.mass = 10
        self.update_rect()
        self.hit = False
        self.colliding = False
        self.angle = 0
        self.thrower = thrower
Example #5
0
 def __init__(self, x = 0.0, y = 0.0):
     Ball.__init__(self)
     if Blobble.image is None:
         # This is the first time loading the sprite,
         # so we need to load the image data
         Blobble.image = pg.image.load(os.path.join("data","blobble.png")).convert()
         Blobble.image.set_colorkey(0)
     self.image = Blobble.image
     self.rect = self.image.get_rect()
     #self.radius = self.rect.w / 2.0
     self._setPosition(Vector(x, y))
     self.infiniteMass = False
     self.moveable = True
     self.xAccel = 0.0
     self.doJump = False
Example #6
0
 def __init__(self,x,y):
     Ball.__init__(self, x, y)
     self.randomize_color()
     self.set_speed(30)
Example #7
0
 def __init__(self,x,y):
     Ball.__init__(self,x,y)
     self._color = "BROWN"
     self.set_dimension(10, 10)
     self.time_count = 0
     self.set_speed(6)
Example #8
0
 def __init__(self, x,y):
     Ball.__init__(self, x, y)
     self._speed   = 5
     self._angle   = random.random()*math.pi*2
     self._image   = PhotoImage(file="ufo.gif")
Example #9
0
 def __init__(self, x, y):
     Ball.__init__(self, x, y)
     self._color = 'pink'
Example #10
0
 def __init__(self, x, y, parent):
     Ball.__init__(self, x, y)
     self.next = parent
     self.set_angle(parent.get_angle())
     self.color = 'Green'
Example #11
0
 def __init__(self, x, y):
     Ball.__init__(self, x, y)
Example #12
0
 def __init__(self, stage, swing, pos_x, pos_y, circle_mass, radius, circle_elasticity, color):
     Ball.__init__(self, stage, pos_x, pos_y, circle_mass, radius, circle_elasticity, color)
     self.swing = swing
     self.detached = False
Example #13
0
 def __init__(self, x, y, width, height, angle, speed):
     Ball.__init__(self, x, y, width, height, angle, speed)
     self.vision = 50
     self.randomize_angle()
Example #14
0
 def __init__(self, x, y):
     Ball.__init__(self,x,y)
     self.randomize_angle()
Example #15
0
 def __init__(self, x, y):
     self._r = random.randint(5, 15)
     Ball.__init__(self, x, y)
     self.count = 0
     self.color = random.choice(Special.colors)
Example #16
0
class Breakout:
    """Overall class to manage game assets and behaviors."""
    def __init__(self):
        """Initialize the game, and create game resources."""
        pygame.init()
        self.settings = 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("Breakout")

        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.paddle = Paddle(self)
        self.ball = Ball(self)
        self.all_sprites_list = pygame.sprite.Group()
        self.blocks = pygame.sprite.Group()

        self.play_button = Button(self, "Play")
        self.games_ran = 0

    def run_game(self):
        """Start the main loop for the game."""
        while True:
            clock.tick(60)
            self._check_events()

            if self.stats.game_active:
                self.paddle.update()
                self.paddle_collision()
                self.ball.update()
                self.check_ball_block_collision()
                self.check_ball_bottom()

            self._update_screen()

    def _check_events(self):
        """Respond to keypresses and mouse events."""
        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.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)

    def _check_keydown_events(self, event):
        """Respond to keypresses."""
        # Exit game if 'ESCAPE' key is pressed
        if event.key == pygame.K_ESCAPE:
            sys.exit()

    def _check_play_button(self, mouse_pos):
        """Start a new game when the player clicks Play."""
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            # Reset the game settings.
            self.games_ran += 1
            self.settings.initialize_dynamic_settings()
            # Reset the game statistics.
            self.stats.reset_stats()
            if self.games_ran == 1:
                # Fixes bug where the first ran game had an extra life
                self.stats.lives_left = 2
            self.stats.game_active = True
            self.sb.prep_score()
            self.sb.prep_level()
            self.sb.prep_balls()

            # Create a new row and center the ball
            self.create_row()
            self.ball.center_ball()

            # Hide the mouse cursor.
            pygame.mouse.set_visible(False)

    def paddle_collision(self):
        """Formulas to make the ball bounce off the paddle in a predictable fashion."""
        if self.ball.rect.colliderect(self.paddle):
            diff = (self.paddle.rect.x + self.settings.paddle_width / 2) - (
                self.ball.rect.x + self.settings.ball_radius / 2)
            self.ball.rect.y = self.screen.get_rect(
            ).height - self.settings.paddle_height - self.settings.ball_radius - 1
            self.ball.bounce(diff)

    def create_row(self):
        """Create the row of blocks."""
        for i in range(14):
            block = Block(LIGHT_BLUE, 105, 30)
            block.rect.x = 10 + i * 110
            block.rect.y = 60
            self.all_sprites_list.add(block)
            self.blocks.add(block)
        for i in range(14):
            block = Block(RED, 105, 30)
            block.rect.x = 10 + i * 110
            block.rect.y = 100
            self.all_sprites_list.add(block)
            self.blocks.add(block)
        for i in range(14):
            block = Block(ORANGE, 105, 30)
            block.rect.x = 10 + i * 110
            block.rect.y = 140
            self.all_sprites_list.add(block)
            self.blocks.add(block)
        for i in range(14):
            block = Block(LIME_GREEN, 105, 30)
            block.rect.x = 10 + i * 110
            block.rect.y = 180
            self.all_sprites_list.add(block)
            self.blocks.add(block)
        for i in range(14):
            block = Block(DARK_BLUE, 105, 30)
            block.rect.x = 10 + i * 110
            block.rect.y = 220
            self.all_sprites_list.add(block)
            self.blocks.add(block)

    def check_ball_block_collision(self):
        """Respond to ball-block collisions."""
        for block in self.blocks:
            if self.ball.rect.colliderect(block):
                self.ball.bounce(0)
                self.blocks.remove(block)
                self.stats.score += self.settings.block_points
                self.sb.prep_score()
                self.sb.check_high_score()
                # Change ball speed in correlation with block color
                if block.rect.y == 220:
                    self.settings.ball_speed = 12
                elif block.rect.y == 180:
                    self.settings.ball_speed = 14
                elif block.rect.y == 140:
                    self.settings.ball_speed = 16
                elif block.rect.y == 100:
                    self.settings.ball_speed = 18
                elif block.rect.y == 60:
                    self.settings.ball_speed = 20
        if not self.blocks:
            # Remake game and make it a new level
            self.stats.level += 1
            self.sb.prep_level()
            self.sb.prep_balls()
            self.ball.center_ball()
            sleep(1)
            self.ball.__init__(self)
            self.settings.ball_speed = 10
            self.create_row()
            self.ball.bounce(0)

    def check_ball_bottom(self):
        """Check if any ball have reached the bottom of the screen."""
        screen_rect = self.screen.get_rect()
        if self.ball.rect.bottom >= screen_rect.bottom:
            # Treat this the same as if the ship got hit.
            self.ball_lost()

    def ball_lost(self):
        """Respond to the ball hitting the bottom of the screen."""
        if self.stats.lives_left > 0:
            self.stats.lives_left -= 1
            self.sb.prep_balls()
            self.ball.center_ball()
            sleep(1)
            self.ball.__init__(self)
            self.settings.ball_speed = 10
        else:
            # End game if no lives are left
            self.stats.game_active = False
            self.blocks.empty()
            self.settings.ball_speed = 10
            pygame.mouse.set_visible(True)

    def _update_screen(self):
        """Update images on the screen and flip to the updated screen."""
        self.screen.fill(self.settings.bg_color)
        self.paddle.blitme()
        self.ball.blitme()
        self.blocks.draw(self.screen)
        self.sb.show_score()

        if not self.stats.game_active:
            self.play_button.draw_button()
        pygame.display.flip()
Example #17
0
def main_loop():
    start = False
    game_exit = False
    game_over = False

    player1 = Player(1, white, screen_width, screen_height)
    player2 = Player(2, white, screen_width, screen_height)

    ball = Ball(Direction.No, white, screen_width, screen_height)
    divider = Divider(white, screen_width)

    while not game_exit:
        for event in pygame.event.get():
            if event.type == QUIT:
                game_exit = True

            # Escape game when escape key is pressed
            if event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    game_exit = True

                # Move players with arrow keys and WASD
                if start:
                    if event.key == K_w:
                        player1.move_up()
                    if event.key == K_s:
                        player1.move_down()

                    if event.key == K_UP:
                        player2.move_up()
                    if event.key == K_DOWN:
                        player2.move_down()

                # Press Space to start game
                if event.key == K_SPACE:
                    if not start:
                        start = True
                        ball.__init__(Direction.Left, white, screen_width,
                                      screen_height)
                    if game_over:
                        main_loop()

            # Stop moving player if arrows or WASD is up
            if event.type == KEYUP:
                if event.key == K_w or event.key == K_s:
                    player1.stop()
                if event.key == K_UP or event.key == K_DOWN:
                    player2.stop()

        # Fill black background
        game_surface.fill(black)

        # Render game objects and UI
        if start:
            ball.draw(game_surface)
        divider.draw(game_surface, screen_height)

        player1.draw(game_surface, screen_height)
        player2.draw(game_surface, screen_height)

        if not start and not game_over:
            game_surface.blit(start_text, [240, 200])

        display_score(player1)
        display_score(player2)

        # Check collisions
        if not game_over:
            if ball.check_collision_player(
                    player1) or ball.check_collision_player(player2):
                ball.change_direction_horizontal()

            if ball.check_collision_wall(screen_height):
                ball.change_direction_vertical()

            if ball.check_score(player1, player2, screen_width) == player1:
                ball.__init__(Direction.Left, white, screen_width,
                              screen_height)
                player1.add_score()
            elif ball.check_score(player1, player2, screen_width) == player2:
                ball.__init__(Direction.Right, white, screen_width,
                              screen_height)
                player2.add_score()

        # Handle game winning
        if winner(player1, player2, ball) != None:
            player_win(winner(player1, player2, ball), ball)

            start = False
            game_over = True

        # Render game at 60 fps
        clock.tick(60)
        pygame.display.update()

    quit_game()
Example #18
0
 def __init__(self, x, y, r, color=(255, 0, 0)):
     """Initialize the game object."""
     Ball.__init__(self, (x, y), r)
     self.movement = [choice([-1.0, -0.5, 0.5, 1.0]) for _ in [1, 2]]
     self.__color = color
Example #19
0
    deadblocks = pygame.sprite.spritecollide(ball, blocks, True)
    deadmonsters = pygame.sprite.spritecollide(ball, monsters, True)
    destroychest = pygame.sprite.spritecollide(ball, chests, True)
    takecoin = pygame.sprite.spritecollide(player, bonuses, True)

    if len(deadblocks) > 0:
        ball.bounce(0)
        score += 10
    if len(deadmonsters) > 0:
        score += 500
        if len(monsters) == 0:
            game_over = True
    if len(takecoin) > 0:
        KK += 1
        Ball.width = 30
        Ball.height = 30
        Ball.speed = 7.5
        ball.__init__(KK)
    if len(destroychest) > 0:
        ball.bounce(0)
        x, y = ball.x, ball.y - 30
        bon = Coin(x, y, 15)
        allsprites.add(bon)
        bonuses.add(bon)
        score += 20

    allsprites.draw(screen)

    pygame.display.flip()

pygame.quit()
Example #20
0
File: main.py Project: sjk39/pong
    sc.update()
    #time.sleep(0.001)

    if ball.distance(paddle_one.pos()) < 40 or ball.distance(
            paddle_two.pos()) < 40:
        ball.move(1)
        #prevents ball getting 'stuck' to paddle
        ball.move(0)
    else:
        ball.move(0)
    #if ball y cor different to comp y cor, move to coords
    if ball.ycor() > paddle_two.ycor() and ball.xcor() > 200:
        paddle_two.up()
    elif ball.ycor() < paddle_two.ycor() and ball.xcor() > 200:
        paddle_two.down()
    #if ball goes out left add one to comp score and replace ball and vice versa
    if ball.xcor() < -400:
        scoreboard.increase_score_two()
        ball.color("black")
        ball.__init__()
    elif ball.xcor() > 400:
        scoreboard.increase_score_one()
        ball.color("black")
        ball.__init__()
    #if a player exceeds score limit end game
    if scoreboard.score_one > 9 or scoreboard.score_two > 9:
        scoreboard.game_over()
        game_on = False

sc.exitonclick()
Example #21
0
 def __init__(self,x,y):
     Ball.__init__(self,x,y)
     self._color = 'green'