Bricky - A Breakout Clone in Pygame

Question

I've been working on learning Pygame and I made a Breakout clone. I'm looking for stylistic advice and overall suggestions for improvement.

Controls are simple: - ← and → to move.

# Breakout/Arkanoid clone

import pygame, sys
from pygame.locals import *
import math

# General game attributes
FPS = 100
WINDOWWIDTH = 480
WINDOWHEIGHT = 600
MAXLEVEL = 6

# Ball attributes
BALLSTARTINGX = 0
BALLSTARTINGY = 250
BALLSPEED = 6 # pixels per tick
STARTINGANGLE = 60

# Paddle attributes
PADDLEWIDTH = 100
PADDLEHEIGHT = 10
PADDLESTARTINGX = (WINDOWWIDTH-PADDLEWIDTH)/2
PADDLEY = WINDOWHEIGHT-PADDLEHEIGHT
PADDLESPEED = 6
# Brick attributes
BRICKWIDTH = 50
BRICKHEIGHT = 25
SIDEBUFFER = 15
TOPBUFFER = 220

# Colors
WHITE       = (255, 255, 255)
NAVYBLUE    = ( 60,  60, 100)
RED         = (200,   0,   0)
DARKRED     = (100,   0,   0)
ORANGE      = (200, 100,   0)
DARKORANGE  = (100,  50,   0)
YELLOW      = (200, 200,   0)
DARKYELLOW  = (100, 100,   0)
GREEN       = (  0, 200,   0)
DARKGREEN   = (  0, 100,   0)
BLUE        = (  0,   0, 200)
DARKBLUE    = (  0,   0, 100)
PURPLE      = (200,   0, 200)
DARKPURPLE  = (100,   0, 100)

RAINBOW = [(RED, DARKRED),(ORANGE,DARKORANGE),(YELLOW,DARKYELLOW),
           (GREEN,DARKGREEN),(BLUE,DARKBLUE),(PURPLE,DARKPURPLE)]

def main():
    global FPSCLOCK, DISPLAYSURF, FONT
    pygame.init()

    # Globals
    FPSCLOCK = pygame.time.Clock()
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

    # Caption
    pygame.display.set_caption("Bricky")

    # Game objects
    ball = Ball(DISPLAYSURF)
    paddle = Paddle(DISPLAYSURF)
    game_board = Game_board(DISPLAYSURF)

    new_level = True

    # Font
    FONT = pygame.font.Font('freesansbold.ttf', 18)

    # Text objects
    text_newlevel_surf = FONT.render("New level!", True, WHITE, NAVYBLUE)
    text_newlevel = text_newlevel_surf.get_rect()
    text_newlevel.center = (WINDOWWIDTH/2, WINDOWHEIGHT/2)

    text_youwin_surf = FONT.render("YOU WIN!", True, WHITE, NAVYBLUE)
    text_youwin = text_newlevel_surf.get_rect()
    text_youwin.center = (WINDOWWIDTH/2, WINDOWHEIGHT/2)

    text_gamestart_surf = FONT.render("Game start!", True, WHITE, NAVYBLUE)
    text_gamestart = text_newlevel_surf.get_rect()
    text_gamestart.center = (WINDOWWIDTH/2, WINDOWHEIGHT/2)

    text_youlose_surf = FONT.render("YOU LOSE!", True, WHITE, NAVYBLUE)
    text_youlose = text_newlevel_surf.get_rect()
    text_youlose.center = (WINDOWWIDTH/2, WINDOWHEIGHT/2)

    # Main loop
    while True:
        DISPLAYSURF.fill(NAVYBLUE)
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                if(event.key == K_LEFT):
                    paddle.direction -= paddle.speed
                elif(event.key == K_RIGHT):
                    paddle.direction += paddle.speed
            elif event.type == KEYUP:
                if(event.key == K_LEFT):
                    paddle.direction += paddle.speed
                elif(event.key == K_RIGHT):
                    paddle.direction -= paddle.speed

        if new_level:
            game_board.new_board()
            ball.posx, ball.posy = BALLSTARTINGX, BALLSTARTINGY
            ball.angle = STARTINGANGLE
            new_level = False
            paddle.posx = PADDLESTARTINGX

        bricks_cleared = len(game_board.brickarray) == 0
        if bricks_cleared:
            if game_board.roundnum == MAXLEVEL:
                DISPLAYSURF.fill(NAVYBLUE)
                DISPLAYSURF.blit(text_youwin_surf, text_youwin)
                pygame.display.update()
                pygame.time.wait(1000)
            else:
                new_level = True
                DISPLAYSURF.fill(NAVYBLUE)
                if game_board.roundnum == 0:
                    DISPLAYSURF.blit(text_gamestart_surf, text_gamestart)
                else:
                    DISPLAYSURF.blit(text_newlevel_surf, text_newlevel)
                pygame.display.update()
                pygame.time.wait(1000)
                game_board.roundnum += 1
        elif ball.ballsremaining == -1:
            DISPLAYSURF.fill(NAVYBLUE)
            DISPLAYSURF.blit(text_youlose_surf, text_youlose)
            pygame.display.update()
            pygame.time.wait(2000)
            new_level = True
            game_board.roundnum = 0
            ball.ballsremaining = 3



        else:
            paddle.update()
            ball.update(paddle.posx, game_board.brickarray) # Handle ball collisions
            game_board.update(ball.brickarray) # Destroy bricks colliding with ball

        pygame.display.update()
        FPSCLOCK.tick(FPS)


