def test_critico(self):
"""Verifica se o cálculo de golpes críticos está funcionando OK."""
res = (2 * self.poke1.lvl + 5)/(self.poke1.lvl + 5)
chance = self.poke1.spd/512
maior_chance = chance + 0.001
valores_menores = []
valores_maiores = []
# Novamente usamos valores conhecidos para testar a unidade do
# batalha.critico que usa números pseudo-aleatórios. Os primeiros
# 100 valores serão menores que a chance e os outros 100, maiores.
for i in range(100):
valores_menores.append(random.uniform(0.0, chance))
valores_maiores.append(random.uniform(maior_chance, 1.0))
valores = valores_menores + valores_maiores
a = RandomPoke()
ataque = Ataque(a.gera_ataque())
with patch("batalha.random.uniform", side_effect=valores):
# Em cada loop, a iteração chamará dano.critico duas
# vezes, usando, então, dois valores do side_effect.
for i in range(50):
self.assertEqual(ataque.critico(self.poke1, 0), 1)
self.assertEqual(ataque.critico(self.poke1,
random.randint(1, 100)), res)
for i in range(50):
self.assertEqual(ataque.critico(self.poke1, 0), 1)
self.assertEqual(ataque.critico(self.poke1,
random.randint(1, 100)), 1)
"""
def test_efetividade(self):
"""Verifica se o cálculo de efetividade é feito corretamente."""
# Novamente geramos um novo Pokémon para podermos realizar vários
# testes com resultados diferentes.
for i in range(100):
a = RandomPoke()
poke1 = Pokemon(a.gera())
ataque = Ataque(a.gera_ataque())
# Esta é a fórmula para calcular efetividade
mult = ataque.typ.get_eff_contra(poke1.tipo1)
if poke1.tipo2.nome != "Blank":
mult *= ataque.typ.get_eff_contra(poke1.tipo2)
self.assertEquals(mult, ataque.efetividade(poke1, False))
def test_efetividade(self):
"""Verifica se o cálculo de efetividade é feito corretamente."""
# Novamente geramos um novo Pokémon para podermos realizar vários
# testes com resultados diferentes.
for i in range(100):
a = RandomPoke()
poke1 = Pokemon(a.gera())
ataque = Ataque(a.gera_ataque())
# Esta é a fórmula para calcular efetividade
mult = ataque.typ.get_eff_contra(poke1.tipo1)
if poke1.tipo2.nome != "Blank":
mult *= ataque.typ.get_eff_contra(poke1.tipo2)
self.assertEquals(mult, ataque.efetividade(poke1, False))
def test_verificar_matriz_de_daño(self):
elementos = [
Elemento.AGUA, Elemento.FUEGO, Elemento.TIERRA, Elemento.AIRE
]
daños_esperados = [[10, 12, 8, 10], [8, 10, 12, 10], [10, 10, 10, 10],
[12, 8, 10, 10]]
daños_calculados = []
for elemento_ataque in range(0, 4):
mi_ataque = Ataque(elementos[elemento_ataque])
mi_ataque_daños = []
for elemento_defensa in range(0, 4):
mi_ataque_daños.append(
mi_ataque.calcular_danio([elementos[elemento_defensa]]))
daños_calculados.append(mi_ataque_daños)
self.assertEqual(daños_esperados, daños_calculados,
'algun calculo de daño esta fallando')
def __init__(self, dados, cpu=False):
"""Recebe uma lista contendo dados e cria um Pokémon."""
aux = dados[9:] # Dados dos ataques
dados = dados[:9] # Dados do Pokémon
dados.reverse() # Revertido para facilitar pop()
# Atributos iniciais
self._nome = dados.pop()
self._lvl = int(dados.pop())
self._hp = self._hp_max = int(dados.pop())
self._atk = int(dados.pop())
self._dfs = int(dados.pop())
self._spd = int(dados.pop())
self._spc = int(dados.pop())
# Tipos do Pokémon
t = int(dados.pop()), int(dados.pop())
for i in range(2):
if t[i] not in range(get_num_tipos() + 1):
print("ERRO: Valor inválido (" + str(t) +
") para tipo de Pokémon.")
exit(1)
self._tipo1 = get_tipo(t[0])
self._tipo2 = get_tipo(t[1])
# Ataques
self._ataques = []
while aux:
ataque = Ataque(aux[:5])
self.ataques.append(ataque)
aux = aux[5:]
self._cpu = cpu
print("'" + self.nome + "' lido com sucesso!")
def setUp(self):
"""Inicializa os dois Pokémons aleatórios para os testes."""
sys.stdout = open(os.devnull, "w") # Suprime o output de batalha.py
sys.stderr = sys.stdout
self.a = RandomPoke()
self.b = RandomPoke()
self.poke1 = Pokemon(self.a.gera())
self.poke2 = Pokemon(self.b.gera())
self.struggle = Ataque(["Struggle", 0, 100, 50, 10])
def test_critico(self):
"""Verifica se o cálculo de golpes críticos está funcionando OK."""
res = (2 * self.poke1.lvl + 5)/(self.poke1.lvl + 5)
chance = self.poke1.spd/512
maior_chance = chance + 0.001
valores_menores = []
valores_maiores = []
# Novamente usamos valores conhecidos para testar a unidade do
# batalha.critico que usa números pseudo-aleatórios. Os primeiros
# 100 valores serão menores que a chance e os outros 100, maiores.
for i in range(100):
valores_menores.append(random.uniform(0.0, chance))
valores_maiores.append(random.uniform(maior_chance, 1.0))
valores = valores_menores + valores_maiores
a = RandomPoke()
ataque = Ataque(a.gera_ataque())
with patch("batalha.random.uniform", side_effect=valores):
# Em cada loop, a iteração chamará dano.critico duas
# vezes, usando, então, dois valores do side_effect.
for i in range(50):
self.assertEqual(ataque.critico(self.poke1, 0), 1)
self.assertEqual(ataque.critico(self.poke1,
random.randint(1, 100)), res)
for i in range(50):
self.assertEqual(ataque.critico(self.poke1, 0), 1)
self.assertEqual(ataque.critico(self.poke1,
random.randint(1, 100)), 1)
"""
def test_realiza_ataque_e_calcula_dano(self):
"""Verifica se ataque e suas consequências ocorrem sem problemas."""
batalha.input = Mock(return_value="ok")
# Geramos novos Pokémons para podermos realizar vários
# testes sem acabar com todo o HP deles.
for i in range(100):
a = RandomPoke()
b = RandomPoke()
poke3 = poke1 = Pokemon(a.gera())
poke4 = poke2 = Pokemon(b.gera())
# Assumindo que o ataque sempre vai acertar
with patch('batalha.random.uniform', return_value=1.0):
# Aqui começa o cálculo do dano
lvl = poke1.lvl
ataque = Ataque(a.gera_ataque())
if ataque.typ.especial:
atk = poke1.spc
dfs = poke2.spc
else:
atk = poke1.atk
dfs = poke2.dfs
pp = ataque.pp
hp = poke2.hp
base = ataque.pwr
eff = efetividade(ataque, poke2, False)
dano = (2 * lvl + 10) / 250 * atk / dfs * base + 2
dano *= (stab(ataque, poke1) * critico(poke1, eff) * eff *
aleatorio())
dano = int(dano)
#Testa o dano.calcula_dano
self.assertEqual(dano, calcula_dano(ataque, poke1, poke2))
if (dano > 0):
poke1.remove_hp(dano)
if ataque == self.struggle:
dano //= 2
poke2.remove(hp.dano)
# Verficamos se o Pokemon.realiza_ataque está
# aplicando corretamente o dano conforme a fórmula.
pokemon.input = Mock(return_value="\n")
poke3.realiza_ataque(ataque, poke4)
self.assertEquals(pp - 1, ataque.pp)
self.assertEquals(poke1.hp, poke3.hp)
self.assertEquals(poke2.hp, poke4.hp)
def gera_poke(self):
"""Gera pokemons tais que os ataques estão ordenados em ordem
crescente de pwr e acu."""
t = RandomPoke()
dados = t.gera()
dados = dados[:9] #Tiramos a lista de ataques aleatórios
ataque = []
rand_num = randint(1, 97)
for i in range(4): #Criamos ataques ordenados
ataque.append(
self.gera_ataque(i + rand_num, i + rand_num, randint(1, 255)))
ataques = [Ataque(ataque[i]) for i in range(4)]
dados.append(ataques)
poke = Pokemon(dados) #Agora nosso pokemón contém os ataques ordenados
return poke
def __init__(self):
"""Inicializa os dados para teste."""
le_tipos("tipos.txt")
self._nome = ''.join(
choice(ascii_lowercase + ascii_uppercase)
for x in range(randint(2, 20)))
self._lvl = randint(0, 100)
self._hp = randint(10, 255)
self._atk = randint(1, 255)
self._dfs = randint(1, 255)
self._spd = randint(0, 255)
self._spc = randint(1, 255)
self._tipo1 = randint(0, 15)
while True:
self._tipo2 = randint(0, 16)
if (self._tipo2 != self._tipo1):
break
# Esta lista conterá os atributos do pokemon no formato linear, o que
# é normalmente passado pela entrada padrão. Será útil para o
# teste_multiplayer
self.dados_linear = [
self._nome, self._lvl, self._hp, self._atk, self._dfs, self._spd,
self._spc, self._tipo1, self._tipo2
]
self._ataques = []
num_ataques = randint(1, 4)
self.dados_linear.append(num_ataques)
for i in range(num_ataques):
gera_ataque = self.gera_ataque()
self._ataques.append(gera_ataque)
for att in gera_ataque:
self.dados_linear.append(att)
self.dados = [
self._nome, self._lvl, self._hp, self._atk, self._dfs, self._spd,
self._spc, self._tipo1, self._tipo2,
[Ataque(self._ataques[i]) for i in range(num_ataques)]
]
def test_se_puede_crear_un_ataque_de_cada_elemento(self):
a = Ataque(Elemento.FUEGO)
b = Ataque(Elemento.AGUA)
c = Ataque(Elemento.TIERRA)
d = Ataque(Elemento.AIRE)
def test_verificando_recibir_ataque_basico_disminuido(self):
#El monstruo es tipo fuego y agua, por ende al recibir agua deberia recibir ataque de 10-20% = 8
ataque_impactado = Ataque(Elemento.TIERRA)
self.monster.recibir_ataque(ataque_impactado)
self.assertEqual(self.monster.__estado_vital__, 100 - 8)
def test_verificando_recibir_ataque_basico_aumentado(self):
#El monstruo es tipo fuego y agua, por ende al recibir agua deberia recibir ataque de 10+20% = 12
ataque_impactado = Ataque(Elemento.AGUA)
self.monster.recibir_ataque(ataque_impactado)
self.assertEqual(self.monster.__estado_vital__, 100 - 12)
def test_verificando_recibir_ataque_basico_disminuye_vida(self):
ataque_impactado = Ataque(Elemento.AGUA)
self.monster.recibir_ataque(ataque_impactado)
self.assertLess(self.monster.__estado_vital__, 100)
import pygame
from player import Player
from inimigo import Inimigo
from ataque import Ataque
pygame.init()
janela_principal = pygame.display.set_mode((1600, 1200))
pygame.display.set_caption("Jogo do Pipi atirador")
jogador = Player()
inimigo = Inimigo()
disparo = Ataque(jogador)
angle = 0
janela_aberta = True
while janela_aberta:
pygame.time.delay(10)
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
janela_aberta = False
comando = pygame.key.get_pressed()
if comando[pygame.K_UP]:
angle = 180
jogador.cima()
if comando[pygame.K_DOWN]:
angle = 0
if alive(a) == True:
try:
attack(IP())
except:
continue
elif numero == 2:
ip = str(input("Insert the IP: "))
loadAtaque()
Ataque(1, ip, 0, "None")
elif numero == 3:
ip = str(input("Insert the IP: "))
loadAtaque()
Ataque(2, ip, 0, "None")
elif numero == 4:
ip = str(input("Insert the IP: "))
puerto = str(input("Select the port: "))
loadAtaque()
Ataque(3, ip, puerto, "-S")