class ControladorJogo:
    TAM_FONTE_PONTUACAO = 40
    DESLOCAMENTO_TELA = 5
    POSICAO_TROCA_TELA = -500

    def __init__(self):
        pygame.init()
        self.apljogo = AplJogo()
        self.telajogo = TelaJogo()
        self.imagempersonagem = self.get_imagem("personagem.png")
        self.posicaotela = EstiloElementos.posicao_imagem_fundo()
        self.entradas = EntradaUsuario()
        self.fabricaimagens = FlyweightFabrica()

    @staticmethod
    def get_obstaculo(nomeobstaculo):
        return pygame.image.load(os.path.join(CaminhoRecursos.caminho_imagens_obstaculos(), nomeobstaculo))

    @staticmethod
    def get_imagem(nomeimagem):
        return pygame.image.load(os.path.join(CaminhoRecursos.caminho_imagens(), nomeimagem))

    @staticmethod
    def get_musica(nomemusica):
        return os.path.join(CaminhoRecursos.caminho_musicas(), nomemusica)

    @staticmethod
    def get_som(nomesom):
        return os.path.join(CaminhoRecursos.caminho_sons(), nomesom)

    def exibir_tela_jogo(self):
        imagem = self.get_imagem("fundojogo.png")
        self.telajogo.exibe_imagem(imagem, self.posicaotela)
        self.anda_tela()

    def anda_tela(self):
        self.posicaotela.eixox -= self.DESLOCAMENTO_TELA
        if self.posicaotela.eixox == self.POSICAO_TROCA_TELA:
            self.posicaotela.eixox = 0

    def exibir_vidas(self):
        for numvida in range(self.apljogo.personagem.vida):
            imagem = self.get_imagem("vida.png")
            self.telajogo.exibe_imagem(imagem, EstiloElementos.get_posicao_vida(numvida))

    def exibir_pontuacao(self, mensagem):
        self.telajogo.exibe_texto(mensagem + str(self.apljogo.pontos), self.TAM_FONTE_PONTUACAO,
                                  EstiloElementos.posicao_pontuacao())

    def exibir_fim_de_jogo(self):
        imagem = self.get_imagem("gameover.png")
        self.telajogo.exibe_imagem(imagem, EstiloElementos.posicao_imagem_fundo())
        self.posicaotela.eixox = 0

    def exibir_mensagem(self, mensagem):
        self.telajogo.exibe_texto(mensagem, self.TAM_FONTE_PONTUACAO, EstiloElementos.posicao_mensagem())

    def atualiza_tela(self):
        self.exibir_tela_jogo()
        self.fabricaimagens.get_flyweight("personagem").desenhar_imagem(self.apljogo.personagem.posicao)
        for obstaculo in self.apljogo.lobstaculos:
            self.fabricaimagens.get_flyweight(obstaculo.nome).desenhar_imagem(obstaculo.posicao)
        self.exibir_pontuacao("Score: ")
        self.exibir_vidas()

    def entrada_jogador(self):
        for event in pygame.event.get():
            self.entradas.reset()
            if event.type == pygame.QUIT:
                self.entradas.quit_pressed = True
            if (event.type == pygame.KEYDOWN):
                if (event.key == pygame.K_SPACE):
                    self.entradas.quit_pressed = True
            if (event.type == pygame.KEYDOWN):
                if (event.key == pygame.K_UP):
                    self.apljogo.personagem.diminui_deslocamento()
            if (event.type == pygame.KEYUP):
                if (event.key == pygame.K_UP):
                    self.apljogo.personagem.aumenta_deslocamento()
            pygame.key.set_repeat(1)

    def jogo(self):
        self.apljogo.configuracao()
        continua = True
        while continua:
            self.entrada_jogador()
            self.apljogo.jogar()
            self.atualiza_tela()
            for obstaculo in self.apljogo.lobstaculos:
                imagemobstaculo = self.get_obstaculo(obstaculo.nome + ".png")
                if self.apljogo.verifica_colisao_personagem(self.imagempersonagem, imagemobstaculo, obstaculo):
                    self.apljogo.penaliza_jogador()
                    som = self.get_som("colisao.wav")
                    self.telajogo.exibe_som(som)
            if self.apljogo.fimdejogo:
                self.exibir_fim_de_jogo()
            if self.entradas.quit_pressed:
                exit(0)
        pygame.quit()