class Game_board(object):
    def __init__(self, surface):
        self.surf = surface
        self.roundnum = 6
    def draw_brick(self, x, y, color):
        pygame.draw.rect(self.surf, color[0], (x,y,BRICKWIDTH, BRICKHEIGHT))
        pygame.draw.rect(self.surf, color[1], (x,y,BRICKWIDTH,BRICKHEIGHT), 3)
    def draw_board(self):
        for brick in self.brickarray:
            self.draw_brick(brick[1][0], brick[1][1], RAINBOW[brick[0][1]])
    def new_board(self):
        self.brick_indexes = zip(range(9)*self.roundnum, [i for i in range(self.roundnum) for _ in range(9)])
        self.brick_positions = [(SIDEBUFFER + x * BRICKWIDTH, (TOPBUFFER-(y*BRICKHEIGHT*1.5))) for x,y in self.brick_indexes]
        self.brickarray = zip(self.brick_indexes, self.brick_positions)
    def update(self, brickarray):
        self.brickarray = brickarray
        self.draw_board()


class Paddle(Game_board):
    def __init__(self, surf):
        """
        Initialize paddle. Paddle starts in the middle. Speed is constant.
        """
        self.surf = surf
        self.posx, self.posy = PADDLESTARTINGX, PADDLEY
        self.speed = PADDLESPEED
        self.direction = 0
        pygame.draw.rect(self.surf, WHITE,(self.posx, self.posy, PADDLEWIDTH, PADDLEHEIGHT))
    def update(self):
        """
        Move paddle if the left or right key is held down. Do not allow
        paddle to move out of bounds.
        """
        #############################
        # Handling movement of paddle
        #############################
        self.posx += self.direction
        ##############################################
        # Making sure paddle does not go out of bounds
        ##############################################
        if self.posx < 0:
            self.posx = 0
        if self.posx > WINDOWWIDTH-PADDLEWIDTH:
            self.posx = WINDOWWIDTH-PADDLEWIDTH
        # Drawing paddle
        pygame.draw.rect(self.surf, WHITE,(self.posx, self.posy, PADDLEWIDTH, PADDLEHEIGHT))


