Merge branch 'master' of github.com:lvl2/avocados

avocado.py

@@ -62,10 +62,10 @@ class Avocado:
                 self.has_been_pinned = True
                 self.is_still_falling = False
                 self.click.play()
-                return True
+                return True, self.rect.center
             else:
                 self.clickFail.play()
-                return False
+        return False, (0, 0)
         # BUG - isHit is called 4 times upon click which makes it return the
         # first time but fail the consecutive times
         #else:
@@ -80,10 +80,14 @@ class Avocado:
         return self.has_been_pinned
 
 
+    def checkBoundaries(self):
+        if self.rect.right > self.screen_width or self.rect.left < 0:
+            self.vx = -self.vx
+
+
     def move(self):
         if not self.has_been_pinned:
-            if self.rect.right > self.screen_width or self.rect.left < 0:
+            self.checkBoundaries()
-                self.vx = -self.vy
 
             if self.hasLanded():
                 self.destroy()

game.py

@@ -5,7 +5,7 @@ Avocados and stuff
 
 import os, random, sys
 import pygame
-import avocado, crystal, pingenerator
+import avocado, crystal, pingenerator, itext
 from pygame.locals import *
 from support.colors import *
 from interface import hud
@@ -17,18 +17,14 @@ class TheGame:
         """ Initialize the game """
         pygame.init()
         pygame.display.set_caption('Pin Avo, the Cado!')
-
+        self.clock = pygame.time.Clock()
-        displayInfo = pygame.display.Info()
+        self.initializeScreen()
-        self.resize = 1.3
-
-        self.WIDTH = int(displayInfo.current_w / self.resize)
-        self.HEIGHT = int(displayInfo.current_h / self.resize)
-
-        self.WIDTH, self.HEIGHT = 800, 600
 
         # initialize the game canvas
-        self.size = (self.WIDTH, self.HEIGHT)
+        self.timeout = 30
-        self.screen = pygame.display.set_mode(self.size)
+        self.level = 1
+        self.targetScore = 400
+        self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
         self.colors = [BLUE, GREEN, RED, YELLOW]
         self.bg = pygame.image.load(os.path.join('img', 'lawyerCrystalBall.png'))
         self.bg.set_colorkey((255,255,255))
@@ -39,7 +35,13 @@ class TheGame:
 
         # Set splashscreen
         splashScreen = pygame.image.load("img/splashScreen.png")
-        self.screen.blit(pygame.transform.scale(splashScreen, self.size), (0, 0))
+        self.screen.blit(
+            pygame.transform.scale(
+                splashScreen, (self.WIDTH, self.HEIGHT)
+            ),
+            (0, 0)
+        )
+
         pygame.display.flip()
         pygame.time.wait(3000)
 
@@ -52,6 +54,17 @@ class TheGame:
             sound = False
 
 
+    def initializeScreen(self):
+        # displayInfo = pygame.display.Info()
+        # self.resize = 1.3
+
+        # self.WIDTH = int(displayInfo.current_w / self.resize)
+        # self.HEIGHT = int(displayInfo.current_h / self.resize)
+
+        # Look at the cleverness ;)
+        self.WIDTH, self.HEIGHT = 800, 600
+
+
     def mute(self,mute=False, sound=True):
         if not sound:
             return
@@ -84,11 +97,12 @@ class TheGame:
 
 
     def gameOver(self):
-        screen_width, screen_height = self.size
+        screen_width, screen_height = self.screen.get_size()
         gameOverImage = pygame.image.load("img/gameOver.png")
         gameOverText = self.bigFont.render('GAME OVER', 0, YELLOW)
         gameOverImage.blit(gameOverText, (screen_width/8, screen_height/7))
-        self.screen.blit(pygame.transform.scale(gameOverImage, self.size), (0, 0))
+        self.screen.blit(pygame.transform.scale(gameOverImage,
+                         self.screen.get_size()), (0, 0))
         pygame.display.flip()
         self.fadeSound()
         pygame.time.wait(3000)
@@ -104,28 +118,35 @@ class TheGame:
         if type(self.bg) is tuple:
             self.screen.fill(self.bg)
         else:
-            self.screen.blit(pygame.transform.scale(self.bg, self.size), (0, 0))
+            self.screen.blit(
+                pygame.transform.scale(
+                    self.bg, self.screen.get_size()
+                ),
+                (0, 0)
+            )
+
+
+    def resetLevel(self):
+        self.pinnedAvocados = []
+        self.movingAvocados = []
+        self.thrownPins = []
+        self.timeleft = self.timeout
 
 
     def main(self):
-        clock = pygame.time.Clock()
         desired_fps = 60
