balsdf

# Pygame imports
import pygame, pygame.mixer
from pygame import Surface
from pygame.image import load
from pygame.locals import *
from pygame.mixer import music
from pygame.rect import Rect
from pygame.sprite import Group, Sprite

# Path imports
from os.path import join

# Random imports
from random import randint, choice

# Microgame-specific imports
import locals
from microgame import Microgame
################################################################################
# Extra Functions #

# Determines what type of collision occurs *only called when one does occur
REFLECT_X = 1
REFLECT_Y = 2
REFLECT_BOTH = 3

def determine_collision(rect1, rect2):
    tl = not rect2.collidepoint(rect1.topleft)
    bl = not rect2.collidepoint(rect1.bottomleft)
    tr = not rect2.collidepoint(rect1.topright)
    br = not rect2.collidepoint(rect1.bottomright)
    if (tl and bl and tr) or (tr and br and tl) or (tl and bl and br) or (tr and br and bl):
        return REFLECT_BOTH
    if (tl and bl) or (tr and br):
        return REFLECT_X
    else:
        return REFLECT_Y

##### LOADER-REQUIRED FUNCTIONS ################################################

def make_game():
    # TODO: Return a new instance of your Microgame class.
    return BrickBreaker()

def title():
    # TODO: Return the title of the game.
    return "#BrickBreaker"

def thumbnail():
    # TODO: Return a (relative path) to the thumbnail image file for your game.
    return join("games", "brick_breaker", "thumbnail.png")

def hint():
    # TODO: Return the hint string for your game.
    return "#Collect"

################################################################################

def _load_image(name, x, y):
    '''
    Loads an image file, returning the surface and rectangle corresponding to
    that image at the given location.
    '''
    try:
        image = load(name)
        if image.get_alpha is None:
            image = image.convert()
        else:
            image = image.convert_alpha()
    except pygame.error, msg:
        print 'Cannot load image: {}'.format(name)
        raise SystemExit, msg
    rect = image.get_rect().move(x, y)
    return image, rect

##### MODEL CLASSES ############################################################

# Global Vars

#Movement of Bar
MOVE_SPEED = 20

#Values for blocks
BLOCK_WIDTH = 100
BLOCK_HEIGHT = 40
INITIAL_BLOCK_X = 0
INITIAL_BLOCK_Y = 0
INITIAL_POS = randint(100, locals.WIDTH-100)

#Start Ball Speed
INIT_VELOCITY_X = choice([10, -10])
INIT_VELOCITY_Y = -10

#############################################################################

class BlockSprite(Sprite):
    def __init__(self, x, y):
        Sprite.__init__(self)
        self.block_options = ["blue.png", "red.png", "yellow.png", "orange.png", "green.png"]
        imgpath = join("games", "brick_breaker", choice(self.block_options))
        self.image, self.rect = _load_image(imgpath, x, y)

class BallSprite(Sprite):
    def __init__(self):
        Sprite.__init__(self)
        imgpath = join("games", "brick_breaker", "ball.png")
        self.image, self.rect = _load_image(imgpath, INITIAL_POS - 25, locals.HEIGHT - 45)
        self.velocity_x = INIT_VELOCITY_X
        self.velocity_y = INIT_VELOCITY_Y

    def update(self):
        self.rect = self.rect.move(self.velocity_x, self.velocity_y)

class BarSprite(Sprite):
    def __init__(self):
        Sprite.__init__(self)
        imgpath = join("games", "brick_breaker", "bar.png")
        self.image, self.rect = _load_image(imgpath, INITIAL_POS - 100, locals.HEIGHT - 20)
        self.velocity = 0

    def update(self):
        #Update Position
        self.rect = self.rect.move(self.velocity, 0)

##### MICROGAME CLASS ##########################################################

# TODO: rename this class to your game's name...