class Ball(object):
    """
    Ball object for Bricky game. Handles collision detection and bouncing.
    """
    def __init__(self, surf):
        """
        Initialize ball. Ball always starts in same position with same
        angle. Speed is constant throughout the game.
        """
        self.posx,self.posy = BALLSTARTINGX,BALLSTARTINGY
        self.speed = BALLSPEED
        self.angle = STARTINGANGLE
        self.surf = surf
        self.ballsremaining = 3

        pygame.draw.circle(self.surf, WHITE, (self.posx,self.posy), 5, 0)

    def update(self, paddlex, brickarray):
        self.brickarray = brickarray
        """
        Calculate position of ball at next tick. If no collision occurs,
        ball's position will change based on current angle and speed.

        If ball bounces off of a brick or a wall, position will not
        change this tick but angle will update to reflect the direction
        the ball is facing, based on its angle before the collision.

        If ball bounces off of the paddle, again position will not
        change but angle will update based off of the location on the
        paddle that the ball hit: the closer to the center the ball hits,
        the closer to a vertical angle the ball will have. Hitting towards
        the edges will give the ball a steeper angle closer to
        0 or 180.
        """
        ############################
        # Displaying remaining balls
        ############################
        text_ballsremaining_surf = FONT.render("Balls left: {}".format(self.ballsremaining), True, WHITE, NAVYBLUE)
        text_ballsremaining = text_ballsremaining_surf.get_rect()
        text_ballsremaining.center = (55, 10)
        self.surf.blit(text_ballsremaining_surf, text_ballsremaining)
        ######################################
        # Next position if no collision occurs
        ######################################
        # Next position depends on current angle and speed
        xdif = int(math.cos(self.angle*(math.pi/180)) * self.speed)
        ydif = int(math.sin(self.angle*(math.pi/180)) * self.speed)

        ########################
        # Bouncing off of bricks
        ########################
        ycollission = [ y1 < (self.posy + ydif) < y2 for y1, y2 in [ (y, y+BRICKHEIGHT) for x,y in [ b[1] for b in self.brickarray ] ]]
        xcollission = [ x1 < (self.posx + xdif) < x2 for x1, x2 in [ (x, x+BRICKWIDTH) for x,y in [ b[1] for b in self.brickarray ] ]]

        collissions = [ xcollission[i] and ycollission[i] for i in range(len([ b[1] for b in self.brickarray ]))]

        if any(collissions):
            collided = self.brickarray.pop([ i for i in range(len(collissions)) if collissions[i] ][0])[1]
            if (self.posx <= collided[0]) and (collided[0] <= (self.posx + xdif) <= collided[0]+BRICKWIDTH):
                if self.angle < 90:
                    adj = (90 - (self.angle%90))*2 # Change angle clockwise
                else:
                    adj = -(self.angle%90)*2 # change angle counter-clockwise
            elif (self.posx >= (collided[0]+BRICKWIDTH)) and (collided[0] <= (self.posx + xdif) <= collided[0]+BRICKWIDTH):
                if self.angle < 180:
                    adj = -(self.angle%90)*2 # Change angle counter-clockwise
                else:
                    adj = (90 - (self.angle%90))*2 # Change angle clockwise
            elif (self.posy <= collided[1]) and (collided[1] <= (self.posy + ydif) <= collided[1]+BRICKHEIGHT):
                if self.angle < 90:
                    adj = -(self.angle%90)*2 # Change angle counter-clockwise
                else:
                    adj = (90 - (self.angle%90))*2 # Change angle clockwise
            elif (self.posy >= collided[1]+BRICKHEIGHT) and (collided[1] <= (self.posy + ydif) <= collided[1]+BRICKHEIGHT):
                if self.angle < 270:
                    adj = -(self.angle%90)*2 # Change angle counter-clockwise
                else:
                    adj = (90 - (self.angle%90))*2 # Change angle clockwise

            self.angle = (self.angle + adj) % 360


        ##########################################
        # Bouncing against window borders
        ##########################################
        if not (0 < (self.posx + xdif) < WINDOWWIDTH): #Bounce off wall
            if (90 <= self.angle <= 180) or (270 <= self.angle <= 360):
                adj = -(self.angle%90)*2 # Change angle counterclockwise
            else:
                adj = (90 - (self.angle%90))*2 # Change angle clockwise
            self.angle  = (self.angle + adj) % 360

        elif self.posy + ydif < 0: # Bounce off ceiling
            if (90 <= self.angle <= 180) or (270 <= self.angle <= 360):
                adj = (90 - (self.angle%90))*2 # Change angle clockwise
            else:
                adj = -(self.angle%90)*2 # Change angle counterclockwise
            self.angle = (self.angle + adj) % 360
        ##############################################
        # Bouncing off paddle or falling out of bounds
        ##############################################
        elif WINDOWHEIGHT > self.posy + ydif > WINDOWHEIGHT-PADDLEHEIGHT: # Bounce off paddle or fall out of bounds
            if paddlex < self.posx < paddlex+PADDLEWIDTH:# Bounce off paddle
                if (270 <= self.angle <= 360):
                    adj = (90 - (self.angle%90))*2 # Change angle clockwise
                else:
                    adj = -(self.angle%90)*2 # Change angle counterclockwise
                #####
                # Angle changes based off of how far from the middle the ball has bounced
                #####
                paddleangle = (paddlex - self.posx) + PADDLEWIDTH/2
                paddleangle *= 130.0/PADDLEWIDTH
                self.angle = 270 - paddleangle
            else: # Ball falls out of bounds
                self.posx += xdif
                self.posy += ydif
                pygame.draw.circle(self.surf, WHITE, (self.posx,self.posy), 5, 0)




        ########################################
        # Movement if ball does not hit anything
        ########################################
        else:
            self.posx += xdif
            self.posy += ydif
            pygame.draw.circle(self.surf, WHITE, (self.posx,self.posy), 5, 0)

            if self.posy > WINDOWHEIGHT + 300:
                self.posx,self.posy = BALLSTARTINGX, BALLSTARTINGY
                self.angle = STARTINGANGLE
                self.ballsremaining -= 1



if __name__ == "__main__":
    main()

Answer 1

Avoid repetition

You have repetition that screams to become a function:

    adj = (90 - (self.angle%90))*2 # Change angle clockwise

    adj = -(self.angle%90)*2 # change angle counter-clockwise

Each one of this is repeated 6 times identical

Just write two easy functions:

def rotate_clockwise(angle):
    return (90 - (self.angle%90))*2

def rotate_counter_clockwise(angle):
    return -(self.angle%90)*2

And use those.

This also makes the code self-documenting removing the need for the # Change angle clockwise and # Change angle counter-clockwise comments

Answer 2

One suggestion is to avoid wildcard imports.
You can find some information and alternatives here.

Also in Ball.update you have a command before the docstring which is confusing.

Lastly you might want to use a tool like PyLint if you want to enforce some style guidelines. For example I see that several lines in your code exceed 80 characters and at some parts you have more than 3 empty lines which is not recommended.