+
+        ##############################
         # Never set below 4, else we have a high
         # probability of losing the game due to a missing color
         # Alternatively, you could edit chooseRandomColor()
         # to only work on the first multiplier colors
         multiplier = 4
-        time = timeleft = 30
-        level = 1
-        levelChange = 0
         score = 0
-        targetScore = 400
 
         # We could use this list for redrawing only this part
         # of the screen install of all of it
-        pinnedAvocados = []
+        self.resetLevel()
-        movingAvocados = []
-        thrownPins = []
 
         # initialize the HUD class and the lawyer
         the_hud = hud.Hud(self.screen)
@@ -135,85 +156,95 @@ class TheGame:
         color = self.chooseRandomColor()
         crystalBall.setColor(color)
 
+        texts = []
+        container = {'font': self.bigFont, 'screen': self.screen, 'clock': self.clock}
+        # onetext = itext.Text(container, 'Huhu', 2000)
+        # texts.append(onetext)
+
         running = True
         while running:
-            time_passed = clock.tick(desired_fps)
+            time_passed = self.clock.tick(desired_fps)
-            fps = clock.get_fps()
+            fps = self.clock.get_fps()
-            screen_width, screen_height = self.size
+            screen_width, screen_height = self.screen.get_size()
 
             # Redraw the background and put our lawyer back on top
             self.drawBackground()
             crystalBall.blitme()
 
             # Next level?
-            if score >= (targetScore * level):
+            if score >= (self.targetScore * self.level):
-                level += 1
+                self.level += 1
-                levelChange = 70
+                levelText = itext.Text(
-                timeleft = time
+                    container,
-                print('DEBUG :: Score: ' + str(score))
+                    'Level ' + str(self.level),
-                print('DEBUG :: Level ' + str(level))
+                    (screen_width / 3, screen_height /2),
-                self.playLevel(level)
+                    2000
-                pinnedAvocados = []
+                )
-                movingAvocados = []
+                texts.append(levelText)
-                thrownPins = []
+                # self.screen.blit(levelText, (screen_width / 3, screen_height / 2))
+                self.playLevel(self.level)
+                self.resetLevel()
 
-            if levelChange > 0:
-                levelText = self.bigFont.render('Level ' + str(level), 0, WHITE)
-                self.screen.blit(levelText, (screen_width / 3, screen_height / 2))
-                levelChange -= 1
 
-            timeleft -= time_passed / 1000
+            self.timeleft -= time_passed / 1000
-            timeleft = round(timeleft, 2)
+            self.timeleft = round(self.timeleft, 2)
-            if timeleft <= 0:
+            if self.timeleft <= 0:
                 self.gameOver()
             else:
-                displaytime = timeleft
+                displaytime = self.timeleft
+
+
+            # Check if there's any text that wants to get displayed
+            for text in texts:
+                text.blitme()
+                texts[:] = [text for text in texts if not text.hasExpired() ]
+
 
             # Redraw the HUD
             the_hud.draw_hud(score, displaytime, round(fps, 2))
 
-            # If we're not currently in between levels…
+            # Initialize a number of avocados, depending on the level
-            if levelChange == 0:
+            avocadosInGame = len(self.movingAvocados)
-                # Initialize a number of avocados, depending on the level
+            avocadosWanted = self.level * multiplier
-                avocadosInGame = len(movingAvocados)
-                avocadosWanted = level * multiplier
-                if avocadosInGame < avocadosWanted:
-                    probability = int(1.0/(avocadosWanted - avocadosInGame) * 100)
-                    if random.randint(0, probability) < 3:
-                        avocolor = self.chooseRandomColor()
-                        avosize = (50, 50)   # should we randomize this?
-                        a = avocado.Avocado(self.screen, avocolor, avosize, color, level)
-                        movingAvocados.append(a)
 
-                # Remove avocados from the list of moving avocados if they no longer move
+            if avocadosInGame < avocadosWanted:
-                # Or add them to the list of pinned avocados if they're been hit
+                probability = int(1.0/(avocadosWanted - avocadosInGame) * 100)
-                pinnedAvocados += [avo for avo in movingAvocados if avo.isPinned() ]
+                if random.randint(0, probability) < 3:
-                movingAvocados[:] = [ avo for avo in movingAvocados if avo.isFalling() ]
+                    avocolor = self.chooseRandomColor()
+                    avosize = (50, 50)   # should we randomize this?
+                    # Spawn a new avocado
+                    a = avocado.Avocado(self.screen, avocolor, avosize, color, self.level)
+                    self.movingAvocados.append(a)
 
