avocados/game.py

#!/usr/bin/env python3
"""
Avocados and stuff
"""

import os, random, sys
import pygame
import avocado, lawyer
from pygame.locals import *
from support.colors import *
from interface import hud


class TheGame:

    def __init__(self):
        """ foo """
        self.colors = [BLUE, GREEN, RED, YELLOW]
        pygame.init()
        try:
            pygame.mixer.init()
            pygame.mixer.music.set_volume(0.5)
            noSound = False
        except:
            print("Y U NO sound? :(")
            noSound = True

        pygame.display.set_caption('Pin Avo, the Cado!')


    def initialize_screen(self):
        displayInfo = pygame.display.Info()
        zoom = 1.3
        WIDTH = int(displayInfo.current_w / zoom)
        HEIGHT = int(displayInfo.current_h / zoom)
        return (WIDTH, HEIGHT)


    def mute(self,mute=False,sound=True):
        if not sound:
            return
        if mute:
            pygame.mixer.music.set_volume(0.0)
        else:
            pygame.mixer.music.set_volume(0.5)


    def playLevel(self,lvl=1,sound=True):
        if not sound:
            return
        if lvl == 1:
            pygame.mixer.music.load("""audio/level1.wav""")
        elif lvl == 2:
            pygame.mixer.music.load("""audio/level2.wav""")
        elif lvl >= 3:
            pygame.mixer.music.load("""audio/level3.wav""")
        pygame.mixer.music.play()


    def fade(self, sound=True):
        if not sound:
            return
        pygame.mixer.music.fadeout(3000)


    def loadClick(self, sound=True):
        if not sound:
            return
        self.click = pygame.mixer.Sound("audio/click.wav")
        return self.click

    def gameOver(self,screen,gameOverImage):
        screen.blit(pygame.transform.scale(gameOverImage, (800, 600)), (0, 0))
        pygame.display.flip()
        pygame.time.wait(3000)


    def main(self):
        clock = pygame.time.Clock()
        size = (800, 600)
        bg = pygame.image.load("img/background.png")
        desired_fps = 15
        multiplier = 3
        score = 0
        time = timeleft = 30
        level = 1
        levelChange = 0
        reachScore = 200
        font = pygame.font.Font(None, 60)
        avoClick = game.loadClick()

        # I don't know, should we move this text out of the way?
        game_over = font.render('GAME OVER', 0, RED)

        gameOverImage = pygame.image.load("img/gameOver.png")

        # initialize the game canvas
        screen = pygame.display.set_mode(size)

        # initialize the HUD class and the lawyer
        the_hud = hud.Hud(screen)
        fullegast = lawyer.Lawyer(screen)

        # Initial color
        color = self.chooseRandomColor()
        fullegast.setColor(color)

        avocados = []
        running = True
        while running:

            time_passed = clock.tick(desired_fps)
            fps = clock.get_fps()
            screen_width, screen_height = size

            if type(bg) is tuple:
                screen.fill(bg)
            else:
                screen.blit(pygame.transform.scale(bg, (800, 600)), (0, 0))

            # Next level?
            if score >= reachScore:
                score = 0
                level += 1
                levelChange = 35
                timeleft = time
                avocados = []
                print('DEBUG :: Level ' + str(level))
                game.playLevel(level)

            # Let's add the lawyer
            fullegast.blitme()

            if levelChange > 0:
                levelText = font.render('Level ' + str(level), 0, WHITE)
                screen.blit(levelText, (screen_width / 3, screen_height / 2))
                levelChange -= 1

            timeleft -= time_passed / 1000
            timeleft = round(timeleft, 2)
            if timeleft <= 0:
                screen.blit(game_over, (screen_width/3, screen_height/2))
                displaytime = 'Timed out!'
                pygame.display.flip()
                game.gameOver(screen,gameOverImage)
                continue
            else:
                displaytime = timeleft

            # Redraw the HUD
            the_hud.draw_hud(score, displaytime, round(fps, 2))

            # Initialize a number of avocados, depending on the level
            if levelChange == 0:
                avocados_in_game = len(avocados)
                avocadosWanted = level * multiplier
                if avocados_in_game < avocadosWanted:
                    for i in range(avocados_in_game, avocadosWanted):
                        avocolor = self.chooseRandomColor()
                        avosize = (50, 50)   # should we randomize this?
                        a = avocado.Avocado(screen, avocolor, avosize, color)
                        avocados.append(a)

                # Remove avocados from the list if they no longer exist
                # E.g. have been pinned or fallen down
                avocados[:] = [ x for x in avocados if x.exists() ]
                for a in avocados:
                    a.setTargetColor(color)
                    a.move()
                    a.blitme()

            # Catch events
            for event in pygame.event.get():
                # Collision detection
                if event.type == MOUSEBUTTONDOWN:
                    avoClick.play()
                    for avo in avocados:
                        hit = avo.isHit(pygame.mouse.get_pos())
                        if hit:
                            score += 100
                            color = self.chooseRandomColor()
                            fullegast.setColor(color)
                        elif hit == False:
                            score -= 50

                # Had enough of this?
                if event.type == pygame.QUIT:
                    running = False
                    game.gameOver(screen,gameOverImage)
                    pygame.quit()
                    sys.exit()

            pygame.display.flip()


    def chooseRandomColor(self):
        selected = random.randint(0, 3)
        return self.colors[selected]


if __name__ == '__main__':
    game = TheGame()
    game.playLevel()
    game.main()