Python fase.Fase类代码示例

    def teste_adicionar_passaro(self):
        fase = Fase()
        self.assertListEqual([], fase._passaros)
        passaro = PassaroVermelho()
        fase.adicionar_passaro(passaro)
        self.assertListEqual([passaro], fase._passaros)

        passaro1, passaro2 = PassaroVermelho(), PassaroAmarelo()
        fase.adicionar_passaro(passaro1, passaro2)
        self.assertListEqual([passaro, passaro1, passaro2], fase._passaros)

    def teste_adicionar_obstaculo(self):
        fase = Fase()
        self.assertListEqual([], fase._obstaculos)
        obstaculo = Obstaculo()
        fase.adicionar_obstaculo(obstaculo)
        self.assertListEqual([obstaculo], fase._obstaculos)

        obstaculo1, obstaculo2 = Obstaculo(), Obstaculo()
        fase.adicionar_obstaculo(obstaculo1, obstaculo2)
        self.assertListEqual([obstaculo, obstaculo1, obstaculo2], fase._obstaculos)

    def teste_adicionar_porco(self):
        fase = Fase()
        self.assertListEqual([], fase._porcos)
        porco = Porco()
        fase.adicionar_porco(porco)
        self.assertListEqual([porco], fase._porcos)

        porco1, porco2 = Porco(), Porco()
        fase.adicionar_porco(porco1, porco2)
        self.assertListEqual([porco, porco1, porco2], fase._porcos)

 def teste_intervalo_de_colisao_nao_padrao(self):
     '''
     Método que testa se o intervalo de colisão da Fase é repassado aos atores. valor testado: 31
     '''
     fase = Fase(30)
     passaro = PassaroAmarelo(1, 1)
     fase.adicionar_passaro(passaro)
     porco = Porco(31, 31)
     fase.adicionar_porco(porco)
     fase.calcular_pontos(0)
     self.assertEqual(DESTRUIDO, passaro.status)
     self.assertEqual(DESTRUIDO, porco.status)

def criar_fase_exemplo(multiplicador=1):
    fase_exemplo = Fase(1 if multiplicador == 1 else 32)
    passaros = [PassaroVermelho(3 * multiplicador, 3 * multiplicador),
                PassaroAmarelo(3 * multiplicador, 3 * multiplicador),
                PassaroAmarelo(3 * multiplicador, 3 * multiplicador)]
    porcos = [Porco(78 * multiplicador, multiplicador), Porco(70 * multiplicador, multiplicador)]
    obstaculos = [Obstaculo(31 * multiplicador, 10 * multiplicador)]

    fase_exemplo.adicionar_passaro(*passaros)
    fase_exemplo.adicionar_porco(*porcos)
    fase_exemplo.adicionar_obstaculo(*obstaculos)

    return fase_exemplo

    def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self):
        passaro_vermelho, passaro_amarelo = PassaroVermelho(1, 1), PassaroAmarelo(1, 1)
        fase = Fase()
        fase.adicionar_passaro(passaro_vermelho, passaro_amarelo)
        self.assertFalse(passaro_vermelho.foi_lancado())
        self.assertFalse(passaro_amarelo.foi_lancado())
        fase.lancar(90, 1)
        fase.lancar(45, 3)
        fase.lancar(31, 5)  # testando que lançar passaros depios de todos lançados não causa erro

        self.assertTrue(passaro_vermelho.foi_lancado())
        self.assertEqual(math.radians(90), passaro_vermelho._angulo_de_lancamento)
        self.assertEqual(1, passaro_vermelho._tempo_de_lancamento)

        self.assertTrue(passaro_amarelo.foi_lancado())
        self.assertEqual(math.radians(45), passaro_amarelo._angulo_de_lancamento)
        self.assertEqual(3, passaro_amarelo._tempo_de_lancamento)

    def teste_acabou_com_porcos_e_passaros(self):
        fase = Fase()
        porcos = [Porco(1, 1) for i in range(2)]  # criando 2 porcos
        passaros = [PassaroAmarelo(1, 1) for i in range(2)]  # criando 2 pássaros
        fase.adicionar_porco(*porcos)
        fase.adicionar_passaro(*passaros)

        self.assertEqual(EM_ANDAMENTO, fase.status())

        # colidindo cada passaro com um porco no tempo 3
        for passaro, porco in zip(passaros, porcos):
            passaro.colidir(porco, 3)

        self.assertEqual(VITORIA, fase.status())

        fase.adicionar_obstaculo(Obstaculo())
        self.assertEqual(VITORIA, fase.status(), 'Obstáculo não interfere no fim do jogo')

        fase.adicionar_porco(Porco())
        self.assertEqual(DERROTA, fase.status(), 'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar')

        fase.adicionar_passaro(PassaroAmarelo())
        self.assertEqual(EM_ANDAMENTO, fase.status(),
                         'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')

 def teste_acabou_sem_porcos(self):
     fase = Fase()
     self.assertEqual(VITORIA, fase.status())

    tela.bind_all('3', _finalizar)
    tela.bind_all('<Escape>', _finalizar)

    tela.mainloop()
    tela.after(passo, _animar)