-                ##############################
+            # Remove avocados from the list of moving avocados if they no longer move
-                #
+            # Or add them to the list of pinned avocados if they're been hit
-                # Late-Night-Comments:
+            self.pinnedAvocados += [avo for avo in self.movingAvocados if avo.isPinned() ]
-                #
+            self.movingAvocados[:] = [ avo for avo in self.movingAvocados if avo.isFalling() ]
-                # Can we maybe handle the pinned avocados the same way I handle "stuck"
-                # pins? It seems to be easier.. well, the pins don't fall out of the screen
-                # though…
-                #
-                ##############################
 
-                # Now redraw our avocados
+            ##############################
-                for a in movingAvocados:
+            #
-                    a.setTargetColor(color)
+            # Late-Night-Comments:
-                    a.move()
+            #
-                    a.blitme()
+            # Can we maybe handle the pinned avocados the same way I handle "stuck"
+            # pins? It seems to be easier.. well, the pins don't fall out of the screen
+            # though…
+            #
+            ##############################
 
-                for a in pinnedAvocados:
+            # Now redraw our avocados
-                    a.blitme()
+            for a in self.movingAvocados:
+                a.setTargetColor(color)
+                a.move()
+                a.blitme()
 
-                # And finally check if we need to redraw any pins
+            for a in self.pinnedAvocados:
-                for activePin in thrownPins:
+                a.blitme()
-                    activePin.blitme()
+
-                    if not activePin.isStuck():
+            # And finally check if we need to redraw any pins
-                        activePin.moveTowardsTarget()
+            for activePin in self.thrownPins:
+                activePin.blitme()
+                if not activePin.isStuck():
+                    activePin.moveTowardsTarget()
 
             # Catch events
             for event in pygame.event.get():
@@ -221,16 +252,17 @@ class TheGame:
                 if event.type == MOUSEBUTTONDOWN:
                     mousepos = pygame.mouse.get_pos()
 
-                    # Throw a pin here
+                    # Throwing a new pin
                     newPin = pingenerator.Generate(self.screen)
                     newPin.throwAt(mousepos)
-                    thrownPins.append(newPin)
+                    self.thrownPins.append(newPin)
 
                     # Check if any avocados have been hit
-                    for avo in movingAvocados:
+                    for avo in self.movingAvocados:
-                        hit = avo.isHit(mousepos)
+                        hit, center = avo.isHit(mousepos)
                         if hit:
                             score += 100
+                            newPin.throwAt(center)
                             color = self.chooseRandomColor()
                             crystalBall.setColor(color)
                         elif hit == False:

itext.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import pygame
+from support.colors import *
+
+class Text:
+
+    def __init__(self, container, text, pos, duration):
+        """ Foo """
+        self.clock = container['clock']
+        self.duration = duration
+        self.totalTime = 0
+        self.text = container['font'].render(text, 0 , WHITE)
+        self.screen = container['screen']
+        self.pos = pos
+
+
+    def blitme(self):
+        """ sd """
+        self.screen.blit(self.text, self.pos)
+
+
+    def hasExpired(self):
+        self.totalTime += self.clock.get_time()
+        if self.totalTime > self.duration:
+            del(self)
+            return True
+        return False

pingenerator.py

@@ -13,23 +13,23 @@ class Generate:
         screen_width, screen_height = screen.get_size()
         self.pos = (screen_width / 2, screen_height)
         self.image = pygame.image.load(os.path.join('img','pin.png')).convert_alpha()
-
+        self.size = self.image.get_size()
 
     def throwAt(self, target):
         self.inFlight = True
-        self.target = target
+        x, y = target
+        self.target = (x, y - self.size[1])
 
 
     def isStuck(self):
         if self.pos == self.target:
-            print('Pin stuck!')
+            # print('Pin stuck!')
             return True
 
 
     def blitme(self):
         self.screen.blit(self.image, self.pos)
 
-
     def moveTowardsTarget(self):
         ##############################
         #
@@ -70,9 +70,9 @@ class Generate:
 
         newy = y + ystep
 
-        print('DEBUG :: pin target: ' + str(tx) + ',' + str(ty))
+        # print('DEBUG :: pin target: ' + str(tx) + ',' + str(ty))
-        print('DEBUG :: pin position: ' + str(newx) + ',' + str(newy))
+        # print('DEBUG :: pin position: ' + str(newx) + ',' + str(newy))
-        print('DEBUG :: pin distance: ' + str(xToCover) + ',' + str(yToCover))
+        # print('DEBUG :: pin distance: ' + str(xToCover) + ',' + str(yToCover))
-        print('DEBUG :: pin speed: ' + str(self.vx) + ',' + str(self.vy))
+        # print('DEBUG :: pin speed: ' + str(self.vx) + ',' + str(self.vy))
-        print('')
+        # print('')
         self.pos = (newx, newy)