added a brickout-game in pygame + uml digramm

I added a brickout-game in pygame + uml diagram for representing the classes and its relations.

brickout-game/README.md

@@ -0,0 +1,13 @@
+# Brickout-Game in pygame
+
+This is a simple brickout-game. It's includes ball, paddle, brick wall 
+and additional collision detection between this objects. Furthermore logic for winning and losing and
+scoring. The game is written in **Python 2**. 
+
+You start the game with ```python game.py```
+
+The game runs with 60 frames per second. 
+
+I used a code sample for the basic structure of pygame from this site [http://programarcadegames.com/](http://programarcadegames.com/)
+The site contains a comprehensive introduction in Python and Pygame. In addition many many examples.
+

brickout-game/brickout-game.py

@@ -0,0 +1,342 @@
+"""
+ Pygame base template for opening a window
+ 
+ Sample Python/Pygame Programs
+ Simpson College Computer Science
+ http://programarcadegames.com/
+ http://simpson.edu/computer-science/
+ 
+ Explanation video: http://youtu.be/vRB_983kUMc
+
+-------------------------------------------------
+
+Author for the Brickout game is Christian Bender
+That includes the classes Ball, Paddle, Brick, and BrickWall.
+
+"""
+
+import pygame
+
+
+# Define some colors
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+GREEN = (0, 255, 0)
+RED = (255, 0, 0)
+
+pygame.init()
+
+# Set the width and height of the screen [width, height]
+size = (700, 500)
+screen = pygame.display.set_mode(size)
+
+"""
+    This is a simple Ball class for respresenting a ball 
+    in the game. 
+"""
+class Ball(object):
+    def __init__ (self, screen, radius,x,y):
+        self.__screen = screen
+        self._radius = radius
+        self._xLoc = x
+        self._yLoc = y
+        self.__xVel = 5
+        self.__yVel = -3
+        w, h = pygame.display.get_surface().get_size()
+        self.__width = w
+        self.__height = h
+    def draw(self):
+        """
+            draws the ball onto screen.
+        """
+        pygame.draw.circle(screen,(255, 0, 0) , (self._xLoc,self._yLoc), self._radius)
+    def update(self, paddle, brickwall):
+        """
+            moves the ball at the screen.
+            contains some collision detection.
+        """
+        self._xLoc += self.__xVel
+        self._yLoc += self.__yVel
+        if self._xLoc == self._radius:
+            self.__xVel *= -1
+        elif self._xLoc >= self.__width - self._radius:
+            self.__xVel *= -1
+        if self._yLoc == self._radius:
+            self.__yVel *= -1
+        elif self._yLoc >= self.__height - self._radius:
+            return True
+
+        # for bouncing off the bricks.
+        if brickwall.collide(self):
+            self.__yVel *= -1
+
+        # collision deection between ball and paddle
+        paddleX = paddle._xLoc
+        paddleY = paddle._yLoc
+        paddleW = paddle._width
+        paddleH = paddle._height
+        ballX = self._xLoc
+        ballY = self._yLoc
+
+        if ((ballX + self._radius) >= paddleX and ballX <= (paddleX + paddleW)) \
+        and ((ballY + self._radius) >= paddleY and ballY <= (paddleY + paddleH)):
+            self.__yVel *= -1
+
+        return False
+
+
+"""
+    Simple class for representing a paddle
+"""        
+class Paddle (object):
+    def __init__ (self, screen, width, height,x,y):
+        self.__screen = screen
+        self._width = width
+        self._height = height
+        self._xLoc = x
+        self._yLoc = y
+        w, h = pygame.display.get_surface().get_size()
+        self.__W = w
+        self.__H = h
+    def draw(self):
+        """
+            draws the paddle onto screen.
+        """
+        pygame.draw.rect(screen, (0,0,0), (self._xLoc,self._yLoc,self._width,self._height),0)
+    def update(self):
+        """
+            moves the paddle at the screen via mouse
+        """
+        x,y = pygame.mouse.get_pos()
+        if x >= 0 and x <= (self.__W - self._width):
+            self._xLoc = x
+
+"""
+    This class represents a simple Brick class.
+    For representing bricks onto screen.
+"""
+class Brick (pygame.sprite.Sprite):
+    def __init__(self, screen, width, height, x,y):
+        self.__screen = screen
+        self._width = width
+        self._height = height
+        self._xLoc = x
+        self._yLoc = y
+        w, h = pygame.display.get_surface().get_size()
+        self.__W = w
+        self.__H = h
+        self.__isInGroup = False
+    def draw(self):
+        """
+            draws the brick onto screen.
+            color: rgb(56, 177, 237)
+        """
+        pygame.draw.rect(screen, (56, 177, 237), (self._xLoc,self._yLoc,self._width,self._height),0)
+    def add (self, group):
+        """
+            adds this brick to a given group.
+        """
+        group.add(self)
+        self.__isInGroup = True
+    def remove(self, group):
+        """
+            removes this brick from the given group.
+        """
+        group.remove(self)
+        self.__isInGroup = False
+    def alive(self):
+        """
+            returns true when this brick is belong to the brick wall.
+            otherwise false
+        """
+        return self.__isInGroup
+
+    def collide(self, ball):
+        """
+            collision deection between ball and this brick
+        """
+        brickX = self._xLoc
+        brickY = self._yLoc
+        brickW = self._width
+        brickH = self._height
+        ballX = ball._xLoc
+        ballY = ball._yLoc
+        radius = ball._radius
+
+        if ((ballX + radius) >= brickX and ballX <= (brickX + brickW)) \
+        and ((ballY + radius) >= brickY and ballY <= (brickY + brickH)):
+            return True
+
+        return False
+
+
+"""
+    This is a simple class for representing a 
+    brick wall.
+"""
+class BrickWall (pygame.sprite.Group):
+    def __init__ (self,screen, x, y, width, height):
+        self.__screen = screen
+        self._x = x
+        self._y = y
+        self._width = width
+        self._height = height
+        self._bricks = []
+
+        X = x
+        Y = y
+        for i in range(3):
+            for j in range(4):
+                self._bricks.append(Brick(screen,width,height,X,Y))
+                X += width + (width/ 7.0)
+            Y += height + (height / 7.0)
+            X = x
+
+    def add(self,brick):
+        """
+            adds a brick to this BrickWall (group)
+        """
+        self._bricks.append(brick)
+    def remove(self,brick):
+        """
+            removes a brick from this BrickWall (group)
+        """
+        self._bricks.remove(brick)
+    def draw(self):
+        """
+            draws all bricks onto screen.
+        """
+        for brick in self._bricks:
+            if brick != None:
+                brick.draw()
+    def update(self, ball):
+        """
+            checks collision between ball and bricks.
+        """
+        for i in range(len(self._bricks)):
+            if ((self._bricks[i] != None) and self._bricks[i].collide(ball)):
+                self._bricks[i] = None
+
+        # removes the None-elements from the brick list.
+        for brick in self._bricks:
+            if brick == None:
+                self._bricks.remove(brick)
+    def hasWin(self):
+        """
+            Has player win the game?
+        """
+        return len(self._bricks) == 0
+    def collide (self, ball):
+        """
+            check collisions between the ball and 
+            any of the bricks.
+        """
+        for brick in self._bricks:
+            if brick.collide(ball):
+                return True
+        return False
+
+# The game objects ball, paddle and brick wall
+ball = Ball(screen,25,350,250)
+paddle = Paddle(screen,100,20,250,450)
+brickWall = BrickWall(screen,25,25,150,50)
+
+isGameOver = False # determines whether game is lose
+gameStatus = True # game is still running
+
+score = 0 # score for the game.
+
+pygame.display.set_caption("Brickout-game")
+
+# Loop until the user clicks the close button.
+done = False
+
+# Used to manage how fast the screen updates
+clock = pygame.time.Clock()
+
+# for displaying text in the game 
+pygame.font.init() # you have to call this at the start, 
+                   # if you want to use this module.
+
+# message for game over
+mgGameOver = pygame.font.SysFont('Comic Sans MS', 60)
+
+# message for winning the game.
+mgWin = pygame.font.SysFont('Comic Sans MS', 60)
+
+# message for score
+mgScore = pygame.font.SysFont('Comic Sans MS', 60)
+
+textsurfaceGameOver = mgGameOver.render('Game Over!', False, (0, 0, 0))
+textsurfaceWin = mgWin.render("You win!",False,(0,0,0))
+textsurfaceScore = mgScore.render("score: "+str(score),False,(0,0,0))
+
+
+# -------- Main Program Loop -----------
+while not done:
+    # --- Main event loop
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            done = True
+
+    # --- Game logic should go here
+
+    # --- Screen-clearing code goes here
+
+    # Here, we clear the screen to white. Don't put other drawing commands
+    # above this, or they will be erased with this command.
+
+    # If you want a background image, replace this clear with blit'ing the
+    # background image.
+    screen.fill(WHITE)
+
+    # --- Drawing code should go here
+
+    """
+        Because I use OOP in the game logic and the drawing code,
+        are both in the same section.
+    """
+    if gameStatus:
+
+        # first draws ball for appropriate displaying the score. 
+        brickWall.draw()
+
+         # for counting and displaying the score
+        if brickWall.collide(ball):
+            score += 10
+        textsurfaceScore = mgScore.render("score: "+str(score),False,(0,0,0))
+        screen.blit(textsurfaceScore,(300,0))
+
+        # after scoring. because hit bricks are removed in the update-method
+        brickWall.update(ball)
+
+        paddle.draw()
+        paddle.update()
+
+        if ball.update(paddle, brickWall):
+            isGameOver = True
+            gameStatus = False
+
+        if brickWall.hasWin():
+            gameStatus = False
+
+        ball.draw()
+
+    else: # game isn't running.
+        if isGameOver: # player lose
+            screen.blit(textsurfaceGameOver,(0,0))
+            textsurfaceScore = mgScore.render("score: "+str(score),False,(0,0,0))
+            screen.blit(textsurfaceScore,(300,0))
+        elif brickWall.hasWin(): # player win
+            screen.blit(textsurfaceWin,(0,0))
+            textsurfaceScore = mgScore.render("score: "+str(score),False,(0,0,0))
+            screen.blit(textsurfaceScore,(300,0))
+
+    # --- Go ahead and update the screen with what we've drawn.
+    pygame.display.flip()
+
+    # --- Limit to 60 frames per second
+    clock.tick(60)
+
+# Close the window and quit.
+pygame.quit()