diff --git a/atores.py b/atores.py index cfc2ef5ea..1bb749c77 100644 --- a/atores.py +++ b/atores.py @@ -38,7 +38,8 @@ 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 colidir(self, outro_ator, intervalo=1): """ @@ -52,15 +53,33 @@ 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.verificar_colisao(self.x, self.y, outro_ator.x, outro_ator.y, intervalo): + self.destruir(intervalo) + outro_ator.destruir(intervalo) + + + @staticmethod + def verificar_colisao(x1, y1, x2, y2, tam): + if x1 - tam <= x2 <= x1 + tam and y1 - tam <= y2 <= y1 + tam: + return True + return False + + def destruir(self,intervalo=1): + self.status = DESTRUIDO + self.intervalo_colisao = intervalo + self.caracter() class Obstaculo(Ator): + _caracter_ativo = 'O' pass class Porco(Ator): + _caracter_ativo = '@' + _caracter_destruido = '+' pass @@ -93,7 +112,8 @@ def foi_lancado(self): :return: booleano """ - return True + + return self._tempo_de_lancamento is not None def colidir_com_chao(self): """ @@ -101,7 +121,10 @@ def colidir_com_chao(self): o status dos Passaro deve ser alterado para destruido, bem como o seu caracter """ - pass + if self.y <= 0.0: + self.destruir() + + def calcular_posicao(self, tempo): """ @@ -117,8 +140,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() is False: + return self._x_inicial, self._y_inicial + + if self.status == DESTRUIDO: + return self.x, self.y + + delta_t = tempo - self._tempo_de_lancamento + self.x = self._x_inicial + (self.velocidade_escalar * math.cos(self._angulo_de_lancamento) * delta_t) + self.y = self._y_inicial + (self.velocidade_escalar * math.sin(self._angulo_de_lancamento) * delta_t) - ((GRAVIDADE * (delta_t * delta_t)) / 2) + return self.x, self.y def lancar(self, angulo, tempo_de_lancamento): """ @@ -129,12 +161,19 @@ 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) class PassaroAmarelo(Passaro): + _caracter_destruido = 'a' + velocidade_escalar = 30 pass class PassaroVermelho(Passaro): + _caracter_ativo = 'V' + _caracter_destruido = 'v' + + velocidade_escalar = 20 pass \ No newline at end of file diff --git a/fase.py b/fase.py index 3385175c6..6c9c07db6 100644 --- a/fase.py +++ b/fase.py @@ -1,7 +1,6 @@ # -*- coding: utf-8 -*- from itertools import chain -from atores import ATIVO - +from atores import ATIVO, Passaro VITORIA = 'VITORIA' DERROTA = 'DERROTA' @@ -43,7 +42,7 @@ def adicionar_obstaculo(self, *obstaculos): :param obstaculos: """ - pass + self._obstaculos.extend(obstaculos) def adicionar_porco(self, *porcos): """ @@ -51,7 +50,11 @@ def adicionar_porco(self, *porcos): :param porcos: """ - pass + for porco in porcos: + porco.intervalo_colisao = self.intervalo_de_colisao + + self._porcos.extend(porcos) + def adicionar_passaro(self, *passaros): """ @@ -59,7 +62,11 @@ def adicionar_passaro(self, *passaros): :param passaros: """ - pass + for passaro in passaros: + passaro.intervalo_colisao = self.intervalo_de_colisao + + self._passaros.extend(passaros) + def status(self): """ @@ -73,6 +80,23 @@ def status(self): :return: """ + + has_passaro_ativo = False + has_porco_ativo = False + for passaro in self._passaros: + if passaro.status == ATIVO: + has_passaro_ativo = True + break + + for porco in self._porcos: + if porco.status == ATIVO: + has_porco_ativo = True + break + + if not has_porco_ativo: + return VITORIA + if not has_passaro_ativo: + return DERROTA return EM_ANDAMENTO def lancar(self, angulo, tempo): @@ -86,7 +110,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 passaro.foi_lancado() is False: + passaro.lancar(angulo, tempo) + break def calcular_pontos(self, tempo): @@ -98,10 +125,21 @@ def calcular_pontos(self, tempo): :param tempo: tempo para o qual devem ser calculados os pontos :return: objeto do tipo Ponto """ - pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos] + + pontos = [self._transformar_em_ponto_passaros(a, tempo) for a in self._passaros] + pontos.extend([self._transformar_em_ponto(a, tempo) for a in self._obstaculos+self._porcos]) return pontos - def _transformar_em_ponto(self, ator): + def _transformar_em_ponto_passaros(self, ator, tempo): + + for porco in self._porcos+self._obstaculos: + ator.colidir(porco, self.intervalo_de_colisao) + + ator.colidir_com_chao() + return self._transformar_em_ponto(ator, tempo) + + def _transformar_em_ponto(self, ator, tempo): + ator.calcular_posicao(tempo) return Ponto(ator.x, ator.y, ator.caracter()) 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..ec3be5fe7 --- /dev/null +++ b/oo/carro.py @@ -0,0 +1,192 @@ +""" +Você deve criar uma classe carro que vai possuir +dois atributos compostos por outras duas classes: + +1) Motor +2) Direção +O Motor terá a responsabilidade de controlar a velocidade. +Ele oferece os seguintes atributos: + +1) Atributo de dado velocidade +2) Método acelerar, que deverá incremetar a velocidade de uma unidade +3) Método frear que deverá decrementar a velocidade em duas unidades + +A Direção terá a responsabilidade de controlar a direção. Ela oferece +os seguintes atributos: +1) Valor de diraçã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' +""" +from oo.motor import Motor +from oo.direcao import Direcao +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__': + motor = Motor() + print(motor.velocidade) + + motor.acelerar() + print(motor.velocidade) + + motor.acelerar() + print(motor.velocidade) + + motor.acelerar() + print(motor.velocidade) + + motor.frear() + print(motor.velocidade) + + motor.frear() + print(motor.velocidade) + + direcao = Direcao() + print(direcao.valor) + + direcao.girar_a_direita() + print(direcao.valor) + + direcao.girar_a_direita() + print(direcao.valor) + + direcao.girar_a_direita() + print(direcao.valor) + + direcao.girar_a_direita() + print(direcao.valor) + + direcao.girar_a_esquerda() + print(direcao.valor) + + direcao.girar_a_esquerda() + print(direcao.valor) + + direcao.girar_a_esquerda() + print(direcao.valor) + + direcao.girar_a_esquerda() + print(direcao.valor) + + carro = Carro(direcao, motor) + carro.calcular_velocidade() + + carro.acelerar() + carro.calcular_velocidade() + + carro.acelerar() + carro.calcular_velocidade() + + carro.frear() + carro.calcular_velocidade() + + carro.calcular_direcao() + + carro.girar_a_direita() + carro.calcular_direcao() + + carro.girar_a_esquerda() + carro.calcular_direcao() + + carro.girar_a_esquerda() + carro.calcular_direcao() \ No newline at end of file diff --git a/oo/direcao.py b/oo/direcao.py new file mode 100644 index 000000000..d80f2ccc5 --- /dev/null +++ b/oo/direcao.py @@ -0,0 +1,14 @@ +class Direcao: + direcao= ['Norte', 'Leste', 'Sul', 'Oeste'] + + def __init__(self): + self.valor= self.direcao[0] + + def girar_a_direita(self): + posicao = self.direcao.index(self.valor) + 1 + self.valor = self.direcao[0 if posicao >= len(self.direcao) else posicao] + + def girar_a_esquerda(self): + posicao = self.direcao.index(self.valor) - 1 + self.valor = self.direcao[len(self.direcao) - 1 if posicao < 0 else posicao] + diff --git a/oo/motor.py b/oo/motor.py new file mode 100644 index 000000000..96171cf1b --- /dev/null +++ b/oo/motor.py @@ -0,0 +1,9 @@ +class Motor: + def __init__(self): + self.velocidade = 0 + + def acelerar(self): + self.velocidade += 1 + + def frear(self): + self.velocidade = max(0, self.velocidade - 2) diff --git a/oo/pessoa.py b/oo/pessoa.py new file mode 100644 index 000000000..43212ef65 --- /dev/null +++ b/oo/pessoa.py @@ -0,0 +1,47 @@ +class Pessoa: + olhos = 2 + + def __init__(self, *filhos, nome=None, idade=27): + self.idade = idade + self.nome = nome + self.filhos = list(filhos) + + def cumprimentar(self): + return f'Olá {id(self)}' + + @staticmethod + def metodo_estatico(): + return 50 + + @classmethod + def nome_e_atributos_de_classes(cls): + return f'[{cls} - olhos {cls.olhos}]' + +class Homem(Pessoa): + pass + +if __name__ == '__main__': + luciano = Homem(nome='Luciano') + luiz = Homem(luciano,nome='Luiz') + print(luiz.nome) + for f in luiz.filhos: + print(f.nome) + luciano.sobrenome = 'Luiz Filho' + del luciano.filhos + luciano.olhos = 1 + del luciano.olhos + print(luciano.sobrenome) + print(luciano.__dict__) + print(luiz.__dict__) + Pessoa.olhos = 3 + print(Pessoa.olhos) + print(luciano.olhos) + print(luiz.olhos) + print(id(Pessoa.olhos), id(luciano.olhos), id(luiz.olhos)) + print(Pessoa.metodo_estatico(), luciano.metodo_estatico()) + print(Pessoa.nome_e_atributos_de_classes(), luciano.nome_e_atributos_de_classes()) + pessoa = Pessoa() + print(isinstance(pessoa, Pessoa)) + print(isinstance(pessoa, Homem)) + print(isinstance(luiz, Homem)) + print(isinstance(luiz, Homem)) \ No newline at end of file diff --git a/oo/teste_carro.py b/oo/teste_carro.py new file mode 100644 index 000000000..14f94dfed --- /dev/null +++ b/oo/teste_carro.py @@ -0,0 +1,14 @@ +from unittest import TestCase + +from oo.motor import Motor + + +class CarroTestCase(TestCase): + def teste_velocidade_inicial(self): + motor = Motor() + self.assertEqual(0, motor.velocidade) + + def teste_acelerar(self): + motor = Motor() + motor.acelerar() + self.assertEqual(1, motor.velocidade) \ No newline at end of file diff --git a/testes/atores_testes.py b/testes/testes_atores.py similarity index 100% rename from testes/atores_testes.py rename to testes/testes_atores.py diff --git a/testes/fase_testes.py b/testes/testes_fase.py similarity index 100% rename from testes/fase_testes.py rename to testes/testes_fase.py diff --git a/testes/integracao.py b/testes/testes_integracao.py similarity index 100% rename from testes/integracao.py rename to testes/testes_integracao.py