Example #2
0
class Controlador:
    def __init__(self):
        pygame.init()
        self.apljogo = AplJogo()
        self.telajogo = TelaJogo()
        self.telamenu = TelaMenu()
        self.caminhoimagem = (os.getcwd()).replace("principal", os.path.join("recursos", "imagem"))
        self.xtela = 0

    def exibir_tela_jogo(self):
        self.telajogo.exibe_imagem(self.caminhoimagem, "fundo8.png", Posicao(self.xtela, 0))
        self.xtela -= 5
        if self.xtela == -500:
            self.xtela = 0

    def exibir_personagem(self, posicao):
        imagem = self.telajogo.exibe_imagem(self.caminhoimagem, "peixa.png", posicao)
        rect = imagem.get_rect().move(posicao.eixox, posicao.eixoy)
        return rect

    def exibir_obstaculo(self, figura, posicao):
        imagem = self.telajogo.exibe_imagem(self.caminhoimagem, figura, posicao)
        rect = imagem.get_rect().move(posicao.eixox, posicao.eixoy)
        return rect

    def exibir_vida(self, x, y):
        self.telajogo.exibe_imagem(self.caminhoimagem, "vida.png", Posicao(x, y))

    def exibir_pontuacao(self, pontos):
        self.telajogo.exibe_texto("Score: " + str(pontos), 40, [10, 50])

    def exibir_fim_de_jogo(self):
        self.telajogo.exibe_texto("Game Over", 75, [200, 250])
        self.xtela = 0

    def controla_vida(self):
        x = 0
        for auxvida in range(self.apljogo.personagem.vida):
            self.exibir_vida(x, 0)
            x += 40

    def imprime_obstaculos(self):
        rect1 = self.exibir_personagem(self.apljogo.personagem.posicao)
        for obs in self.apljogo.obstaculos:
            if obs.nome == "peixeespada":
                rect2 = self.exibir_obstaculo("peixeespada.png", obs.posicao)
            elif obs.nome == "baiacu":
                rect2 = self.exibir_obstaculo("baiacu.png", obs.posicao)
            self.apljogo.verifica_colisao(rect1, rect2)

    def jogo(self):
        self.apljogo.configuracao()
        while True:
            self.apljogo.novo += 1
            self.apljogo.jogar()
            self.exibir_tela_jogo()
            self.imprime_obstaculos()
            self.exibir_pontuacao(self.apljogo.pontos)
            self.controla_vida()
            if self.apljogo.fimdejogo == True:
                self.exibir_fim_de_jogo()
        pygame.quit()