def rodar_fase(fase):
    root.title("Python Birds")
    root.geometry("800x600")
    root.resizable(0, 0)
    stage = Canvas(root, width=800, height=ALTURA_DA_TELA)

    multiplicador = 10
    PassaroAmarelo.velocidade_escalar *= multiplicador
    PassaroVermelho.velocidade_escalar *= multiplicador
    atores.GRAVIDADE = 100
    animar(root, stage, fase)


if __name__ == '__main__':
    fase = Fase(intervalo_de_colisao=32)
    passaros = [PassaroVermelho(30, 30), PassaroAmarelo(30, 30), PassaroAmarelo(30, 30)]
    porcos = [Porco(750, 1), Porco(700, 1)]
    obstaculos = [Obstaculo(310, 100)]

    fase.adicionar_obstaculo(*obstaculos)
    fase.adicionar_passaro(*passaros)
    fase.adicionar_porco(*porcos)
    rodar_fase(fase)

# -*- coding: utf-8 -*-
from os import path
import sys
import math

project_dir = path.dirname(__file__)
project_dir = path.join('..')
sys.path.append(project_dir)

from atores import PassaroAmarelo, PassaroVermelho, Obstaculo, Porco
from fase import Fase
from placa_grafica_tkinter import rodar_fase
from random import randint

