def __init__(self, topic):
self.orientacao = Vetor(0, 0)
self.pos = Vetor(0, 0)
self.lado = 0
rospy.Subscriber(topic, Pose, self.recebe_dados)
def test_abs():
"""
testa se o operador abs funciona
"""
v_a = Vetor(3, 4)
v_b = Vetor(9, 16)
abs_a = abs(v_a)
assert abs_a == sqrt(v_a.x**2 + v_a.y**2)
abs_b = abs(v_b)
assert abs_b == sqrt(v_b.x**2 + v_b.y**2)
def test_eq():
"""
Testa se igualdade funciona
"""
v_a = Vetor(1, 2)
v_b = Vetor(1, 2)
v_c = Vetor(2, 1)
assert v_a == v_b
assert v_b == v_a
assert v_c != v_a
def __init__(self, ambiente, imagem, posicao=Vetor(0, 0)):
"""
Neste metodo um objeto circular e criado
:param ambiente: O ambiente pygame do jogo, que e usado para carregar
a imagem
:param imagem: O caminho da imagem do objeto
:param posicao: A posicao inicial do objeto
"""
Objeto.__init__(self, ambiente, imagem, posicao)
self._raio = self.imagem.get_width() / 2
self.posicao += Vetor(self._raio, self._raio)
def test_add():
"""
Testa se soma funciona
"""
v_a = Vetor(1, 2)
v_b = Vetor(1, 2)
v_c = Vetor(2, 1)
v_ab = v_a + v_b
assert v_ab.x == v_a.x + v_b.x
assert v_ab.y == v_a.y + v_b.y
v_abc = v_a + v_b + v_c
assert v_abc.x == v_a.x + v_b.x + v_c.x
assert v_abc.y == v_a.y + v_b.y + v_c.y
def integracao(self, tempo):
'''(Nbody, float) -> None
Realiza integracao numerica da forca gravitacional em Nbody
'''
t = 0
while t < tempo and self.n > 1:
for i in range(self.n):
body = self.bodies[i]
# somatoria de forcas devido as demais particulas
f_res = Vetor()
for j in range(self.n):
if i != j:
f_res += body.gravity(self.bodies[j])
# calculando impulso nesse corpo
dp = f_res.multiply(dt)
# calculando velocidade atual
body.p = body.p + dp
body.v = body.p.multiply(1 / body.m)
# calculando posicao atual (na pos auxiliar)
body.r_ = body.r + body.v.multiply(dt)
# atualiza posicoes das particulas
for body in self.bodies:
body.r = body.r_
# trata as colisoes
#self.colisoes()
t += dt
# atualiza animacao
self.atualiza_anim(t)
def __init__(self, ambiente, cor, posicao, velocidade_maxima, aceleracao,
escudo, codigo):
"""
Neste metodo uma nave e criada
:param ambiente: O ambiente pygame do jogo, que e usado para carregar
a imagem
:param cor: A cor da nave (numero de 0 a 5)
:param posicao: A posicao inicial da nave
:param velocidade_maxima: A velocidade maxima que a nave pode atingir
:param aceleracao: A aceleracao que a nave possui
:param escudo: A defesa da nave, que reduz o dano recebido
"""
ObjetoMovel.__init__(self, ambiente, "nave_" + str(cor), posicao,
Vetor(0, 0), 0)
ObjetoCircular.__init__(self, ambiente, "nave_" + str(cor), posicao)
self.imagem_inicial = self.imagem
self.pontos_de_vida = 100
self.velocidade_maxima = velocidade_maxima
self.aceleracao = aceleracao
self.escudo = escudo
self.codigo = codigo
self.cor = cor
self.pode_atirar = True
self.pode_colidir = True
self.angulo = 90
self.lista_tiros = []
def __init__(self, subscriber, publisher_esquerda, publisher_direita):
Robo.__init__(self, subscriber)
self.pubL = rospy.Publisher(publisher_esquerda, Float64, queue_size = 100)
self.pubR = rospy.Publisher(publisher_direita, Float64, queue_size = 100)
self.vel = 0 #velocidade linear (inicializada como zero)
self.omega = 0 #velocidade angular (inicializada como zero)
self.orientacaoDesejada = Vetor(0, 0)
self.posDesejada = Vetor(0, 0)
self.orientacaoPrevista = Vetor(0, 0)
self.posPrevista = Vetor(0, 0)
self.omegaD = 0 # velocidade angular da roda direita
self.omegaE = 0 # velocidade angular da roda esquerda
def __init__(self, lbl, r=(0, 0, 0), v=(0, 0, 0), mass=1, color=None):
'''(Particula, str, 3-tuple, 3-tuple, float) -> None
O padrão é uma "partícula" na posição origem
'''
self.label = lbl
# vetor posição
self.r = Vetor(r)
# vetor velocidade
self.v = Vetor(v)
# massa
self.m = mass
# vetor momentum
self.p = self.v.multiply(self.m)
# vetor posição auxiliar
self.r_ = Vetor(r)
# cor
self.cor = color
def test_initialization():
"""
Testa se o vetor seta as variáveis corretamente
"""
v = Vetor(1, 2)
assert v.x == 1
assert v.y == 2
def mass_center(self):
'''(Nbody) -> 3-tuple, float
Retorna a posicao do centro de massa e massa total
'''
s, m = Vetor(), 0
for body in self.bodies:
s += body.r.multiply(body.m)
m += body.m
c = s.multiply(1 / m)
return c.to_list()
def desenhar(self, tela):
"""
Este metodo desenha o objeto na tela
:param tela: A tela onde o objeto sera desenhado
"""
posicao_desenho = self.posicao - Vetor(self._raio, self._raio)
tela.blit(self.imagem, posicao_desenho.get_tupla())
def __init__(self,
ambiente,
imagem,
posicao=Vetor(0, 0),
direcao=Vetor(0, 0),
velocidade=0,
dano=20):
"""
Neste metodo um obstaculo e criado
:param ambiente: O ambiente pygame do jogo, que e usado para carregar
a imagem
:param imagem: O caminho da imagem do obstaculo
:param posicao: A posicao inicial do obstaculo
:param direcao: A direcao inicial do obstaculo
:param velocidade: A velocidade inicial do obstaculo
"""
ObjetoMovel.__init__(self, ambiente, imagem, posicao, direcao,
velocidade)
ObjetoCircular.__init__(self, ambiente, imagem, posicao)
def __init__(self,
ambiente,
imagem,
posicao=Vetor(0, 0),
direcao=Vetor(0, 0),
velocidade=0):
"""
Neste metodo um objeto movel e criado
:param ambiente: O ambiente pygame do jogo, que e usado para carregar
a imagem
:param imagem: O caminho da imagem do objeto
:param posicao: A posicao inicial do objeto
:param direcao: A direcao inicial do objeto
:param velocidade: A velocidade inicial do objeto
"""
Objeto.__init__(self, ambiente, imagem, posicao)
self.direcao = direcao
self.velocidade = velocidade
def desenhar(self, ambiente, tela):
"""
Este metodo desenha a nave na tela, com a sua posicao e rotacao
:param ambiente: O ambiente Pygame em que a nave esta
:param tela: A tela no qual a nave sera desenhada
"""
self.imagem = ambiente.transform.rotate(self.imagem_inicial,
self.angulo)
largura, altura = self.imagem.get_size()
posicao_de_desenho = self.posicao - Vetor(largura / 2, altura / 2)
tela.blit(self.imagem, posicao_de_desenho.get_tupla())
def __init__(self, ambiente, imagem, posicao=Vetor(0, 0)):
"""
Neste metodo um objeto e criado
:param ambiente: O ambiente pygame do jogo, que e usado para carregar
a imagem
:param imagem: O caminho da imagem do objeto
:param posicao: A posicao inicial do objeto
"""
self.imagem = ambiente.image.load("Imagens/" + imagem + ".png")
self.posicao = posicao
def movimentar(self, jogo):
"""
Este metodo faz a nave se movimentar, impede que ela se movimente alem
de sua velocidade maxima e impede que ela saia da tela
:param jogo: O jogo no qual a nave esta
"""
nova_posicao = (self.posicao +
(self.direcao * self.velocidade)).get_tupla()
tamanho = jogo.tela.get_size()
if self.velocidade >= self.velocidade_maxima:
self.velocidade = self.velocidade_maxima
if (nova_posicao[0] - self._raio > 0
and nova_posicao[0] + self._raio < tamanho[0]
and nova_posicao[1] - self._raio > 0
and nova_posicao[1] + self._raio < tamanho[1]):
self.posicao = Vetor(nova_posicao[0], nova_posicao[1])
def tratar_eventos(self, jogo):
"""
Este metodo trata os eventos de pressionamento de teclas
:param jogo: O jogo no qual a nave esta
"""
teclas = jogo.ambiente.key.get_pressed()
if self.codigo == 0:
# FAZ A NAVE ATIRAR
if teclas[jogo.ambiente.K_LSHIFT] and self.pode_atirar:
direcao = Vetor(math.cos(self.angulo * math.pi / 180),
-math.sin(self.angulo * math.pi / 180))
tiro = Obstaculo(jogo.ambiente, "tiro_" + str(self.cor),
self.posicao + (direcao * self._raio),
direcao, 5, 5)
self.lista_tiros.append(tiro)
self.pode_atirar = False
jogo.ambiente.time.set_timer(jogo.ambiente.USEREVENT + 1, 300)
# ACELERA A NAVE
if teclas[jogo.ambiente.K_w]:
movimento_x = self.aceleracao * math.cos(
self.angulo * math.pi / 180)
movimento_y = (-self.aceleracao) * math.sin(
self.angulo * math.pi / 180)
self.adicionar_movimento(Vetor(movimento_x, movimento_y))
# FREIA A NAVE
elif teclas[jogo.ambiente.K_s]:
movimento_x = (-self.aceleracao / 2) * math.cos(
self.angulo * math.pi / 180)
movimento_y = self.aceleracao / 2 * math.sin(
self.angulo * math.pi / 180)
self.adicionar_movimento(Vetor(movimento_x, movimento_y))
# GIRA A NAVE NO SENTIDO ANTI-HORARIO
if teclas[jogo.ambiente.K_a]:
self.angulo += 2
if self.angulo >= 360:
self.angulo = 0
# GIRA A NAVE NO SENTIDO HORARIO
elif teclas[jogo.ambiente.K_d]:
self.angulo -= 2
if self.angulo >= 360:
self.angulo = 0
elif self.codigo == 1:
# FAZ A NAVE ATIRAR
if teclas[jogo.ambiente.K_RSHIFT] and self.pode_atirar:
direcao = Vetor(math.cos(self.angulo * math.pi / 180),
-math.sin(self.angulo * math.pi / 180))
tiro = Obstaculo(jogo.ambiente, "tiro_" + str(self.cor),
self.posicao + (direcao * self._raio),
direcao, 5, 5)
self.lista_tiros.append(tiro)
self.pode_atirar = False
jogo.ambiente.time.set_timer(jogo.ambiente.USEREVENT + 2, 300)
# ACELERA A NAVE
if teclas[jogo.ambiente.K_UP]:
movimento_x = self.aceleracao * math.cos(
self.angulo * math.pi / 180)
movimento_y = (-self.aceleracao) * math.sin(
self.angulo * math.pi / 180)
self.adicionar_movimento(Vetor(movimento_x, movimento_y))
# FREIA A NAVE
elif teclas[jogo.ambiente.K_DOWN]:
movimento_x = (-self.aceleracao / 4) * math.cos(
self.angulo * math.pi / 180)
movimento_y = (self.aceleracao / 4) * math.sin(
self.angulo * math.pi / 180)
self.adicionar_movimento(Vetor(movimento_x, movimento_y))
# GIRA A NAVE NO SENTIDO ANTI-HORARIO
if teclas[jogo.ambiente.K_LEFT]:
self.angulo += 2
if self.angulo >= 360:
self.angulo = 0
# GIRA A NAVE NO SENTIDO HORARIO
elif teclas[jogo.ambiente.K_RIGHT]:
self.angulo -= 2
if self.angulo >= 360:
self.angulo = 0
def centro(self):
x = (self.infD.x + self.supE.x)/2.
y = (self.infD.y + self.supE.y)/2.
return Vetor(x, y)
def coordenadas(self, supEx, supEy, infDx, infDy):
supE = Vetor(supEx, supEy)
infD = Vetor(infDx, infDy)
return Regiao(supE, infD)
def __init__(self, topic):
self.pos = Vetor(0, 0)
rospy.Subscriber(topic, Pose, self.recebe_dados)
def testa_soma(self):
v1 = Vetor(5, 1)
v2 = Vetor(0, 3)
v = soma_vetor(v1, v2)
self.assertEqual(v, Vetor(5, 4))
def selecao(self):
"""
Este metodo controla a selecao de jogadores e naves
"""
for i in range(2):
system("clear")
print("SELEÇÃO")
print("1 - Criar")
print("2 - Já tenho")
opcao = input(": ")
if opcao == "1":
print("\nJOGADOR")
while True:
nome = input("Nome: ").upper()
if not self.buscar_nome(nome):
break
else:
print("Este jogador já existe.\n")
print("\nNAVE")
print(
"Você tem 10 pontos para distribuir (entre velocidade máxima, aceleração e escudo)."
)
while True:
try:
velocidade_maxima = int(
input("Velocidade máxima (1-5): "))
aceleracao = int(input("Aceleração (1-5): "))
escudo = int(input("Escudo (0-5): "))
except:
print("Valor inválido!\n")
continue
if velocidade_maxima + aceleracao + escudo <= 10:
break
else:
print("Você gastou mais de 10 pontos.\n")
while True:
print("Cor:")
print("1 - vermelho")
print("2 - amarelo")
print("3 - verde")
print("4 - azul turquesa")
print("5 - azul")
print("6 - roxo")
try:
cor = int(input(": "))
except:
print("Valor inválido!\n")
continue
if cor > 0 and cor < 7:
break
else:
print("Cor inexistente.")
if i == 0:
nave = Nave(jogo.ambiente, cor, Vetor(200, 300),
velocidade_maxima, aceleracao * 0.5, escudo, 0)
else:
nave = Nave(jogo.ambiente, cor, Vetor(1000, 300),
velocidade_maxima, aceleracao * 0.5, escudo, 1)
self.lista_naves.append(nave)
self.salvar_configuracao(nome, cor, velocidade_maxima,
aceleracao * 0.5, escudo)
elif opcao == "2":
nome = input("Nome: ").upper()
configuracao = self.ler_configuracao(nome)
if i == 0:
nave = Nave(jogo.ambiente, configuracao[0],
Vetor(200, 300), configuracao[1],
configuracao[2], configuracao[3], 0)
else:
nave = Nave(jogo.ambiente, configuracao[0],
Vetor(1000, 300), configuracao[1],
configuracao[2], configuracao[3], 1)
self.lista_naves.append(nave)
else:
print("Opção inválida")
sys.exit()
self.desenhar()
self.atualizar_tela()
clock.tick(60)
if __name__ == "__main__":
jogo = Jogo()
"""
nave1 = Nave(jogo.ambiente, 1, Vetor(200, 300), 6, 0.1, 1, 0)
nave2 = Nave(jogo.ambiente, 2, Vetor(1000, 300), 3, 0.3, 1, 1)
jogo.adicionar_nave(nave1)
jogo.adicionar_nave(nave2)
"""
jogo.selecao()
asteroide1 = Obstaculo(jogo.ambiente, "asteroide_0", Vetor(600, 200),
Vetor(1, 0.35), 2)
asteroide2 = Obstaculo(jogo.ambiente, "asteroide_0", Vetor(600, 400),
Vetor(-1, -0.35), 2)
asteroide3 = Obstaculo(jogo.ambiente, "asteroide_0", Vetor(600, 300),
Vetor(0.0, 0.1), 0.2)
jogo.adicionar_objeto(asteroide1)
jogo.adicionar_objeto(asteroide2)
jogo.adicionar_objeto(asteroide3)
jogo.criar_tela("Sagu", (1280, 720), "fundo")
jogo.run()
def testa_subtrai(self):
v1 = Vetor(5, 1)
v2 = Vetor(2, 3)
v = subtrai_vetor(v1, v2)
self.assertEqual(v, Vetor(3, -2))
def testa_vetor(self):
v = Vetor(x=1, y=-1)
self.assertEqual(v.x, 1)
self.assertEqual(v.y, -1)