diff --git a/atores.py b/atores.py index cfc2ef5ea..d7e7493cd 100644 --- a/atores.py +++ b/atores.py @@ -38,7 +38,18 @@ def calcular_posicao(self, tempo): :param tempo: o tempo do jogo :return: posição x, y do ator """ - return 1, 1 + return self.x, self.y + + # def _mesma_posicao(self, outro_ator): + # return self.x == outro_ator.x and self.y == outro_ator.y + # + # def _intersecao_de_atores(self, outro_ator, intervalo): + # limite = intervalo * 2 + # + # d = ((outro_ator.x - self.x) ** 2) + ((outro_ator.y - self.y) ** 2) + # d = math.sqrt(d) + # + # return d < limite def colidir(self, outro_ator, intervalo=1): """ @@ -52,16 +63,24 @@ def colidir(self, outro_ator, intervalo=1): :param intervalo: Intervalo a ser considerado :return: """ - pass + if self.status == ATIVO and outro_ator.status == ATIVO: + # if self._mesma_posicao(outro_ator) or self._intersecao_de_atores(outro_ator, intervalo): + delta_x = abs(self.x - outro_ator.x) + delta_y = abs(self.y - outro_ator.y) + if delta_x <= intervalo and delta_y <= intervalo: + self.status = DESTRUIDO + outro_ator.status = DESTRUIDO class Obstaculo(Ator): - pass + _caracter_ativo = 'O' + _caracter_destruido = ' ' class Porco(Ator): - pass + _caracter_ativo = '@' + _caracter_destruido = '+' class DuploLancamentoExcecao(Exception): @@ -93,7 +112,11 @@ def foi_lancado(self): :return: booleano """ - return True + return not self._tempo_de_lancamento is None + # if self._tempo_de_lancamento is None and self._angulo_de_lancamento is None: + # return False + # + #return True def colidir_com_chao(self): """ @@ -101,7 +124,26 @@ def colidir_com_chao(self): o status dos Passaro deve ser alterado para destruido, bem como o seu caracter """ - pass + if self.y <= 0: + self.status = DESTRUIDO + + def _posicao_de_x(self, delta_tempo): + # return (self._x_inicial + + # math.cos(self._angulo_de_lancamento) * tempo * self.velocidade_escalar) + x_atual = self._x_inicial + x_atual += math.cos(self._angulo_de_lancamento) * delta_tempo * self.velocidade_escalar + self.x = x_atual + + def _posicao_de_y(self, delta_tempo): + """ considerando subida """ + # return (self._y_inicial + + # self.velocidade_escalar * tempo * math.sin(self._angulo_de_lancamento) - + # 0.5 * GRAVIDADE * tempo ** 2) + y_atual = self._y_inicial + y_atual += self.velocidade_escalar * delta_tempo * math.sin(self._angulo_de_lancamento) + y_atual -= 0.5 * GRAVIDADE * delta_tempo ** 2 + self.y = y_atual + def calcular_posicao(self, tempo): """ @@ -117,8 +159,17 @@ def calcular_posicao(self, tempo): :param tempo: tempo de jogo a ser calculada a posição :return: posição x, y """ - return 1, 1 + if self.foi_lancado() and self.status == ATIVO: + delta_tempo = tempo - self._tempo_de_lancamento + # lançamento horizontal + # self.x = self._posicao_de_x(delta_tempo) + self._posicao_de_x(delta_tempo) + # lançamento vertical + #self.y = self._posicao_de_y(tempo) + self._posicao_de_y(delta_tempo) + return super().calcular_posicao(tempo) + # return self.x, self.y def lancar(self, angulo, tempo_de_lancamento): """ @@ -129,12 +180,20 @@ def lancar(self, angulo, tempo_de_lancamento): :param tempo_de_lancamento: :return: """ - pass + + self._tempo_de_lancamento = tempo_de_lancamento + self._angulo_de_lancamento = math.radians(angulo) # radianos class PassaroAmarelo(Passaro): + _caracter_ativo = 'A' + _caracter_destruido = 'a' + velocidade_escalar = 30 + pass class PassaroVermelho(Passaro): - pass \ No newline at end of file + _caracter_ativo = 'V' + _caracter_destruido = 'v' + velocidade_escalar = 20 \ No newline at end of file diff --git a/fase.py b/fase.py index 3385175c6..ab38dc497 100644 --- a/fase.py +++ b/fase.py @@ -36,14 +36,13 @@ def __init__(self, intervalo_de_colisao=1): self._porcos = [] self._obstaculos = [] - def adicionar_obstaculo(self, *obstaculos): """ Adiciona obstáculos em uma fase :param obstaculos: """ - pass + self._obstaculos.extend(obstaculos) def adicionar_porco(self, *porcos): """ @@ -51,7 +50,10 @@ def adicionar_porco(self, *porcos): :param porcos: """ - pass + for i in porcos: + i.intervalo_colisao = self.intervalo_de_colisao + + self._porcos.extend(porcos) def adicionar_passaro(self, *passaros): """ @@ -59,7 +61,10 @@ def adicionar_passaro(self, *passaros): :param passaros: """ - pass + for i in passaros: + i.intervalo_colisao = self.intervalo_de_colisao + + self._passaros.extend(passaros) def status(self): """ @@ -73,7 +78,12 @@ def status(self): :return: """ - return EM_ANDAMENTO + if not self._possui_porco_ativo(): + return VITORIA + elif self._possui_passaro_ativo(): + return EM_ANDAMENTO + else: + return DERROTA def lancar(self, angulo, tempo): """ @@ -86,8 +96,10 @@ def lancar(self, angulo, tempo): :param angulo: ângulo de lançamento :param tempo: Tempo de lançamento """ - pass - + for passaro in self._passaros: + if not passaro.foi_lancado(): + passaro.lancar(angulo, tempo) + break def calcular_pontos(self, tempo): """ @@ -98,6 +110,12 @@ def calcular_pontos(self, tempo): :param tempo: tempo para o qual devem ser calculados os pontos :return: objeto do tipo Ponto """ + for passaro in self._passaros: + passaro.calcular_posicao(tempo) + for alvo in self._porcos+self._obstaculos: + passaro.colidir(alvo, self.intervalo_de_colisao) + passaro.colidir_com_chao() + pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos] return pontos @@ -105,3 +123,14 @@ def calcular_pontos(self, tempo): def _transformar_em_ponto(self, ator): return Ponto(ator.x, ator.y, ator.caracter()) + def _possui_porco_ativo(self): + for porco in self._porcos: + if porco.status == ATIVO: + return True + return False + + def _possui_passaro_ativo(self): + for passaro in self._passaros: + if passaro.status == ATIVO: + return True + return False diff --git a/oo/__init__.py b/oo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/oo/carro.py b/oo/carro.py new file mode 100644 index 000000000..5ec812fb8 --- /dev/null +++ b/oo/carro.py @@ -0,0 +1,190 @@ +"""VocÊ deve criar uma classe carro que vai possuir +dois atributos compostos por outras duas classe: + +1) Motor +2) Direção + +O Motor trá a responsabilidade de controlar a velocidade. +Ele oferece os seguintes attributos: + +1) Attr de dado velocidade +2) Method acelear, que deverá incrementar a velocidade de + uma unidade +3) Method frear que deverá decrementar a velocidade em duas + unidades. + +A Direção terá a responsabilidede de controlar a direção. + Ela oferacerá os seguintes attrs: + +1) Valor da direção com valores possíveis: Norte, Sul, Leste + Oeste. +2) Método girar_a_direita +3) Método girar_a_esquerda + + N +O L + S + + Exemplo: + >>> # Testando Motor + >>> motor = Motor() + >>> motor.velocidade + 0 + >>> motor.acelerar() + >>> motor.velocidade + 1 + >>> motor.acelerar() + >>> motor.velocidade + 2 + >>> motor.acelerar() + >>> motor.velocidade + 3 + >>> motor.frear() + >>> motor.velocidade + 1 + >>> motor.frear() + >>> motor.velocidade + 0 + >>> # Testando Direcao + >>> direcao = Direcao() + >>> direcao.valor + 'Norte' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Leste' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Sul' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Oeste' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Norte' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Oeste' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Sul' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Leste' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Norte' + >>> + >>> carro = Carro(direcao, motor) + >>> carro.calcular_velocidade() + 0 + >>> carro.acelerar() + >>> carro.calcular_velocidade() + 1 + >>> carro.acelerar() + >>> carro.calcular_velocidade() + 2 + >>> carro.frear() + >>> carro.calcular_velocidade() + 0 + >>> carro.calcular_direcao() + 'Norte' + >>> carro.girar_a_direita() + >>> carro.calcular_direcao() + 'Leste' + >>> carro.girar_a_esquerda() + >>> carro.calcular_direcao() + 'Norte' + >>> carro.girar_a_esquerda() + >>> carro.calcular_direcao() + 'Oeste' +""" + + +class Motor: + def __init__(self): + self.velocidade = 0 + + def acelerar(self): + self.velocidade += 1 + + def frear(self): + self.velocidade -= 2 + self.velocidade = max(0, self.velocidade) + # if self.velocidade > 2: + # self.velocidade -= 2 + # else: + # self.velocidade = 0 + +NORTE = 'Norte' +SUL = 'Sul' +LESTE = 'Leste' +OESTE = 'Oeste' + + +class Direcao: + rotacao_a_direita = { + NORTE: LESTE, + LESTE: SUL, + SUL: OESTE, + OESTE: NORTE + } + rotacao_a_esquerda = { + NORTE: OESTE, + OESTE: SUL, + SUL: LESTE, + LESTE:NORTE + } + + def __init__(self): + # self.direcao_valores = ['Norte', 'Leste', 'Sul', 'Oeste'] + # self.valor = 'Norte' + self.valor = NORTE + + def girar_a_direita(self): + # direcao_atual = self.direcao_valores.index(self.valor) + # if self.valor == 'Oeste': + # direcao_atual = 0 + # else: + # direcao_atual += 1 + # + # self.valor = self.direcao_valores[direcao_atual] + self.valor = self.rotacao_a_direita[self.valor] + + def girar_a_esquerda(self): + # direcao_atual = self.direcao_valores.index(self.valor) + # if self.valor == 'Norte': + # direcao_atual = 3 + # else: + # direcao_atual -= 1 + # + # self.valor = self.direcao_valores[direcao_atual] + self.valor = self.rotacao_a_esquerda[self.valor] + + +class Carro: + def __init__(self, direcao, motor): + self.direcao = direcao + self.motor = motor + + def calcular_velocidade(self): + return self.motor.velocidade + + def acelerar(self): + self.motor.acelerar() + + def frear(self): + self.motor.frear() + + def calcular_direcao(self): + return self.direcao.valor + + def girar_a_direita(self): + self.direcao.girar_a_direita() + + def girar_a_esquerda(self): + self.direcao.girar_a_esquerda() + + +if __name__ == '__main__': + import doctest + doctest.testmod() \ No newline at end of file diff --git a/oo/pessoa.py b/oo/pessoa.py new file mode 100644 index 000000000..37d8f9098 --- /dev/null +++ b/oo/pessoa.py @@ -0,0 +1,67 @@ +class Pessoa: + # da classe + olhos = 2 + + # da instancia + def __init__(self, *filhos, nome=None, idade=35): + self.idade = idade + self.nome = nome + self.filhos = list(filhos) + + def cumprimentar(self): + return f'Olá, meu nome é {self.nome}' + + @staticmethod + def metodo_estatico(): + return 42 + + @classmethod + def nome_e_attr_de_classe(cls): + return f'{cls} - olhos {cls.olhos}' + + +class Homem(Pessoa): + def cumprimentar(self): + cumprimentar_da_classe = super().cumprimentar() + return f'{cumprimentar_da_classe}. Aperto de mão' + +class Mutante(Pessoa): + olhos = 3 + + +if __name__ == '__main__': + renzo = Mutante(nome='Renzo', idade=30) + luciano = Homem(renzo, nome='Luciano') + + print(Pessoa.cumprimentar(luciano)) + print(id(luciano)) + print(luciano.cumprimentar()) + print(luciano.nome) + print(luciano.idade) + for filho in luciano.filhos: + print(filho.nome) + print(filho.idade) + # da instância + luciano.sobrenome = 'Ramalho' + print(luciano.sobrenome) + del luciano.sobrenome + # __dict__ - da instância + print(luciano.__dict__) + print(renzo.__dict__) + print(f'antes da mudança luciano.olhos - {luciano.olhos}') + # da classe - vai todas as instancias + print(Pessoa.olhos) + print(luciano.olhos) + print(renzo.olhos) + print(id(Pessoa.olhos), id(luciano.olhos), id(renzo.olhos)) + print(Pessoa.metodo_estatico(), luciano.metodo_estatico()) + print(Pessoa.nome_e_attr_de_classe(), luciano.nome_e_attr_de_classe()) + print(isinstance(luciano, Pessoa)) + print(isinstance(luciano, Homem)) + print(isinstance(renzo, Pessoa)) + print(isinstance(renzo, Homem)) + print(renzo.olhos) + print(luciano.cumprimentar()) + print(renzo.cumprimentar()) + + diff --git a/oo/test_carro.py b/oo/test_carro.py new file mode 100644 index 000000000..bbe0e911a --- /dev/null +++ b/oo/test_carro.py @@ -0,0 +1,55 @@ +from unittest import TestCase +from oo.carro import Motor, Direcao, Carro + + +class CarroTestCase(TestCase): + def setUp(self): + self.motor = Motor() + self.direcao = Direcao() + + def test_velocidade_inicial(self): + self.assertEqual(0, self.motor.velocidade) + + def test_acelerar(self): + self.motor.acelerar() + self.assertEqual(1, self.motor.velocidade) + + def test_frear(self): + self.motor.acelerar() + self.motor.frear() + self.assertEqual(0, self.motor.velocidade) + + def test_direcao_inicial(self): + self.assertEqual('Norte', self.direcao.valor) + + def test_direcao_direita(self): + rumo = list(self.direcao.rotacao_a_direita.values()) + + with self.subTest(): + for i in rumo: + self.direcao.girar_a_direita() + self.assertEqual(i, self.direcao.valor) + + def test_direcao_esquerda(self): + rumo = list(self.direcao.rotacao_a_esquerda.values()) + + with self.subTest(): + for i in rumo: + self.direcao.girar_a_esquerda() + self.assertEqual(i, self.direcao.valor) + + + + + + + + + + + + + + + + diff --git a/testes/atores_testes.py b/testes/test_atores.py similarity index 99% rename from testes/atores_testes.py rename to testes/test_atores.py index f4254f29e..c682de0c3 100644 --- a/testes/atores_testes.py +++ b/testes/test_atores.py @@ -148,6 +148,8 @@ class ObstaculoTestes(TestCase): """ def teste_status(self): obstaculo = Obstaculo() + #obstaculo._caracter_ativo = 'O' + #obstaculo._caracter_destruido = ' ' self.assertEqual('O', obstaculo.caracter()) outro_ator_na_mesma_posicao = Ator() obstaculo.colidir(outro_ator_na_mesma_posicao) @@ -160,6 +162,8 @@ class PorcoTestes(TestCase): """ def teste_status(self): porco = Porco() + # porco._caracter_ativo = '@' + # porco._caracter_destruido = '+' self.assertEqual('@', porco.caracter()) outro_ator_na_mesma_posicao = Ator() porco.colidir(outro_ator_na_mesma_posicao) @@ -197,6 +201,8 @@ class PassaroVermelhoTests(PassaroBaseTests): def teste_status(self): passaro_vermelho = PassaroVermelho(1, 1) + # passaro_vermelho._caracter_ativo = 'V' + # passaro_vermelho._caracter_destruido = 'v' self.assertEqual('V', passaro_vermelho.caracter()) outro_ator_na_mesma_posicao = Ator() passaro_vermelho.colidir(outro_ator_na_mesma_posicao) @@ -249,6 +255,8 @@ class PassaroAmareloTests(PassaroBaseTests): def teste_status(self): passaro_amarelo = PassaroAmarelo(1, 1) + # passaro_amarelo._caracter_ativo = 'A' + # passaro_amarelo._caracter_destruido = 'a' self.assertEqual('A', passaro_amarelo.caracter()) outro_ator_na_mesma_posicao = Ator() passaro_amarelo.colidir(outro_ator_na_mesma_posicao) diff --git a/testes/fase_testes.py b/testes/test_fase.py similarity index 100% rename from testes/fase_testes.py rename to testes/test_fase.py diff --git a/testes/integracao.py b/testes/test_integracao.py similarity index 100% rename from testes/integracao.py rename to testes/test_integracao.py