Example #3
0
class ControladorDefineSintagma(ControladorJogo):
    POSICAOX_BOTAO_CADASTRAR_SINTAGMAS = 350
    POSICAOY_BOTAO_CADASTRAR_SINTAGMAS = 400
    POSICAOX_BOTAO_MARCAR_SINTAGMA = 50
    POSICAOY_BOTAO_MARCAR_SINTAGMA = 250
    POSICAOX_BOTAO_CADASTRAR_SINTAGMAS = 350
    POSICAOY_BOTAO_CADASTRAR_SINTAGMAS = 450
    POSICAOX_CLASSE_GRAMATICAL = 250
    POSICAOY_CLASSE_GRAMATICAL = 250
    INCREMENTO_POSICAOY_CLASSE_GRAMATICAL = 80

    def __init__(self, frase):
        ControladorJogo.__init__(self)
        self.apljogo = AplJogo()
        self.telajogo = Tela()
        self.frase = frase
        self.posicaoy = (self.telajogo.tamanhotelay / 4)
        self.listarelacoes = []

    def inicializa_tela(self):
        self.renderizar_fundo()
        self.exibir_botoes_palavras()

    def renderizar_fundo(self):
        self.telajogo.telajogo.fill((255, 255, 255))

    def gerar_botao(self, nomeimagem, posicaoxbotao, posicaoybotao):
        botao = self.get_imagem(nomeimagem)
        botaorect = botao.get_rect().move(posicaoxbotao, posicaoybotao)
        return botao, botaorect

    def imprimir_imagem_botao(self, botao, posicaox, posicaoy):
        self.telajogo.exibe_imagem(botao, Posicao(posicaox, posicaoy))

    def imprimir_botao_classes(self, classe, botao, posicaox, posicaoy):
        self.telajogo.exibe_imagem(botao, Posicao(posicaox, posicaoy))
        self.telajogo.exibe_texto(classe, self.TAM_FONTE_TEXTO,
                                  Posicao(posicaox + 10, posicaoy + 10))

    def imprimir_classes_gramaticais(self):
        self.listaclasses = [
            "Substantivo", "Verbo", "Adverbio", "Adjetivo", "Pronome Adjetivo",
            "Numeral", "Artigo"
        ]
        self.listarectclasses = []

        posicaoy = self.POSICAOY_CLASSE_GRAMATICAL
        posicaox = self.POSICAOX_CLASSE_GRAMATICAL
        cont = 0
        for classe in self.listaclasses:
            largura = self.calcula_largura_botao(classe)
            botao = self.cria_botao(classe,
                                    (220, 220, 220))  #definir a melhor cor
            imagemrectbotao = botao.get_rect().move(posicaox, posicaoy)
            self.listarectclasses.append(imagemrectbotao)
            self.imprimir_botao_classes(classe, botao, posicaox, posicaoy)
            posicaox += largura + 10

            cont += 1
            if cont == 4:
                posicaoy = posicaoy + self.INCREMENTO_POSICAOY_CLASSE_GRAMATICAL
                posicaox = self.POSICAOX_CLASSE_GRAMATICAL
                cont = 0

        pygame.display.flip()

    def verificar_escolha_classe_gramatical(self):
        while True:
            for idrectclasse in range(len(self.listarectclasses)):
                if pygame.mouse.get_pressed(
                )[0] and self.listarectclasses[idrectclasse].collidepoint(
                        pygame.mouse.get_pos()):
                    return idrectclasse

            self.verifica_evento_finalizar()

    def verifica_evento_mouse(self):
        for palavraobj in self.objpalavras:
            self.controla_cor_botao_visitado(palavraobj)

            if palavraobj.foi_clicada():
                if palavraobj.id not in self.listapalavrasclicadas:
                    palavraobj.ativo = True
                    self.listapalavrasclicadas.append(palavraobj.id)
                    self.destacar_botao_clicado(palavraobj.id)
                else:
                    palavraobj.ativo = False
                    self.listapalavrasclicadas.remove(palavraobj.id)
                    self.restaurar_botao(palavraobj.id)

    def verifica_evento_finalizar(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

    def verifica_sintagma_existente(self):
        for tuplasintagmaclasse in self.listaretornosintagmasclasses:
            if tuplasintagmaclasse[0] == self.listapalavrasclicadas:
                return True
        return False

    def define_sintagmas(self):
        self.apljogo.configuracao()
        self.objpalavras = self.apljogo.gera_estrutura_frase(self.frase)
        self.inicializa_tela()

        self.botaodefinirsintagma, self.imagemrectbotaodefinirsintagma = self.gerar_botao(
            "btmarcarcenario.png", self.POSICAOX_BOTAO_MARCAR_SINTAGMA,
            self.POSICAOY_BOTAO_MARCAR_SINTAGMA)
        self.botaocadastrar, self.imagemrectbotaocadastrar = self.gerar_botao(
            "btimagens.png", self.POSICAOX_BOTAO_CADASTRAR_SINTAGMAS,
            self.POSICAOY_BOTAO_CADASTRAR_SINTAGMAS)

        self.listaretornosintagmasclasses = []
        self.listapalavrasclicadas = []
        continua = True
        while continua:
            self.imprimir_imagem_botao(self.botaodefinirsintagma,
                                       self.POSICAOX_BOTAO_MARCAR_SINTAGMA,
                                       self.POSICAOY_BOTAO_MARCAR_SINTAGMA)
            self.imprimir_imagem_botao(self.botaocadastrar,
                                       self.POSICAOX_BOTAO_CADASTRAR_SINTAGMAS,
                                       self.POSICAOY_BOTAO_CADASTRAR_SINTAGMAS)
            self.verifica_evento_mouse()
            self.verifica_evento_finalizar()

            if pygame.mouse.get_pressed(
            )[0] and self.imagemrectbotaodefinirsintagma.collidepoint(
                    pygame.mouse.get_pos()):
                self.listapalavrasclicadas.sort()

                if not self.verifica_sintagma_existente():
                    self.imprimir_classes_gramaticais()
                    idclasse = self.verificar_escolha_classe_gramatical()

                    tuplasintagmaclasse = (self.listapalavrasclicadas,
                                           self.listaclasses[idclasse])
                    self.listaretornosintagmasclasses.append(
                        tuplasintagmaclasse)
                    self.telajogo.exibe_som(self.get_som("acerto.wav"))
                else:
                    self.telajogo.exibe_som(self.get_som("erro.wav"))

                self.listapalavrasclicadas = []
                self.inicializa_tela()

            if pygame.mouse.get_pressed(
            )[0] and self.imagemrectbotaocadastrar.collidepoint(
                    pygame.mouse.get_pos()):
                return self.listaretornosintagmasclasses

            pygame.display.flip()
            self.apljogo.clock.tick(10)
class ControladorJogo:
    TAM_FONTE_TEXTO = 35
    TAM_FONTE_NUMERO = 40
    TAMANHOFONTEGAMEOVER = 40
    DESLOCAMENTO_TELA = 5
    POSICAO_TROCA_TELA = -500
    INTERVALOMOEDAS = 70
    INTERVALOESQUELETOS = 234
    VELOCIDADEBONUS = 11

    def __init__(self):
        self.apljogo = AplJogo()
        self.telajogo = Tela()
        self.aplcadastrarjogador = AplCadastrarJogador()
        self.fabricaimagens = FlyweightFabrica()
        self.imagempersonagem = self.get_imagem("personagem.png")
        self.posicaotela = EstiloElementos.posicao_imagem_fundo()
        self.fundojogo = "fundojogo2.png"
        self.music = False
        self.continuarjogo = True

    @staticmethod
    def get_obstaculo(nomeobstaculo):
        return pygame.image.load(os.path.join(CaminhoRecursos.caminho_imagens_obstaculos(), nomeobstaculo))

    @staticmethod
    def get_imagem(nomeimagem):
        return pygame.image.load(os.path.join(CaminhoRecursos.caminho_imagens(), nomeimagem))

    @staticmethod
    def get_musica(nomemusica):
        return os.path.join(CaminhoRecursos.caminho_musicas(), nomemusica)

    @staticmethod
    def get_som(nomesom):
        return os.path.join(CaminhoRecursos.caminho_sons(), nomesom)

    def exibir_tela_jogo(self):
        imagem = self.get_imagem(self.fundojogo)
        self.telajogo.exibe_imagem(imagem, self.posicaotela)
        self.anda_tela()

    def anda_tela(self):
        self.posicaotela.eixox -= self.DESLOCAMENTO_TELA
        if self.posicaotela.eixox == self.POSICAO_TROCA_TELA:
            self.posicaotela.eixox = 0

    def exibir_vidas(self):
        for numvida in range(self.apljogo.personagem.vida):
            imagem = self.get_imagem("vida.png")
            self.telajogo.exibe_texto("Vida", self.TAM_FONTE_TEXTO, EstiloElementos.posicao_texto_vida())
            self.telajogo.exibe_imagem(imagem, EstiloElementos.get_posicao_vida(numvida))

    def exibir_pontuacao(self):
        self.telajogo.exibe_texto(str(self.apljogo.pontos), self.TAM_FONTE_NUMERO, EstiloElementos.posicao_numero_pontuacao() )
        self.telajogo.exibe_texto("Pontuação", self.TAM_FONTE_TEXTO, EstiloElementos.posicao_texto_pontuacao())

    def exibir_pontuacao_moedas(self):
        self.fabricaimagens.get_flyweight("moeda").desenhar_imagem(EstiloElementos.posicao_desenho_moeda())
        self.telajogo.exibe_texto("Bônus", self.TAM_FONTE_TEXTO, EstiloElementos.posicao_texto_bonus())
        self.telajogo.exibe_texto(str(self.apljogo.qtdmoedas)+" / "+str(self.apljogo.valor_alcance_bonus), self.TAM_FONTE_NUMERO, EstiloElementos.posicao_numero_bonus())

    def exibir_fim_de_jogo(self):
        self.posicaotela.eixox = 0
        imagem = self.get_imagem("gameover.png")
        self.telajogo.exibe_imagem(imagem, EstiloElementos.posicao_imagem_fundo())
        self.telajogo.exibe_texto("Parabéns! Você fez %s pontos"%str(self.apljogo.pontos), self.TAMANHOFONTEGAMEOVER, EstiloElementos.posicao_mensagem_gameover())
        pygame.display.flip()


    def exibir_musica(self, musica):
        self.telajogo.exibe_musica(CaminhoRecursos.caminho_musicas(), musica)

    # exibe moedas e esqueletos na tela
    def exibir_bonus(self, lista, intervalo):
        self.auxbonusanterior = lista[0].posicaox - (intervalo + 1)
        for bonus in lista:
            if ((bonus.posicaox - self.auxbonusanterior) > intervalo) or ((bonus.posicaox - self.auxbonusanterior) < 0):
                bonus.decrementa_posicao_x(self.VELOCIDADEBONUS)
                if bonus.ehtangivel:
                    self.fabricaimagens.get_flyweight(bonus.nome).desenhar_imagem(bonus.define_posicao())
            else:
                break
            self.auxbonusanterior = bonus.posicaox
            if bonus.posicaox <= 0:
                bonus.restaura_posicao()

    def constroi_jogo_evolucao(self):
        self.fabricaimagens.get_flyweight("peixemoto").desenhar_imagem(self.apljogo.personagem.posicao)
        self.exibir_bonus(self.lesqueletos, self.INTERVALOESQUELETOS)
        if not self.music:
            self.music = True
            self.exibir_musica(self.apljogo.personagem.musicaatual)
        self.verifica_colisao_bonus(self.lesqueletos)
        self.fundojogo = "fundojogonegro2.png"

    def constroi_jogo_original(self):
        self.fabricaimagens.get_flyweight("personagem").desenhar_imagem(self.apljogo.personagem.posicao)
        self.exibir_bonus(self.lmoedas, self.INTERVALOMOEDAS)
        self.verifica_colisao_bonus(self.lmoedas)
        self.fundojogo = "fundojogo2.png"

    def exibir_personagem(self):
        if self.apljogo.personagem.estado == EstadoPersonagem.normal:
            self.constroi_jogo_original()
        else:
            self.constroi_jogo_evolucao()

    def atualiza_tela(self):
        self.exibir_tela_jogo()
        self.exibir_personagem()
        for obstaculo in self.apljogo.lobstaculos:
            self.fabricaimagens.get_flyweight(obstaculo.nome).desenhar_imagem(obstaculo.posicao)
        self.exibir_pontuacao()
        self.exibir_vidas()
        self.exibir_pontuacao_moedas()

    # o jogo volta ao estado original (sem motoqueiro)
    def restaura_estado_jogo(self):
        self.apljogo.personagemmemento.restaura_estado()
        self.music = False
        self.exibir_musica(self.apljogo.personagem.musicaatual)

    # verifica se o personagem colidiu com algum obstaculo marinho
    def verifica_colisao_obstaculo(self):
        for obstaculo in self.apljogo.lobstaculos:
            imagemobstaculo = self.get_obstaculo(obstaculo.nome + ".png")
            if self.apljogo.testa_colisao_personagem_obstaculo(self.imagempersonagem, imagemobstaculo, obstaculo):
                self.telajogo.exibe_som(self.get_som(obstaculo.somcolisao))
                if self.apljogo.personagem.estado == EstadoPersonagem.normal:
                    self.apljogo.penaliza_jogador()
                else:
                    self.restaura_estado_jogo()
                    self.restaura_posicao_esqueletos()

    def colidiu_esqueleto(self, objeto):
        self.telajogo.exibe_som(self.get_som(objeto.somcolisao))
        self.restaura_estado_jogo()
        self.restaura_posicao_esqueletos()

    def capturou_moeda(self, objeto):
        self.telajogo.exibe_som(self.get_som(objeto.somcolisao))
        self.apljogo.qtdmoedas += 1

    # verifica se houve colisao do personagem com uma moeda ou um esqueleto
    def verifica_colisao_bonus(self, lista):
        for objeto in lista:
            imagem = self.get_imagem(objeto.imagem)
            if self.apljogo.testa_colisao_personagem_bonus(self.imagempersonagem, imagem, objeto):
                if objeto.nome == "moeda":
                    self.capturou_moeda(objeto)
                else:
                    self.colidiu_esqueleto(objeto)
                    break

    # inicializa a posicao de todos os esqueletos
    def restaura_posicao_esqueletos(self):
        for esqueleto in self.lesqueletos:
            esqueleto.restaura_posicao()

    # a classe ControlodorJogo (q eh um observador)recebe atualização pq a classe Observada ObservableEventosTeclado capturou um evento
    def update(self, observable):
        if observable.cima:
            self.apljogo.personagem.diminui_deslocamento()
        elif observable.soltoubaixo:
            self.apljogo.personagem.aumenta_deslocamento()
        elif (observable.enter) and (self.apljogo.fimdejogo):
            self.continuarjogo = False

    def inicializa_observable(self):
        observable = ObservableEventosTeclado()
        observable.add_observer(self)
        return observable

    def jogo(self, jogador):
        observable = self.inicializa_observable()
        self.exibir_musica(self.apljogo.personagem.musicaatual)
        self.apljogo.configuracao()
        self.lmoedas = self.apljogo.cria_bloco_bonus(11, "moeda")
        self.lesqueletos = self.apljogo.cria_bloco_bonus(3, "esqueleto")
        continua = True
        while continua:
            observable.verifica_evento()
            self.apljogo.jogar()
            self.atualiza_tela()
            self.verifica_colisao_obstaculo()
            if self.apljogo.fimdejogo:
                for moeda in self.lmoedas:
                    moeda.ehtangivel = False
                self.aplcadastrarjogador.cadastrar_pontuacao(jogador, self.apljogo.pontos)
                self.exibir_fim_de_jogo()
                continua = self.continuarjogo
        music.stop()
Example #5
0
class ControladorJogo:
    TAM_FONTE_TEXTO = 35
    TAM_FONTE_NUMERO = 40
    TAMANHOFONTEGAMEOVER = 40
    DESLOCAMENTO_TELA = 5
    POSICAO_TROCA_TELA = -500
    INTERVALOMOEDAS = 70
    INTERVALOESQUELETOS = 234
    VELOCIDADEBONUS = 11

    def __init__(self):
        self.apljogo = AplJogo()
        self.telajogo = Tela()
        self.aplcadastrarjogador = AplCadastrarJogador()
        self.fabricaimagens = FlyweightFabrica()
        self.imagempersonagem = self.get_imagem("personagem.png")
        self.posicaotela = EstiloElementos.posicao_imagem_fundo()
        self.fundojogo = "fundojogo2.png"
        self.music = False
        self.continuarjogo = True

    @staticmethod
    def get_obstaculo(nomeobstaculo):
        return pygame.image.load(
            os.path.join(CaminhoRecursos.caminho_imagens_obstaculos(),
                         nomeobstaculo))

    @staticmethod
    def get_imagem(nomeimagem):
        return pygame.image.load(
            os.path.join(CaminhoRecursos.caminho_imagens(), nomeimagem))

    @staticmethod
    def get_musica(nomemusica):
        return os.path.join(CaminhoRecursos.caminho_musicas(), nomemusica)

    @staticmethod
    def get_som(nomesom):
        return os.path.join(CaminhoRecursos.caminho_sons(), nomesom)

    def exibir_tela_jogo(self):
        imagem = self.get_imagem(self.fundojogo)
        self.telajogo.exibe_imagem(imagem, self.posicaotela)
        self.anda_tela()

    def anda_tela(self):
        self.posicaotela.eixox -= self.DESLOCAMENTO_TELA
        if self.posicaotela.eixox == self.POSICAO_TROCA_TELA:
            self.posicaotela.eixox = 0

    def exibir_vidas(self):
        for numvida in range(self.apljogo.personagem.vida):
            imagem = self.get_imagem("vida.png")
            self.telajogo.exibe_texto("Vida", self.TAM_FONTE_TEXTO,
                                      EstiloElementos.posicao_texto_vida())
            self.telajogo.exibe_imagem(
                imagem, EstiloElementos.get_posicao_vida(numvida))

    def exibir_pontuacao(self):
        self.telajogo.exibe_texto(str(self.apljogo.pontos),
                                  self.TAM_FONTE_NUMERO,
                                  EstiloElementos.posicao_numero_pontuacao())
        self.telajogo.exibe_texto("Pontuação", self.TAM_FONTE_TEXTO,
                                  EstiloElementos.posicao_texto_pontuacao())

    def exibir_pontuacao_moedas(self):
        self.fabricaimagens.get_flyweight("moeda").desenhar_imagem(
            EstiloElementos.posicao_desenho_moeda())
        self.telajogo.exibe_texto("Bônus", self.TAM_FONTE_TEXTO,
                                  EstiloElementos.posicao_texto_bonus())
        self.telajogo.exibe_texto(
            str(self.apljogo.qtdmoedas) + " / " +
            str(self.apljogo.valor_alcance_bonus), self.TAM_FONTE_NUMERO,
            EstiloElementos.posicao_numero_bonus())

    def exibir_fim_de_jogo(self):
        self.posicaotela.eixox = 0
        imagem = self.get_imagem("gameover.png")
        self.telajogo.exibe_imagem(imagem,
                                   EstiloElementos.posicao_imagem_fundo())
        self.telajogo.exibe_texto(
            "Parabéns! Você fez %s pontos" % str(self.apljogo.pontos),
            self.TAMANHOFONTEGAMEOVER,
            EstiloElementos.posicao_mensagem_gameover())
        pygame.display.flip()

    def exibir_musica(self, musica):
        self.telajogo.exibe_musica(CaminhoRecursos.caminho_musicas(), musica)

    # exibe moedas e esqueletos na tela
    def exibir_bonus(self, lista, intervalo):
        self.auxbonusanterior = lista[0].posicaox - (intervalo + 1)
        for bonus in lista:
            if ((bonus.posicaox - self.auxbonusanterior) > intervalo) or (
                (bonus.posicaox - self.auxbonusanterior) < 0):
                bonus.decrementa_posicao_x(self.VELOCIDADEBONUS)
                if bonus.ehtangivel:
                    self.fabricaimagens.get_flyweight(
                        bonus.nome).desenhar_imagem(bonus.define_posicao())
            else:
                break
            self.auxbonusanterior = bonus.posicaox
            if bonus.posicaox <= 0:
                bonus.restaura_posicao()

    def constroi_jogo_evolucao(self):
        self.fabricaimagens.get_flyweight("peixemoto").desenhar_imagem(
            self.apljogo.personagem.posicao)
        self.exibir_bonus(self.lesqueletos, self.INTERVALOESQUELETOS)
        if not self.music:
            self.music = True
            self.exibir_musica(self.apljogo.personagem.musicaatual)
        self.verifica_colisao_bonus(self.lesqueletos)
        self.fundojogo = "fundojogonegro2.png"

    def constroi_jogo_original(self):
        self.fabricaimagens.get_flyweight("personagem").desenhar_imagem(
            self.apljogo.personagem.posicao)
        self.exibir_bonus(self.lmoedas, self.INTERVALOMOEDAS)
        self.verifica_colisao_bonus(self.lmoedas)
        self.fundojogo = "fundojogo2.png"

    def exibir_personagem(self):
        if self.apljogo.personagem.estado == EstadoPersonagem.normal:
            self.constroi_jogo_original()
        else:
            self.constroi_jogo_evolucao()

    def atualiza_tela(self):
        self.exibir_tela_jogo()
        self.exibir_personagem()
        for obstaculo in self.apljogo.lobstaculos:
            self.fabricaimagens.get_flyweight(obstaculo.nome).desenhar_imagem(
                obstaculo.posicao)
        self.exibir_pontuacao()
        self.exibir_vidas()
        self.exibir_pontuacao_moedas()

    # o jogo volta ao estado original (sem motoqueiro)
    def restaura_estado_jogo(self):
        self.apljogo.personagemmemento.restaura_estado()
        self.music = False
        self.exibir_musica(self.apljogo.personagem.musicaatual)

    # verifica se o personagem colidiu com algum obstaculo marinho
    def verifica_colisao_obstaculo(self):
        for obstaculo in self.apljogo.lobstaculos:
            imagemobstaculo = self.get_obstaculo(obstaculo.nome + ".png")
            if self.apljogo.testa_colisao_personagem_obstaculo(
                    self.imagempersonagem, imagemobstaculo, obstaculo):
                self.telajogo.exibe_som(self.get_som(obstaculo.somcolisao))
                if self.apljogo.personagem.estado == EstadoPersonagem.normal:
                    self.apljogo.penaliza_jogador()
                else:
                    self.restaura_estado_jogo()
                    self.restaura_posicao_esqueletos()

    def colidiu_esqueleto(self, objeto):
        self.telajogo.exibe_som(self.get_som(objeto.somcolisao))
        self.restaura_estado_jogo()
        self.restaura_posicao_esqueletos()

    def capturou_moeda(self, objeto):
        self.telajogo.exibe_som(self.get_som(objeto.somcolisao))
        self.apljogo.qtdmoedas += 1

    # verifica se houve colisao do personagem com uma moeda ou um esqueleto
    def verifica_colisao_bonus(self, lista):
        for objeto in lista:
            imagem = self.get_imagem(objeto.imagem)
            if self.apljogo.testa_colisao_personagem_bonus(
                    self.imagempersonagem, imagem, objeto):
                if objeto.nome == "moeda":
                    self.capturou_moeda(objeto)
                else:
                    self.colidiu_esqueleto(objeto)
                    break

    # inicializa a posicao de todos os esqueletos
    def restaura_posicao_esqueletos(self):
        for esqueleto in self.lesqueletos:
            esqueleto.restaura_posicao()

    # a classe ControlodorJogo (q eh um observador)recebe atualização pq a classe Observada ObservableEventosTeclado capturou um evento
    def update(self, observable):
        if observable.cima:
            self.apljogo.personagem.diminui_deslocamento()
        elif observable.soltoubaixo:
            self.apljogo.personagem.aumenta_deslocamento()
        elif (observable.enter) and (self.apljogo.fimdejogo):
            self.continuarjogo = False

    def inicializa_observable(self):
        observable = ObservableEventosTeclado()
        observable.add_observer(self)
        return observable

    def jogo(self, jogador):
        observable = self.inicializa_observable()
        self.exibir_musica(self.apljogo.personagem.musicaatual)
        self.apljogo.configuracao()
        self.lmoedas = self.apljogo.cria_bloco_bonus(11, "moeda")
        self.lesqueletos = self.apljogo.cria_bloco_bonus(3, "esqueleto")
        continua = True
        while continua:
            observable.verifica_evento()
            self.apljogo.jogar()
            self.atualiza_tela()
            self.verifica_colisao_obstaculo()
            if self.apljogo.fimdejogo:
                for moeda in self.lmoedas:
                    moeda.ehtangivel = False
                self.aplcadastrarjogador.cadastrar_pontuacao(
                    jogador, self.apljogo.pontos)
                self.exibir_fim_de_jogo()
                continua = self.continuarjogo
        music.stop()
Example #6
0
class ControladorJogo:

    TAM_FONTE_TEXTO = 35
    TAM_MARGEM_BOTAO = 40

    def __init__(self):
        self.apljogo = AplJogo()
        self.telajogo = Tela()
        self.music = True
        self.posicaobotaorelacoes = 0
        self.idpalavraorigem = -1
        self.posicaoy = (self.telajogo.tamanhotelay / 5 * 4)
        self.listasetas = []

    @staticmethod
    def get_imagem(nomeimagem):
        return pygame.image.load(
            os.path.join(CaminhoRecursos.caminho_imagens(), nomeimagem))

    @staticmethod
    def get_musica(nomemusica):
        return os.path.join(CaminhoRecursos.caminho_musicas(), nomemusica)

    @staticmethod
    def get_som(nomesom):
        return os.path.join(CaminhoRecursos.caminho_sons(), nomesom)

    def exibir_musica(self, musica):
        self.telajogo.exibe_musica(CaminhoRecursos.caminho_musicas(), musica)

    def redimensionar_imagem(self, wsize):
        hsize = 75
        img = self.get_imagem("relacao.png")
        img = pygame.transform.scale(img, (wsize + 30, hsize))
        return img

    def exibir_seta_relacao(self, wsize, posicaox, direcaonormal):
        pygameImage = self.redimensionar_imagem(wsize)

        if not direcaonormal:
            pygameImage = pygame.transform.flip(pygameImage, True, False)

        self.telajogo.exibe_imagem(pygameImage,
                                   Posicao(posicaox, self.posicaoy - 60))

    def exibir_botao_voltar_menu(self):
        botao = self.get_imagem("voltar.png")
        self.telajogo.exibe_imagem(botao, Posicao(15, 15))
        self.rectbotaovoltar = botao.get_rect().move(15, 15)

    def calcula_largura_botao(self, palavra):
        tamanhopalavra = len(palavra)
        largura = (tamanhopalavra * 10) + self.TAM_MARGEM_BOTAO
        return largura

    def cria_botao(self, palavra, cor):
        largura = self.calcula_largura_botao(palavra)
        botao = pygame.Surface((largura, 50))
        botao.fill(cor)
        return botao

    def exibir_botoes_palavras(self):
        posicaox = 50
        for palavra in self.objpalavras:
            largura = self.calcula_largura_botao(
                palavra.texto)  #TODO: pensar melhor nesse metodo repetido aqui
            botao = self.cria_botao(palavra.texto,
                                    (218, 165, 32))  #cor goldenrod

            palavra.posicaoxbotao = posicaox
            imagemrect = botao.get_rect().move(posicaox, self.posicaoy)
            palavra.set_imagemrect(imagemrect)

            self.imprimir_botao(palavra.id, botao)

            posicaox += largura + 10

        self.posicaobotaorelacoes = posicaox

    def exibir_botao_qtd_relacoes(self, posicaox):
        setarelacoes = self.get_imagem("setarelacoes.gif")
        self.telajogo.exibe_imagem(setarelacoes,
                                   Posicao(posicaox + 10, self.posicaoy - 50))
        self.telajogo.exibe_texto(str(self.apljogo.qtdrelacaoes),
                                  self.TAM_FONTE_TEXTO,
                                  Posicao(posicaox + 27, self.posicaoy - 35))

    def imprimir_botao(self, idpalavraclicada, botao):
        self.telajogo.exibe_imagem(
            botao,
            Posicao(self.objpalavras[idpalavraclicada].posicaoxbotao,
                    self.posicaoy))
        self.telajogo.exibe_texto(
            self.objpalavras[idpalavraclicada].texto, self.TAM_FONTE_TEXTO,
            Posicao(self.objpalavras[idpalavraclicada].posicaoxbotao + 10,
                    self.posicaoy + 10))

    #TODO: os tres proximos metodos virarao um so, recebendo como prametro id e cor
    def destacar_botao(self, idpalavraclicada):
        botao = self.cria_botao(self.objpalavras[idpalavraclicada].texto,
                                (255, 105, 180))  #cor HotPink
        self.imprimir_botao(idpalavraclicada, botao)

    def destacar_botao_clicado(self, idpalavraclicada):
        botao = self.cria_botao(self.objpalavras[idpalavraclicada].texto,
                                (220, 20, 60))  #cor Crimson
        self.imprimir_botao(idpalavraclicada, botao)

    def restaurar_botao(self, idpalavraclicada):
        botao = self.cria_botao(self.objpalavras[idpalavraclicada].texto,
                                (218, 165, 32))  #cor goldenrod
        self.imprimir_botao(idpalavraclicada, botao)

    def verifica_relacao(self, idpalavradestino):
        relacaoentrada = (self.idpalavraorigem, idpalavradestino, 0)

        for idrelacao in range(len(self.relacoes)):
            if self.relacoes[idrelacao] == relacaoentrada:
                self.apljogo.qtdrelacaoes -= 1
                #self.relacoes.pop(idrelacao)
                self.relacoes[idrelacao] = (self.relacoes[idrelacao][0],
                                            self.relacoes[idrelacao][1], 1)
                self.telajogo.exibe_som(self.get_som("acerto.wav"))
                return True

        self.telajogo.exibe_som(self.get_som("erro.wav"))
        # TODO: destacar de vermelho botoes da relacao incorreta
        return False

    def busca_estado_relacoes(self):
        estado = ""
        for relacao in self.relacoes:
            estado += str(relacao[2])
        return estado

    # TODO: conferir todas as possibilidades que essa logica alcanca
    def altera_cenario(self):
        estado = self.busca_estado_relacoes()
        for cenario in self.cenario:
            valido = True
            for id in range(len(estado)):
                if cenario[0][id] == "1" and estado[id] == "0":
                    valido = False
                    break

            if valido:
                imagem = self.get_imagem(cenario[1])
                self.telajogo.exibe_imagem(imagem, Posicao(0, 0))

    def controla_cor_botao_visitado(self, palavraobj):
        if palavraobj.foi_detectada(
        ) and palavraobj.id != self.idpalavraorigem and not palavraobj.ativo:
            self.destacar_botao(palavraobj.id)
        elif pygame.MOUSEBUTTONDOWN and palavraobj.id != self.idpalavraorigem and not palavraobj.ativo:
            self.restaurar_botao(palavraobj.id)

    def incrementa_lista_setas(self, wsize, posicaox, direcaonormal, relacao):
        seta = Seta(posicaox, wsize, direcaonormal, relacao)
        self.listasetas.append(seta)

    def manipula_seta_relacao(self, idorigem, iddestino):
        wsize = abs(self.objpalavras[iddestino].posicaoxbotao -
                    self.objpalavras[idorigem].posicaoxbotao)
        posicaosaidaseta = idorigem
        issequencial = iddestino > idorigem
        if (not issequencial):
            posicaosaidaseta = iddestino

        relacao = (idorigem, iddestino)
        self.incrementa_lista_setas(
            wsize, self.objpalavras[posicaosaidaseta].posicaoxbotao,
            issequencial, relacao)

    def verifica_evento_mouse(self):
        for palavraobj in self.objpalavras:
            self.controla_cor_botao_visitado(palavraobj)

            if palavraobj.foi_clicada():
                if not (self.existepalavraclicada):
                    self.idpalavraorigem = palavraobj.id
                    self.existepalavraclicada = True
                    self.destacar_botao_clicado(self.idpalavraorigem)
                else:
                    self.existepalavraclicada = False
                    self.restaurar_botao(self.idpalavraorigem)
                    if self.verifica_relacao(palavraobj.id):
                        self.altera_cenario()
                        self.manipula_seta_relacao(self.idpalavraorigem,
                                                   palavraobj.id)

                    self.idpalavraorigem = -1

    def carrega_dados(self):
        self.objpalavras = self.apljogo.captura_frase()
        self.relacoes = self.apljogo.captura_relacoes()
        self.cenario = self.apljogo.captura_relacao_cenario()
        self.apljogo.qtdrelacaoes = len(self.relacoes)

    def jogo(self):
        observable = self.inicializa_observable()
        #self.exibir_musica("music1.mp3")
        self.apljogo.configuracao()

        self.carrega_dados()
        self.exibir_botoes_palavras()
        self.exibir_botao_qtd_relacoes(self.posicaobotaorelacoes)

        self.existepalavraclicada = False
        self.continua = True
        while self.continua:
            observable.verifica_evento()
            self.verifica_evento_mouse()
            self.exibir_botao_qtd_relacoes(self.posicaobotaorelacoes)
            self.exibir_botao_voltar_menu()

            for seta in self.listasetas:
                self.exibir_seta_relacao(seta.largura, seta.posicaox,
                                         seta.direcaonormal)

            pygame.display.flip()
            self.apljogo.clock.tick(10)

    # a classe ControlodorJogo (q eh um observador)recebe atualizacao pq a classe Observada ObservableEventosTeclado
    # capturou um evento
    def update(self, observable):
        if observable.clicou and self.rectbotaovoltar.collidepoint(
                pygame.mouse.get_pos()):
            self.continua = False

    def inicializa_observable(self):
        observable = ObservableEventosTeclado()
        observable.add_observer(self)
        return observable