code. compile. run. debug. share.
from utils import limpar_tela, Cores
from jogo import BattleOfOlympo
from deuses import TODOS_OS_DEUSES
def mostrar_regras():
"""Exibe as regras detalhadas com visual aprimorado e desenhos dos dados."""
limpar_tela()
print(f"{Cores.NEGRITO}=== 📜 REGRAS DO BATTLE OF OLYMPO ==={Cores.RESET}\n")
# Seção 1: Objetivo
print(f"{Cores.AMARELO}1. OBJETIVO 🏆{Cores.RESET}")
print(" Empurrar o marcador da Arena para o lado do oponente.")
print(" Se o marcador passar da casa 4, você vence a partida.\n")
# Seção 2: Dados
print(f"{Cores.AMARELO}2. OS DADOS 🎲{Cores.RESET}")
print(" • No 1º turno de ambos os jogadores: Lança-se 3 dados.")
print(" • Nos demais Turnos: Lança-se 5 dados.")
print(" • Você pode rerrolar até 2 vezes, mas deve manter pelo menos 1 dos dados rolado.")
print(f" • {Cores.VERMELHO}Dados com valor 1 (⚀) são 'Azarentos': ficam TRAVADOS e não podem ser rerrolados{Cores.RESET}\n")
# Seção 3: Combos (Com desenho ASCII dos dados)
print(f"{Cores.AMARELO}3. COMBINAÇÕES (O que os dados fazem){Cores.RESET}")
print(f" • {Cores.CIANO}Par de 2 (⚁⚁) {Cores.RESET} ➔ GANHA 1 ITEM ALEATORIO (Máx 3)")
print(f" • {Cores.CIANO}Par de 3/4 (⚂⚂ ou ⚃⚃) {Cores.RESET} ➔ ATAQUE (Reduz a defesa do inimigo)")
print(f" • {Cores.CIANO}Par de 5/6 (⚄⚄ ou ⚅⚅) {Cores.RESET} ➔ EMPURRAO (Move a arena contra o oponente)")
print(f" • {Cores.CIANO}Trio de 6 (⚅⚅⚅) {Cores.RESET} ➔ ESPECIAL (Ativa o golpe unico do seu deus escolhido)\n")
# Seção 4: Mecânica de Defesa (Estabilidade)
print(f"{Cores.AMARELO}4. ESTABILIDADE = DEFESA{Cores.RESET}")
print(" Aqui sua % representa seu DEFESA.")
print(" Quanto mais próximo de 100%, mais 'pesado' difícil sera de empurrar voce.")
print(" Se sua defesa cai, você fica 'leve' e voa longe com qualquer empurrao!")
print("\n TABELA DE VULNERABILIDADE:")
print(f" • {Cores.VERDE}100% a 51%:{Cores.RESET} PESADO (O inimigo te empurra apenas 1 casa)")
print(f" • {Cores.AMARELO}50% a 1%:{Cores.RESET} LEVE (O inimigo te empurra 2 casas)")
print(f" • {Cores.VERMELHO}0%:{Cores.RESET} PENA (PERIGO! O inimigo te empurra 3 casas)\n")
input(f"{Cores.VERDE}[Pressione Enter para voltar ao Menu...]{Cores.RESET}")
def mostrar_itens():
limpar_tela()
print(f"{Cores.NEGRITO}=== 🎒 ENCICLOPÉDIA DE ITENS ==={Cores.RESET}\n")
print(f"{Cores.MAGENTA}1. NÉCTAR 🍯{Cores.RESET} Recupera 25% de Defesa.")
print(f"{Cores.MAGENTA}2. AMBROSIA 🍰{Cores.RESET} +1 Força de Empurrão.")
print(f"{Cores.MAGENTA}3. ESCUDO 🛡️{Cores.RESET} Bloqueia o próximo dano.")
print(f"{Cores.AMARELO}4. LANÇA ⚔️{Cores.RESET} +25% Dano no próximo ataque.")
print(f"{Cores.AMARELO}5. MEDUSA 🐍{Cores.RESET} Destrói um item do inimigo.")
print(f"{Cores.CIANO}--- NOVOS ITENS DE DADOS ---{Cores.RESET}")
print(f"{Cores.VERDE}6. BÊNÇÃO DE HERMES 👟{Cores.RESET}")
print(" Você joga com +1 DADO neste turno. Mais chances de combo!")
print(f"{Cores.VERMELHO}7. CAIXA DE PANDORA 📦{Cores.RESET}")
print(" Azaração! O oponente jogará com –1 DADO no turno dele.")
print(f"\n{Cores.AMARELO}8. VELOCINO DOURADO ✨{Cores.RESET} Cura parcial(50%). Muito raro.")
input(f"\n{Cores.VERDE}[Enter]{Cores.RESET}")
def mostrar_info_deuses():
"""Mostra os deuses disponíveis na lista oficial."""
limpar_tela()
print(f"{Cores.NEGRITO}=== 🏛️ PANTHEON DOS DEUSES ==={Cores.RESET}\n")
for classe_deus in TODOS_OS_DEUSES:
d = classe_deus()
print(f"{Cores.AMARELO}{d.icone} {d.nome}:{Cores.RESET} {d.descricao}")
print(f"{Cores.CIANO}{'-'*50}{Cores.RESET}")
input(f"\n{Cores.VERDE}[Pressione Enter para voltar]{Cores.RESET}")
def menu_principal():
"""Loop principal do menu."""
while True:
limpar_tela()
print(f"{Cores.CIANO}=======================================")
print(f" ⚡ BATTLE OF OLYMPO ⚡")
print(f"======================================={Cores.RESET}")
print("1. ⚔️ JOGAR (PvP)")
print("2. 🏆 TORNEIO (PvE)")
print("3. 📜 REGRAS (Leia antes de jogar!)")
print("4. 🎒 ENCICLOPEDIA DOS ITENS")
print("5. ️ 🏛 CONHECER OS DEUSES")
print("6. ❌ SAIR")
escolha = input("\nEscolha uma opção: ").strip()
if escolha == "1":
# Chama o modo clássico Jogador vs Jogador
BattleOfOlympo(modo="PvP").pvp_inicial()
elif escolha == "2":
# Chama o novo modo de progressão contra a IA
BattleOfOlympo(modo="Torneio").iniciar_torneio()
input(f"\n{Cores.VERDE}[Pressione Enter para voltar]{Cores.RESET}")
elif escolha == "3":
mostrar_regras()
elif escolha == "4":
mostrar_itens()
elif escolha == "5":
mostrar_info_deuses()
elif escolha == "6":
print("Saindo do Olimpo... Que os deuses te acompanhem!")
break
else:
print("Opção inválida! Tente novamente.")
if __name__ == "__main__":
menu_principal()
import os
class Cores:
VERMELHO = '\033[91m'
VERDE = '\033[92m'
AMARELO = '\033[93m'
AZUL = '\033[94m'
MAGENTA = '\033[95m'
CIANO = '\033[96m'
RESET = '\033[0m'
NEGRITO = '\033[1m'
def limpar_tela():
if os.name == 'nt':
os.system('cls')
else:
os.system('clear')
def desenhar_dado(valor):
"""Retorna uma representação visual simples do dado."""
icones = {1: "⚀", 2: "⚁", 3: "⚂", 4: "⚃", 5: "⚄", 6: "⚅"}
return f"[{icones.get(valor, '?')} {valor}]"
from utils import Cores
class DeusBase:
def __init__(self, nome, icone, descricao):
self.nome = nome
self.icone = icone
self.descricao = descricao
def ativar_especial(self, usuario, oponente):
print(f"{Cores.AMARELO}>>> {self.icone} ESPECIAL DE {self.nome}!{Cores.RESET}")
return 0
class Zeus(DeusBase):
def __init__(self):
super().__init__("Zeus", "⚡", "Relampago: Dano alto (40%).")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Raio cai dos ceus! -40% estabilidade no inimigo.")
oponente.receber_dano(40)
return 0
class Kratos(DeusBase):
def __init__(self):
super().__init__("Kratos", "⚔️", "Furia Espartana: Empurra 3 casas.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Fúria espartana empurra o inimigo!")
return 3
class Hades(DeusBase):
def __init__(self):
super().__init__("Hades", "💀", "Submundo: Rouba vida.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Hades drena a vitalidade! -20% nele, +20% em voce.")
oponente.receber_dano(20)
usuario.curar(20)
return 0
class Poseidon(DeusBase):
def __init__(self):
super().__init__("Poseidon", "🌊", "Maremoto: Empurra 2 casas extra.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Onda gigante empurra o inimigo!")
return 2
class Ares(DeusBase):
def __init__(self):
super().__init__("Ares", "🗡", "Guerra: Dano e Ganha 1 item.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Ataque furioso! Dano de 20% + 1 item.")
oponente.receber_dano(20)
usuario.ganhar_item()
return 0
class Hera(DeusBase):
def __init__(self):
super().__init__("Hera", "🦚", "Protecao: Cura muito (50%).")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Hera cura seu campeao em 40%!")
usuario.curar(40)
return 0
class Artemis(DeusBase):
def __init__(self):
super().__init__("Artemis", "🏹", "Cacada: Dano certeiro (20%) e empurra 1.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Flecha certeira! -20% estabilidade.")
oponente.receber_dano(20)
return 1
class Apolo(DeusBase):
def __init__(self):
super().__init__("Apolo", "☀️", "Luz Solar: Cura (20%) e ganha 1 item.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Luz solar cura seu campeao em 20% e lhe concede 1 item.")
usuario.curar(20)
usuario.ganhar_item()
return 0
class Atena(DeusBase):
def __init__(self):
super().__init__("Atena", "🦉", "Sabedoria: Cura (15%) e escolhe item.")
def ativar_especial(self, usuario, oponente):
super().ativar_especial(usuario, oponente)
print("Estratégia Suprema! Atena permite que você escolha o item perfeito e se cure em 15.")
usuario.escolher_item_manual()
usuario.curar(15)
return 0
TODOS_OS_DEUSES = [Zeus, Hades, Poseidon, Ares, Hera, Artemis, Apolo, Atena]
import random
from utils import Cores
class Jogador:
def __init__(self, nome, deus_escolhido):
self.nome = nome
self.deus = deus_escolhido
self.estabilidade = 100
self.inventario = []
self.max_itens = 3
self.dados_atuais = []
# Atributos de Efeito
self.escudo_ativo = False
self.furia_ativa = False
self.ataque_extra = False
self.modificador_dados = 0
@property
def vulnerabilidade(self):
if self.estabilidade > 50: return 1
elif self.estabilidade > 0: return 2
else: return 3
def receber_dano(self, qtd):
if self.escudo_ativo:
print(f"{Cores.AZUL}🛡️ {self.nome} usou o Escudo e anulou o dano!{Cores.RESET}")
self.escudo_ativo = False
return
self.estabilidade = max(0, self.estabilidade - qtd)
print(f"{Cores.VERMELHO}> {self.nome} perdeu defesa! Agora tem {self.estabilidade}%{Cores.RESET}")
def curar(self, qtd):
self.estabilidade = min(100, self.estabilidade + qtd)
print(f"{Cores.VERDE}> {self.nome} recuperou defesa! {self.estabilidade}%{Cores.RESET}")
def ganhar_item(self):
"""Ganha um item aleatório (padrão do par de 2)."""
if len(self.inventario) >= self.max_itens:
print("Inventario cheio! Item perdido.")
return
itens_possiveis = [
"Nectar", "Ambrosia", "Escudo",
"Lanca", "Medusa", "Velocino dourado",
"Bencao de Hermes", "Caixa de Pandora"
]
# Pesos de raridade
pesos = [25, 20, 15, 10, 5, 5, 10, 10]
novo_item = random.choices(itens_possiveis, weights=pesos, k=1)[0]
self.inventario.append(novo_item)
print(f"{Cores.MAGENTA}Sorte dos dados! Voce ganhou: {novo_item}!{Cores.RESET}")
def escolher_item_manual(self):
"""Função especial (usada por Atena no 6-6-6)."""
if len(self.inventario) >= self.max_itens:
print("Inventario cheio! Não pode escolher item agora.")
return
itens_possiveis = [
"Nectar", "Ambrosia", "Escudo",
"Lanca", "Medusa", "Velocino dourado",
"Bencao de Hermes", "Caixa de Pandora"
]
print(f"\n{Cores.CIANO}🦉 SABEDORIA DE ATENA! Escolha seu item:{Cores.RESET}")
for i, item in enumerate(itens_possiveis):
print(f"{i+1}. {item}")
while True:
try:
escolha = int(input("Digite o numero do item: ")) - 1
if 0 <= escolha < len(itens_possiveis):
novo_item = itens_possiveis[escolha]
self.inventario.append(novo_item)
print(f"{Cores.MAGENTA}Atena concedeu: {novo_item}!{Cores.RESET}")
return
else:
print("Opção inválida.")
except ValueError:
print("Digite um número.")
def usar_item(self, oponente):
if not self.inventario:
return
print(f"\n{Cores.AMARELO}--- SEU INVENTARIO ---{Cores.RESET}")
for i, item in enumerate(self.inventario):
print(f"{i+1}. {item}")
print("0. Nao usar nada")
try:
escolha_str = input("Escolha um item: ")
if not escolha_str.isdigit(): return
idx = int(escolha_str) - 1
if idx == -1: return
if 0 <= idx < len(self.inventario):
item = self.inventario.pop(idx)
print(f"Usando {item}...")
if item == "Nectar":
print("Recupera 25% de Defesa.")
self.curar(25)
elif item == "Velocino dourado":
print("Cura Lendaria! Recupera 50% da Defesa.")
self.curar(50)
elif item == "Ambrosia":
print("Forca bruta! Empurrao +1 neste turno.")
self.furia_ativa = True
elif item == "Lanca":
print("Afiar armas! Proximo ataque +25% de dano.")
self.ataque_extra = True
elif item == "Escudo":
print("Protecao ativada para o proximo ataque.")
self.escudo_ativo = True
elif item == "Medusa":
if oponente.inventario:
item_destruido = oponente.inventario.pop()
print(f"Medusa petrificou o item {item_destruido} do inimigo!")
else:
print("Medusa olhou, mas inimigo estava sem itens.")
elif item == "Bencao de Hermes":
print(f"{Cores.VERDE}Velocidade! +1 Dado neste turno.{Cores.RESET}")
self.modificador_dados += 1
elif item == "Caixa de Pandora":
print(f"{Cores.VERMELHO}Maldição! Oponente terá -1 Dado.{Cores.RESET}")
oponente.modificador_dados -= 1
else:
print("Item invalido.")
except ValueError:
pass
def rolar_dados(self, quantidade):
return [random.randint(1, 6) for _ in range(quantidade)]
import time
import random
from utils import Cores, limpar_tela, desenhar_dado
from jogador import Jogador
from deuses import TODOS_OS_DEUSES, Kratos
# --- CLASSE PARA A INTELIGÊNCIA ARTIFICIAL ---
class InimigoIA(Jogador):
"""
IA que simula o comportamento de um jogador humano, tomando decisões
baseadas no estado da partida (defesa e dados).
"""
def __init__(self, nome, deus_escolhido):
super().__init__(nome, deus_escolhido)
def decidir_uso_item(self, oponente):
"""Lógica da IA para analisar o inventário e usar itens com pausas visuais."""
if not self.inventario:
return
print(f"\n{Cores.CIANO} {self.nome} está analisando itens...{Cores.RESET}")
time.sleep(1.5)
for item in self.inventario[:]:
usar = False
# Prioridade para buffs e debuffs imediatos
if item in ["Escudo", "Bencao de Hermes", "Caixa de Pandora", "Medusa", "Lanca"]:
usar = True
# Itens de cura só se a defesa estiver crítica
elif item in ["Nectar", "Velocino dourado"] and self.estabilidade <= 70:
usar = True
# Ambrosia para finalizar ou empurrar oponente vulnerável
elif item == "Ambrosia" and oponente.estabilidade <= 50:
usar = True
if usar:
print(f"{Cores.CIANO}✨ {self.nome} ativou: {Cores.NEGRITO}{item}{Cores.RESET}!")
time.sleep(1.2)
idx = self.inventario.index(item)
self.inventario.pop(idx)
# Execução lógica do efeito do item
if item == "Nectar": self.curar(25)
elif item == "Velocino dourado": self.curar(100)
elif item == "Ambrosia": self.furia_ativa = True
elif item == "Lanca": self.ataque_extra = True
elif item == "Escudo": self.escudo_ativo = True
elif item == "Bencao de Hermes": self.modificador_dados += 1
elif item == "Caixa de Pandora": oponente.modificador_dados -= 1
elif item == "Medusa" and oponente.inventario:
oponente.inventario.pop()
print(f"🐍 {oponente.nome} perdeu um item pela Medusa!")
time.sleep(1.0)
def escolher_item_manual(self):
"""
Sobrescreve a função humana para que a IA escolha o item
automaticamente durante o Especial de Atena sem pedir input.
"""
if len(self.inventario) >= self.max_itens:
return
itens_possiveis = [
"Nectar", "Ambrosia", "Escudo", "Lanca",
"Medusa", "Velocino dourado", "Bencao de Hermes", "Caixa de Pandora"
]
# Lógica de Sabedoria da IA
if self.estabilidade <= 60:
escolha = "Velocino dourado" if self.estabilidade <= 30 else "Nectar"
else:
escolha = random.choice(["Lanca", "Bencao de Hermes", "Caixa de Pandora", "Medusa"])
self.inventario.append(escolha)
print(f"{Cores.CIANO} {self.nome} (Atena) usou sua sabedoria e escolheu: {Cores.NEGRITO}{escolha}{Cores.RESET}")
time.sleep(1.5)
def decidir_manter_dados(self, dados):
"""IA escolhe o que manter e informa ao jogador os índices."""
manter = []
for i, d in enumerate(dados):
if d == 6 or d == 1:
manter.append(i + 1)
# GARANTE QUE A IA SEMPRE MANTENHA ALGO SE NÃO HOUVER 1 OU 6
if not manter:
maior = max(dados)
for i, d in enumerate(dados):
if d == maior:
manter.append(i+1)
break
if dados.count(6) < 2:
for valor in [6, 5]:
if dados.count(valor) >= 2:
for i, d in enumerate(dados):
if d == valor: manter.append(i + 1)
decisao_str = " ".join(map(str, sorted(list(set(manter)))))
return decisao_str
# --- MOTOR PRINCIPAL DO JOGO ---
class BattleOfOlympo:
def __init__(self, modo="PvP"):
self.modo = modo
self.jogadores = []
self.arena_posicao = 0
self.turno_atual = 1
def selecionar_deus(self, nome_jogador):
while True:
print(f"\n{Cores.CIANO}--- Escolha seu deus para {nome_jogador} ---{Cores.RESET}")
for i, classe_deus in enumerate(TODOS_OS_DEUSES):
temp = classe_deus()
print(f"[{i+1}] {temp.icone} {temp.nome}")
entrada = input("Digite o numero (ou segredo): ").strip()
if entrada.upper() in ["KRATOS", "BOY"]:
print(f"\n{Cores.VERMELHO}⚠️ FANTASMA DE ESPARTA INVOCADO! ⚠️{Cores.RESET}")
time.sleep(1)
return Kratos()
if entrada.isdigit():
escolha = int(entrada) - 1
if 0 <= escolha < len(TODOS_OS_DEUSES):
return TODOS_OS_DEUSES[escolha]()
print("Opção inválida!")
def iniciar_torneio(self):
limpar_tela()
print(f"{Cores.CIANO}=== 🏆 MODO TORNEIO: ASCENSÃO NO OLIMPO ==={Cores.RESET}")
nome_player = input("Digite seu nome, Campeão: ") or "Campeão"
deus_player = self.selecionar_deus(nome_player)
p1 = Jogador(nome_player, deus_player)
deuses_inimigos = [d() for d in TODOS_OS_DEUSES if d().nome != deus_player.nome]
random.shuffle(deuses_inimigos)
for i, deus_ia in enumerate(deuses_inimigos):
# Reset de estado para cada nova luta do torneio
self.arena_posicao = 0
self.turno_atual = 1
p1.inventario = []
p1.estabilidade = 100
p1.modificador_dados = 0
p2 = InimigoIA(f" {deus_ia.nome}", deus_ia)
self.jogadores = [p1, p2]
print(f"\n{Cores.AMARELO}RODADA {i+1} de 7{Cores.RESET}")
print(f"{Cores.NEGRITO}SEU OPONENTE: {p2.nome}{Cores.RESET}")
time.sleep(2.5)
venceu = self.jogar()
if not venceu:
print(f"\n{Cores.VERMELHO}Você foi derrotado por {deus_ia.nome}. O torneio acabou.{Cores.RESET}")
return False
print(f"\n{Cores.VERDE}✨ INCRÍVEL! Você derrotou todos e é o novo Semideus ✨{Cores.RESET}")
return True
def desenhar_hud(self):
p1, p2 = self.jogadores[0], self.jogadores[1]
c1 = Cores.VERDE if p1.estabilidade > 50 else Cores.VERMELHO
c2 = Cores.VERDE if p2.estabilidade > 50 else Cores.VERMELHO
print(f"{Cores.CIANO}{'='*60}{Cores.RESET}")
print(f"{p1.deus.icone} {p1.nome:<20} VS {p2.nome:>20} {p2.deus.icone}")
print(f"{c1}DEF: {p1.estabilidade}%{Cores.RESET:<21} {c2}DEF: {p2.estabilidade}%{Cores.RESET:>21}")
print(f"{Cores.CIANO}{'='*60}{Cores.RESET}")
trilha = [" . "] * 9
idx = max(0, min(8, self.arena_posicao + 4))
trilha[idx] = f"{Cores.AMARELO}[⚡]{Cores.RESET}"
print(f"\n (P1) {''.join(trilha)} (P2)")
def fase_rerrolagem(self, jogador, dados):
rerrolagens = 2
while rerrolagens > 0:
if isinstance(jogador, InimigoIA):
print(f"\n {jogador.nome} está pensando...")
time.sleep(1.8)
decisao = jogador.decidir_manter_dados(dados)
print(f"\nDados atuais: {' '.join([desenhar_dado(d) for d in dados])}")
if not decisao:
print(f" {jogador.nome} decidiu travar os dados atuais.")
else:
print(f" {jogador.nome} decidiu manter os IDs: {decisao}")
time.sleep(1.2)
else:
print(f"\nDados atuais: {' '.join([desenhar_dado(d) for d in dados])}")
if any(d==1 for d in dados): print(f"{Cores.VERMELHO}Dados 1 travados!{Cores.RESET}")
decisao = input(f"[Rerrolagens: {rerrolagens}] Manter IDs (ex: 1 3) ou ENTER: ")
# SE APENAS DER ENTER, ENTENDE QUE QUER MANTER TUDO
if decisao.strip() == "":
break
try:
manteve = [int(x)-1 for x in decisao.split()]
# VERIFICA SE O HUMANO TENTOU ESCOLHER O DADO 1
if not isinstance(jogador, InimigoIA):
tentou_1 = False
for idx in manteve:
if dados[idx] == 1:
tentou_1 = True
break
if tentou_1:
print(f"{Cores.VERMELHO}Dados de valor 1 nao podem ser escolhidos para serem travados, escolha algum outro dado.{Cores.RESET}")
continue
dados = [dados[i] if (i in manteve or dados[i] == 1) else random.randint(1, 6) for i in range(len(dados))]
rerrolagens -= 1
except: pass
return dados
def resolver_turno(self, atacante, defensor):
"""Processa ações com a regra de pares de faces iguais e Ambrosia funcional."""
dados = atacante.dados_atuais
c = {i: dados.count(i) for i in range(1, 7)}
extra = 0
print(f"\nDados finais: {' '.join([desenhar_dado(d) for d in dados])}")
print(f"\n{Cores.NEGRITO}--- RESOLUÇÃO DE AÇÕES ---{Cores.RESET}")
time.sleep(1)
# 1. Especial (Trio de 6 consome os dados)
if c[6] >= 3:
extra = atacante.deus.ativar_especial(atacante, defensor)
c[6] -= 3
time.sleep(1)
# 2. Itens (Par de 2)
if c[2] >= 2:
for _ in range(c[2] // 2):
atacante.ganhar_item()
# 3. Ataque (Apenas pares de faces iguais: 3-3 ou 4-4)
atks = (c[3] // 2) + (c[4] // 2)
if atks > 0:
dano = (atks * 25) + (25 if atacante.ataque_extra else 0)
defensor.receber_dano(dano)
time.sleep(0.8)
# 4. Empurrão (Apenas pares iguais: 5-5 ou 6-6 + Bônus Ambrosia)
emps = (c[5] // 2) + (c[6] // 2)
mov = 0
if emps > 0 or extra > 0:
forca = defensor.vulnerabilidade + (1 if atacante.furia_ativa else 0)
mov = (emps * forca) + extra
print(f"💨 Força do empurrão: {mov} casas.")
# Limpeza
atacante.furia_ativa = False
atacante.ataque_extra = False
atacante.modificador_dados = 0
return mov
def jogar(self):
while True:
idx = (self.turno_atual + 1) % 2
atacante, defensor = self.jogadores[idx], self.jogadores[1 - idx]
direcao = 1 if idx == 0 else -1
limpar_tela(); self.desenhar_hud()
print(f"\n🎲 TURNO {self.turno_atual}: {atacante.nome}")
if isinstance(atacante, InimigoIA):
atacante.decidir_uso_item(defensor)
else:
atacante.usar_item(defensor)
qtd = max(1, (3 if self.turno_atual <= 2 else 5) + atacante.modificador_dados)
atacante.dados_atuais = self.fase_rerrolagem(atacante, atacante.rolar_dados(qtd))
mov = self.resolver_turno(atacante, defensor)
self.arena_posicao += (mov * direcao)
if abs(self.arena_posicao) > 4:
limpar_tela(); self.desenhar_hud()
venc = self.jogadores[0].nome if self.arena_posicao > 4 else self.jogadores[1].nome
print(f"\n{Cores.VERDE}🏆 {venc} VENCEU ESTA PARTIDA!{Cores.RESET}")
time.sleep(2)
input(f"\n{Cores.VERDE}[Pressione Enter para seguir]{Cores.RESET}")
return self.arena_posicao > 4
if not isinstance(atacante, InimigoIA):
input(f"\n{Cores.VERDE}[Pressione Enter para seguir]{Cores.RESET}")
self.turno_atual += 1
def pvp_inicial(self):
limpar_tela()
n1 = input("Nome do Jogador 1 (Esquerda): ")
d1 = self.selecionar_deus(n1)
limpar_tela()
n2 = input("Nome do Jogador 2 (Direita): ")
d2 = self.selecionar_deus(n2)
self.jogadores = [Jogador(n1, d1), Jogador(n2, d2)]
self.jogar()
Compiling Program...
Standard Input:
Interactive Console
Text
Program is not being debugged. Click "Debug" button to start program in debug mode.
| # | Function | File:Line |
|---|
| Variable | Value |
|---|
| Register | Value |
|---|
| Expression | Value |
|---|
| # | Description |
|---|