forked from pythonprobr/pythonbirds
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathfase.py
More file actions
155 lines (119 loc) · 4.44 KB
/
fase.py
File metadata and controls
155 lines (119 loc) · 4.44 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
# -*- coding: utf-8 -*-
from itertools import chain
from atores import ATIVO, DuploLancamentoExcecao
# Status possíveis do jogo
VITORIA = 'VITORIA'
DERROTA = 'DERROTA'
EM_ANDAMENTO = 'EM_ANDAMENTO'
class Ponto():
def __init__(self, x, y, caracter):
self.caracter = caracter
self.x = round(x)
self.y = round(y)
def __eq__(self, other):
return self.x == other.x and self.y == other.y and self.caracter == other.caracter
def __hash__(self):
return hash(self.x) ^ hash(self.y)
def __repr__(self, *args, **kwargs):
return "Ponto(%s,%s,'%s')" % (self.x, self.y, self.caracter)
class Fase():
def __init__(self, intervalo_de_colisao=1):
"""
Método que inicializa uma fase.
:param intervalo_de_colisao:
"""
self.intervalo_de_colisao = intervalo_de_colisao
self._passaros = []
self._porcos = []
self._obstaculos = []
def _adicionar_ator(self, lista, *atores):
lista.extend(atores)
def adicionar_obstaculo(self, *obstaculos):
"""
Adiciona obstáculos em uma fase
:param obstaculos:
"""
self._adicionar_ator(self._obstaculos, *obstaculos)
def adicionar_porco(self, *porcos):
"""
Adiciona porcos em uma fase
:param porcos:
"""
self._adicionar_ator(self._porcos, *porcos)
def adicionar_passaro(self, *passaros):
"""
Adiciona pássaros em uma fase
:param passaros:
"""
self._adicionar_ator(self._passaros, *passaros)
# def acabou(self):
# """
# Método que retorna verdadeiro se o jogo acabou e falso caso contrário
#
# O jogo pode acabar por dois motivos:
#
# 1. Não existem mais porcos ativos no jogo
# 2. Não existem mais pássaros ativos no jogo
#
# :return: booleano
# """
# return self.status() != EM_ANDAMENTO
def status(self):
"""
Método que indica com mensagem o status do jogo
Se o jogo está em andamento (ainda tem porco ativo e pássaro ativo), retorna essa mensagem.
Se o jogo acabou com derrota (ainda existe porco ativo), retorna essa mensagem
Se o jogo acabou com vitória (não existe porco ativo), retorna essa mensagem
:return:
"""
if not self._existe_porco_ativo():
return VITORIA
if self._existe_passaro_ativo():
return EM_ANDAMENTO
return DERROTA
def lancar(self, angulo, tempo):
"""
Método que executa lógica de lançamento.
Deve escolher o primeiro pássaro não lançado da lista e chamar seu método lançar
Se não houver esse tipo de pássaro, não deve fazer nada
:param angulo: ângulo de lançamento
:param tempo: tempo de lançamento
"""
for passaro in self._passaros:
try:
passaro.lancar(angulo, tempo)
except DuploLancamentoExcecao:
continue
else:
return
def calcular_pontos(self, tempo):
"""
Lógica que retorna os pontos a serem exibidos na tela.
Cada ator deve ser transformado em um Ponto.
:param tempo: tempo para o qual devem ser calculados os pontos
:return: objeto do tipo Ponto
"""
pontos = [self._calcular_ponto_de_passaro(p, tempo) for p in self._passaros]
obstaculos_e_porcos = chain(self._obstaculos, self._porcos)
pontos.extend([self._transformar_em_ponto(ator) for ator in obstaculos_e_porcos])
return pontos
def _transformar_em_ponto(self, ator):
return Ponto(ator.x, ator.y, ator.caracter())
def _calcular_ponto_de_passaro(self, passaro, tempo, ):
passaro.calcular_posicao(tempo)
for ator in chain(self._obstaculos, self._porcos):
if ATIVO == passaro.status:
passaro.colidir(ator, self.intervalo_de_colisao)
passaro.colidir_com_chao()
else:
break
return self._transformar_em_ponto(passaro)
def _existe_porco_ativo(self):
return self._verificar_se_existe_ator_ativo(self._porcos)
def _verificar_se_existe_ator_ativo(self, atores):
for a in atores:
if a.status == ATIVO:
return True
return False
def _existe_passaro_ativo(self):
return self._verificar_se_existe_ator_ativo(self._passaros)