if __name__ == '__main__':
    fase = Fase(intervalo_de_colisao=32)


    # Adicionar Pássaros Amarelos
    for i in range(80):
        fase.adicionar_passaro(PassaroAmarelo(30, 30))


    # Obstaculos
    theta = 270
    h = 12
    k = 7
    step = 32
    r = 50

    while theta < 480:

    def teste_status(self):
        fase = Fase()
        porcos = [Porco(1, 1) for i in range(2)]
        passaros = [PassaroAmarelo(1, 1) for i in range(2)]
        fase.adicionar_porco(*porcos)
        fase.adicionar_passaro(*passaros)
        self.assertEqual('Jogo em andamento.', fase.status(0))
        self.assertEqual('Jogo em andamento.', fase.status(2.9))
        self.assertEqual('Jogo em andamento.', fase.status(3))

        for passaro, porco in zip(passaros, porcos):
            passaro.colidir(porco, 3)

        self.assertEqual('Jogo em andamento.', fase.status(0))
        self.assertEqual('Jogo em andamento.', fase.status(2.9))
        self.assertEqual('Jogo em encerrado. Você ganhou!', fase.status(3),
                         'Sem porcos ativos o jogo deveria terminar com vitória')

        fase.adicionar_obstaculo(Obstaculo())
        self.assertEqual('Jogo em encerrado. Você ganhou!', fase.status(3),
                         'Obstáculo não interfere para definir vitória')

        porco = Porco()
        fase.adicionar_porco(porco)
        self.assertEqual('Jogo em encerrado. Você perdeu!', fase.status(3),
                         'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar em derrota')

        fase.adicionar_passaro(PassaroAmarelo())
        self.assertEqual('Jogo em andamento.', fase.status(3),
                         'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')

        porco.colidir(porco, 3)
        self.assertEqual('Jogo em encerrado. Você ganhou!', fase.status(3),
                         'Sem porco ativo, o jogo deveria acabar com vitória')

    def teste_acabou_com_porcos_e_passaros(self):
        fase = Fase()
        porcos = [Porco(1, 1) for i in range(2)]  # criando 2 porcos
        passaros = [PassaroAmarelo(1, 1) for i in range(2)]  # criando 2 pássaros
        fase.adicionar_porco(*porcos)
        fase.adicionar_passaro(*passaros)

        self.assertFalse(fase.acabou(0))
        self.assertFalse(fase.acabou(2.9))
        self.assertFalse(fase.acabou(3))

        # colidingo cada passaro com um porco no tempo 3
        for passaro, porco in zip(passaros, porcos):
            passaro.colidir(porco, 3)

        self.assertFalse(fase.acabou(0))
        self.assertFalse(fase.acabou(2.9))
        self.assertTrue(fase.acabou(3))

        fase.adicionar_obstaculo(Obstaculo())
        self.assertTrue(fase.acabou(3), 'Obstáculo não interfere no fim do jogo')

        fase.adicionar_porco(Porco())
        self.assertTrue(fase.acabou(3), 'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar')

        fase.adicionar_passaro(PassaroAmarelo())
        self.assertFalse(fase.acabou(3), 'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')

 def teste_acabou_sem_porcos(self):
     fase = Fase()
     self.assertTrue(fase.acabou(0))

def criar_fase_exemplo():
    fase_exemplo = Fase()
    passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
    porcos = [Porco(78, 1), Porco(70, 1)]
    obstaculos = [Obstaculo(31, 10)]

    fase_exemplo.adicionar_passaro(*passaros)
    fase_exemplo.adicionar_porco(*porcos)
    fase_exemplo.adicionar_obstaculo(*obstaculos)

    fase_exemplo.lancar(45, 1)
    fase_exemplo.lancar(63, 3)
    fase_exemplo.lancar(23, 4)

    for i in range(86):
        fase_exemplo.calcular_pontos(i / 10)
    return fase_exemplo

                    Ponto(70, 1, '@')]
        self.assertListEqual(expected, fase_exemplo.calcular_pontos(4))

        expected = [Ponto(31, 11, 'v'), Ponto(57, 30, 'A'), Ponto(69, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '@'),
                    Ponto(70, 1, '+')]
        self.assertListEqual(expected, fase_exemplo.calcular_pontos(7))

        expected = [Ponto(31, 11, 'v'), Ponto(77, 2, 'a'), Ponto(69, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '+'),
                    Ponto(70, 1, '+')]
        self.assertListEqual(expected, fase_exemplo.calcular_pontos(8.5))

        self.assertFalse(fase_exemplo.acabou(8.3))
        self.assertTrue(fase_exemplo.acabou(8.5))


fase_exemplo = Fase()
passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
porcos = [Porco(78, 1), Porco(70, 1)]
obstaculos = [Obstaculo(31, 10)]

fase_exemplo.adicionar_passaro(*passaros)
fase_exemplo.adicionar_porco(*porcos)
fase_exemplo.adicionar_obstaculo(*obstaculos)

fase_exemplo.lancar(45, 1)
fase_exemplo.lancar(63, 3)
fase_exemplo.lancar(23, 4)

for i in range(86):
    fase_exemplo.calcular_pontos(i / 10)