################################################################################
class BrickBreaker(Microgame):
    def __init__(self):
        Microgame.__init__(self)
        self.bar = BarSprite()
        self.ball = BallSprite()

        # Sound Effects
        self.break_sound = pygame.mixer.Sound(join("games", "brick_breaker", "break.wav"))
        self.bounce = pygame.mixer.Sound(join("games", "brick_breaker", "bounce.wav"))

        #Groups
        self.bar_group = Group(self.bar)
        self.ball_group = Group(self.ball)
        self.blocks = Group()
        self.build_board()

        #Constructs the layout of the blocks
    def build_board(self):
        position_x = INITIAL_BLOCK_X
        position_y = INITIAL_BLOCK_Y

        for block in range(0, 59):
            if position_x < locals.WIDTH/2 - 100 or (position_x >= locals.WIDTH/2 + 100 and position_x <= locals.WIDTH - 100):
                self.blocks.add(BlockSprite(position_x, position_y))
                position_x += BLOCK_WIDTH
            elif position_x == locals.WIDTH/2 - 100:
                position_x = locals.WIDTH/2 + 100
            else:
                position_y += 40
                position_x = INITIAL_BLOCK_X

    #Detect and determine types of Collisions
    def detect_collision(self):
        for block in pygame.sprite.spritecollide(self.ball, self.blocks, True):
            self.break_sound.play()
            return determine_collision(self.ball.rect, block.rect)

    #Check for Bar Deflection
    def deflection(self):
        for i in pygame.sprite.spritecollide(self.ball, self.bar_group, False):
            self.bounce.play()
            return True

    def start(self):
        # TODO: Startup code here
        pass

    def stop(self):
        # TODO: Clean-up code here
        pass

    def update(self, events):
        # Regular Updates
        self.bar_group.update()
        self.ball_group.update()
        self.blocks.update()

        # Set Bar Boundaries
        x, _ = self.bar.rect.topleft
        a, _ = self.bar.rect.topright
        if x <= 0 or a >= locals.WIDTH:
            self.bar.velocity = 0

        #Set Ball Boundaries
        e, f = self.ball.rect.topleft
        g, h = self.ball.rect.bottomright
        if e <= 0 or g >= locals.WIDTH:
            self.bounce.play()
            self.ball.velocity_x *= -1
        elif f <= 0:
            self.ball.velocity_y *= -1
            self.bounce.play()
        elif h >= locals.HEIGHT:
            self.lose()

        #Process Key Presses
        for event in events:
            if event.type == KEYUP:
                self.bar.velocity = 0
            elif event.type == KEYDOWN and event.key == K_LEFT and x >= 0:
                self.bar.velocity = -1*MOVE_SPEED
            elif event.type == KEYDOWN and event.key == K_RIGHT and a <= locals.WIDTH:
                self.bar.velocity = MOVE_SPEED

        #Process Collisions Between Ball and Bricks
        reflection = self.detect_collision()
        if  reflection == REFLECT_BOTH:
            self.ball.velocity_y *=-1
            self.ball.velocity_x *=-1
        elif reflection == REFLECT_Y:
            self.ball.velocity_y *= -1
        elif reflection == REFLECT_X:
            self.ball.velocity_x *= -1

        # Process collisions between bar and ball
        if self.deflection():
            self.ball.velocity_y *= -1

            # Random Change in X Velocity When Deflected
            self.ball.velocity_x += randint(0, 10) * choice([-1, 1])
            if self.ball.velocity_x < -7:
                self.ball.velocity_x = -1
            elif self.ball.velocity_x > 7:
                self.ball.velocity_x = 7

        #Check for Win
        if len(self.blocks) == 0:
            self.win()

    def render(self, surface):
        # TODO: Rendering code here
        surface.fill(Color(0, 0, 0))
        self.bar_group.draw(surface)
        self.ball_group.draw(surface)
        self.blocks.draw(surface)

    def get_timelimit(self):
        # TODO: Return the time limit of this game (in seconds, 0 <= s <= 15)
        return 120