def campeonatoTeste():
jogador1 = Jogador()
jogador2 = Jogador()
contEmpate = 0
cont1 = 0
cont2 = 0
for i in range(0, 100):
ambiente = AmbienteTicTacToe(3)
partida = Partida(ambiente)
result = partida.partidaJogoDaVelha(jogador1.executaJogadorAleatorio,
jogador2.executaJogadorMiniMax)
if result == 0:
contEmpate += 1
elif result == 1:
cont1 += 1
else:
cont2 += 1
print('\nVIT PLAYER 1: ' + str(cont1))
print('VIT PLAYER 2: ' + str(cont2))
print('EMPATE: ' + str(contEmpate))
def __init__(self, name):
'''
Construtor
@param nome: Nome do jogador.
'''
name = 'CPU:AlfaBeta: %s' % name
Jogador.__init__(self, name)
def Jogo():
jogo = Telas()
#Coloquei pra receber a janela quando inicia o objeto, pra usar o width e height chamando a janela
jogador = Jogador(jogo.janela)
inimigos = Inimigos()
tem_inimigo = 0
lista_x = []
for i in range(4):
lista_x.append(random.randint(1, 1200))
lista_y = []
for i in range(4):
lista_y.append(random.randint(1, 200))
while True:
jogo.fundo.draw()
for i in range(4):
inimigos.cria_inimigo(inimigos.matriz_inimigos[0][i],
inimigos.matriz_inimigos[1][i], lista_x[i],
lista_y[i])
#mudei tirei a movimentar fiona e coloquei tudo no metodo update
jogador.update()
jogo.janela.update()
def jogar(self):
fruta = self.__frutas.sorteiaFruta()
letras = ['_'] * len(fruta)
j = Jogador()
while True:
if j.tentativa == 0:
print('Suas tentativas terminaram')
break
print(f'Tentativas restantes {j.tentativa}')
l = input('Digite uma letra: ')
if len(l) == 1:
if l in fruta:
letras = self.__colocaLetra(fruta, l, letras)
else:
print('letra nao esta na palavra\n')
j.tentativa = 1
else:
if l == fruta:
print('Voce acertou')
break
else:
print('Errouuuuu\n')
j.tentativa = 1
if not '_' in letras:
print('Voce acertou')
break
def menu():
'''
Função que representa o Menu, onde há a parametrização dos objetos
'''
print("Bem vindo ao SE-PA-RAN-DO!!!")
nome = input("Digite seu nome: ")
jogador = Jogador(nome)
jogador.tipo = "JOGADOR"
print("1 - Criar Sala")
print("2 - Entrar na sala")
opcao = int(input("Digite a opção desejada: "))
if opcao == 1:
limite = int(
input(
"Informe o limite máximo da sala(Não informe para sem limites): "
))
sala = Sala(limite, nome)
sala.addParticipantes(nome)
elif opcao == 2:
sala = None
ret = [jogador, sala, opcao]
return ret
def __init__(self, tela):
self.jogador = Jogador(0, 640 / 3)
bola = Bola(3 * 960 / 4, 640 / 2, -420, 30 * random.randint(-10, 10))
self.parede1 = ParedeHorizontal("src/g/ping_pong_wall.png", 0, 0)
self.parede2 = ParedeHorizontal("src/g/ping_pong_wall2.png", 0,
640 - 10)
self.parede3 = ParedeVertical("src/g/ping_pong_fundo.png", 960 - 10, 0,
10, 640, False)
self.r, self.g, self.b = 0, 0, 0
self.tela = tela
self.bolas = [bola]
self.inicializarSons()
tempo = current_milli_time = lambda: int(round(time.time() * 1000))
random.seed(tempo)
# pygame.mixer.init()
self.scoreFont = pygame.font.SysFont("tahoma.TTF", 60)
self.score = 0
self.up = pygame.rect.Rect(0, -200, 960, 200)
self.down = pygame.rect.Rect(0, 640, 960, 200)
self.right = pygame.rect.Rect(960, 0, 200, 640)
self.obstaculos = [
self.parede1, self.parede2, self.parede3, self.jogador, self.up,
self.down, self.right
]
self.q = Queue()
self.st = threading.Thread(target=self.tocar_som, daemon=True)
self.st.start()
def inicializarJogo(self):
"""
Inicializa o jogo: cria as cartas e as distribui para os jogadores e as pilhas.
"""
# Inicializa a pilha de descarte do jogo construindo o objeto "monte" e retirando 1 carta
monte = self.monte
while True:
primeira_carta = monte.desempilhaMonte()
self.pilha_mesa.append(primeira_carta)
if primeira_carta.tipo != "+2" and primeira_carta.tipo != "reverso" and primeira_carta.tipo != "pula" and primeira_carta.tipo != "escolhacor" and primeira_carta.tipo != "+4":
break
while True:
self.n_de_jogadores = int(input("Digite o número de jogadores:"))
if int(self.n_de_jogadores) not in list(range(2, 10)):
print("Número inválido de jogadores.")
else:
break
# Inicializa cada jogador com sua respectiva quantidade de cartas
for i in range(self.n_de_jogadores):
listaMao = []
for j in range(self.qtd_cartas_iniciais):
listaMao.append(monte.desempilhaMonte())
jogador = Jogador(listaMao)
self.jogadores.append(jogador)
# Inicializa a pilha de compra do jogo retirando as cartas restantes do objeto "monte"
self.pilha_compra = monte.getMonte().copy()
def test_not_winner(self):
# Given
jogador = Jogador([Carta("vermelho", "1")])
# When
ganhou = self.gerenciador.verificarVencedor(jogador)
# Then
self.assertFalse(ganhou)
def test_winner(self):
# Given
jogador = Jogador([])
# When
ganhou = self.gerenciador.verificarVencedor(jogador)
# Then
self.assertTrue(ganhou)
def quantidade_jogadores(self):
lista_jogadores = []
while True:
try:
num_jogadores = int(input("quantos jogadores na mesa: "))
if num_jogadores < 1 or num_jogadores > 7:
print("favor digitar um numero entre 1 e 7")
else:
break
except ValueError:
print('Favor digitar um numero')
for i in range((num_jogadores)):
nome = input(f"Nome do jogador número {i+1}: ")
jogador = Jogador(nome)
lista_jogadores.append(jogador)
croupier = Jogador("Le Croupier")
lista_jogadores.append(croupier)
return lista_jogadores
def __numeroJogadores(self, lista : list) -> list:
try:
numero = int(input('Digite a quantidade de jogadores: '))
while numero < 2 or numero > 7:
numero = int(input('O numero deve ser no minimo 2 e no maximo 7'))
for i in range(0,numero):
j = Jogador(f'Jogador {i}')
lista.append(j)
except:
print('Digite apenas numeros')
def treinamentoSupervisionadoTradicional():
treinamento = TreinamentoSupervisionado(AmbienteTicTacToe(3))
redeTreinada = treinamento.executaTreinamentoTradicional(
numPartidas=1000,
numIteracoes=20000,
taxaAprendizagem=0.001,
momentum=1)
jogador1 = Jogador()
jogador2 = Jogador(redeTreinada)
print(
"\nTorneio entre Jogador Aleatório e Jogador Minimax com Rede Treinada"
)
partidaJogadores(jogador1.executaJogadorAleatorio,
jogador2.executaJogadorMiniMaxNN, 100, False)
print(
"\nTorneio entre Jogador MiniMax com Função Estática e Jogador Minimax com Rede Treinada"
)
partidaJogadores(jogador1.executaJogadorMiniMax,
jogador2.executaJogadorMiniMaxNN, 10, False)
print( regras.read() )
regras.close()
input('\n>>> Aperte <ENTER> para continuar <<<\n')
os.system(limpar)
# ---------------------------------------------------------------------------------------------------------------------------------------------------
# Recebendo o nome dos BOTS e criando BOTS:
for i in range(qtdBOTS):
nome = input('Digite o nome do BOT %i: ' %(i))
while nome.lower() in nomeBOTS or nome == '' or nome == 'REVISAR': # REVISAR é uma palavra reservada
nome = input('Digite outro nome: ')
jogadores[nome.lower()] = Jogador( nome, 'Vivo', choice( [-2, -1, 0, 1, 2] ), dict() ) # Criando BOTS, ainda sem cartas
nomeBOTS[nome.lower()] = nome # nomeBOTS[vinicius] = ViNiCiUs, por exemplo
tamMaiorNome = max( [len(nome) for nome in nomeBOTS] ) # recebendo o tamanho do maior nome
# ----------------------------------------------------------------------------------------------------------------------------------------------------
# Iniciando partida:
partida = 1
sair = False
while not sair: # Enquanto usuário não decidir sair
#os.system(limpar)
#print('Partida:',partida)
#print('Usuário',ptUsuario,'vs',ptAssassinos,'Assassinos')
# -------------------------------------------------------------------------------------------
# Distribuindo cartas:
jogador.dados_iguais += 1 # Incrementa a quantidade de jogadas com dados iguais
jogador.jogadas += 1 # Adiciona uma nova jogada para o jogador
if not jogador.esta_preso:
for dado in dados:
soma_dos_dados += dado
jogador.caminha(soma_dos_dados)
# Carrega o objeto do terreno onde o jogador esta para a variavel casa
casa = Tabuleiro.tabuleiro[jogador.posicao]
Acao.verifica_terreno(jogador, casa)
if jogador.jogadas == 0:
print("Fim do turno do {jogador}.".format(jogador=jogador.nome))
else:
turno(jogador)
if __name__ == '__main__':
for num_jogador in range(Configuracoes.quantidade_jogadores):
nome = input("Digite o nome do jogador {num}: ".format(num=str(num_jogador))) # Pega o nome do jogador
jogador = Jogador(nome) # Cria uma instancia do objeto para o jogador
Configuracoes.jogadores.append(jogador) # Adiciona o jogador na lista de jogadores
while len(Configuracoes.jogadores) > 1:
for jogador in Configuracoes.jogadores:
jogador.inicia_turno()
turno(jogador)
input("Pressione qualquer tecla para continuar...")
return opt
option=Menu()
while(option != 5):
if (option==1):
nome= input("Digite o Nome do Jogo: ")
price=float(input("Digite o preco do Jogo: "))
jogo.append(Jogo(nome,price))
print(jogo[i].name, jogo[i].price)
i+=1
option=Menu()
if (option==2):
nomeP= input("Digite o Nome do Jogador: ")
JogoP= input("Digite o Nome do Jogo: ")
jogador.append(Jogador(nomeP,JogoP))
print(jogador[i].nome, jogador[i].jogo)
j+=1
option=Menu()
if(option==3):
nomeAP= input("Digite o nome do Apostador: ")
cpf= int(input("Digite o CPF do Apostador: "))
mail=input("Digite o e-mail do Apostador: ")
tel= input("Digite o telefone do Apostador: ")
qt= int(input("Digite a quantidade de fichas: "))
jogs= input("Digite o nome do jogo: ")
player=input("Digite o nome do jogador: ")
aposta.append(Aposta(nomeAP,cpf,mail,tel,qt,jogs,player))
print(aposta[k].Nome,aposta[k].CPF , aposta[k].Email,aposta[k].Telefone, aposta[k].Quantidade,aposta[k].Jogo,aposta[k].Jogador)
k+=1
from Mesa import Mesa
from Jogador import Jogador
if __name__ == '__main__':
njogadores = int(input('Escolha a quantidade de jogadores: '))
mesa = Mesa(njogadores)
for i in range(0, njogadores):
nome = str(input('Escreva o nome do jogador ' + str(i + 1) + ": "))
mesa.adicionar_jogador(Jogador(nome, 500))
mesa.distribuir_cartas()
mesa.colocar_cartas_mesa()
print(mesa.checa_vencedor())
def executaTreinamentoTradicional(self,
numPartidas=1000,
numIteracoes=100000,
taxaAprendizagem=0.1,
momentum=1):
print('--- INÍCIO TREINAMENTO ---\n')
print("Etapa 1: Criação Base de Dados -> ", numPartidas, " jogos\n")
##Criação da base de dados (entradas (estados finais) e saídas (true labels))
baseDadosEntradasEstadosFinais = np.zeros((1, 9))
baseDadosSaidasEstadosFinais = np.zeros((1, 1))
iteracao = 0
##Início Etapa 1
while iteracao < numPartidas:
##Inicializa Partida
tabuleiro = self.ambiente.getTabuleiro().getEstadoAtual()
jogadorTurno = 1
#Enquanto a partida estiver sendo realizada
while True:
movimentosLegais = list(
self.ambiente.movimentosDisponiveisLegais(tabuleiro))
if len(movimentosLegais) == 0:
break
if jogadorTurno > 0:
movimento = Jogador().executaJogadorAleatorio(
self.ambiente, tabuleiro, 1)
else:
movimento = Jogador().executaJogadorAleatorio(
self.ambiente, tabuleiro, -1)
#Movimento ilegal ocasiona em vitória do oponente
if movimento not in movimentosLegais:
print("Movimento Ilegal", movimento)
break
#Executa movimento
tabuleiro = self.ambiente.executaMovimento(
tabuleiro, movimento, jogadorTurno)
#Exibe o movimento realizado pelo jogador corrente
#self.ambiente.exibeMovimento(tabuleiro, jogadorTurno)
#Verifica se há um vencedor
vencedor = self.ambiente.verificaExistenciaVencedor(tabuleiro)
#Caso houver vencedor, termina a partida e atualia a melhor rede
if vencedor != 0:
break
#Troca turno
jogadorTurno = -jogadorTurno
##Base de Dados de Estados Finais
entrada = np.array([tabuleiro])
saida = np.array([
Utilidade(self.ambiente, 'Estatica').funcaoAvaliacao(tabuleiro)
]).reshape(1, 1)
if (saida == 1 or saida == 0 or saida == -1) and (
entrada != baseDadosEntradasEstadosFinais).all(1).any():
baseDadosEntradasEstadosFinais = np.append(
baseDadosEntradasEstadosFinais, entrada, axis=0)
baseDadosSaidasEstadosFinais = np.append(
baseDadosSaidasEstadosFinais, saida, axis=0)
else:
iteracao -= 1
iteracao += 1
##Fim Etapa 1
##Início Etapa 2
print('Etapa 2: Treinamento da Rede com a Base de Dados\n')
inicio = timeit.default_timer()
rede = RedeNeuralMLP(9, 20, 1) #Criação da Rede
##Split da base em treinamento e teste (80% treinamento e 20% teste)
entradasTreinamento, entradasTeste, saidasTreinamento, saidasTeste = train_test_split(
baseDadosEntradasEstadosFinais,
baseDadosSaidasEstadosFinais,
test_size=0.2)
custos, iteracoes = rede.executaTreinamentoModelo2Camadas(
entradasTreinamento, saidasTreinamento, numIteracoes,
taxaAprendizagem, momentum)
plt.plot(iteracoes, custos)
plt.xlabel('Número Iterações')
plt.ylabel('Custo')
plt.show()
total = timeit.default_timer() - inicio
print("Tempo de Treinamento: " + str(total) + " segundos.")
##Fim Etapa 2
##Início Etapa 3
print("\nEtapa 3: Teste da Rede\n")
##Array de true labels e de saídas obtidas pela rede
saidasTeste = saidasTeste.reshape(saidasTeste.shape[1],
saidasTeste.shape[0])
predicoesTeste = rede.predicao(entradasTeste)
##Arredondamento dos valores que foram obtidos pela rede (Exemplo: 0.99 = 1)
predicoesTeste = np.round(predicoesTeste,
decimals=1).reshape(saidasTeste.shape)
##Cálculo da precisão da rede
precisaoRede = np.sum(
np.equal(predicoesTeste, saidasTeste) / saidasTeste.size) * 100
print('Precisão da Rede Treinada: ', precisaoRede, '%\n')
##Fim Etapa 3
return rede
from Jogador import Jogador
#Instanciação ciração de um objeto com nome(jogador1)
jogador1 = Jogador('Neymar', 'Corinthians', 10, 9.5)
print('nome: ', jogador1.getNome())
print('time: ', jogador1.getTime())
print('camisa: ', jogador1.getCamisa())
print('velocidade: ', jogador1.getVelocidade())
def __init__(self, name):
'''
Construtor
@param nome: Nome do jogador.
'''
Jogador.__init__(self, name)
class Jogo():
def __init__(self, tela):
self.jogador = Jogador(0, 640 / 3)
bola = Bola(3 * 960 / 4, 640 / 2, -420, 30 * random.randint(-10, 10))
self.parede1 = ParedeHorizontal("src/g/ping_pong_wall.png", 0, 0)
self.parede2 = ParedeHorizontal("src/g/ping_pong_wall2.png", 0,
640 - 10)
self.parede3 = ParedeVertical("src/g/ping_pong_fundo.png", 960 - 10, 0,
10, 640, False)
self.r, self.g, self.b = 0, 0, 0
self.tela = tela
self.bolas = [bola]
self.inicializarSons()
tempo = current_milli_time = lambda: int(round(time.time() * 1000))
random.seed(tempo)
# pygame.mixer.init()
self.scoreFont = pygame.font.SysFont("tahoma.TTF", 60)
self.score = 0
self.up = pygame.rect.Rect(0, -200, 960, 200)
self.down = pygame.rect.Rect(0, 640, 960, 200)
self.right = pygame.rect.Rect(960, 0, 200, 640)
self.obstaculos = [
self.parede1, self.parede2, self.parede3, self.jogador, self.up,
self.down, self.right
]
self.q = Queue()
self.st = threading.Thread(target=self.tocar_som, daemon=True)
self.st.start()
def iniciar(self):
TelaInicial(self.tela).telaInicial()
while True:
self.jogo()
GameOver(self.tela, self.score).gameOver()
self.__init__(self.tela)
def jogo(self):
self.segundos = 0
clock = pygame.time.Clock()
var = True
while (var):
self.segundos = clock.tick(60) / 1000.0
var = self.checarEventos()
self.atualizarBola()
self.atualizarTela()
if not self.bolas:
var = False
def checarEventos(self):
for x in pygame.event.get():
if x.type == pygame.QUIT:
return pygame.quit()
elif x.type == pygame.KEYDOWN:
if x.key == pygame.K_DOWN:
if not (self.jogador.colliderect(self.parede2)):
self.jogador.mover(False, self.segundos)
elif x.key == pygame.K_UP:
if not (self.jogador.colliderect(self.parede1)):
self.jogador.mover(True, self.segundos)
return True
def atualizarBola(self):
for bola in self.bolas:
bola.mover(self.segundos)
if bola.left < -90 or bola.left > 960:
self.bolas.remove(bola)
# if random.randint(0,2)==0:
# self.som3.play()
continue
indice = bola.collidelist(self.obstaculos)
if indice != -1:
self.atualizarCor()
if self.obstaculos[indice] == self.jogador:
self.q.put(bola.centery - self.jogador.centery)
self.score += 1
b = self.jogador.colidirBola(bola)
self.bolas.append(b)
elif self.obstaculos[indice] == self.up:
bola.top = 40
elif self.obstaculos[indice] == self.down:
bola.top = 600
elif self.obstaculos[indice] == self.right:
bola.right = 950
else:
# self.som2.play()
self.obstaculos[indice].colidirBola(bola)
def atualizarTela(self):
self.tela.fill((self.r, self.g, self.b))
self.tela.blit(self.jogador.superficie, self.jogador)
self.tela.blit(self.parede1.superficie, self.parede1)
self.tela.blit(self.parede2.superficie, self.parede2)
self.tela.blit(self.parede3.superficie, self.parede3)
score = self.scoreFont.render(str(self.score), True, (255, 255, 255))
rec = self.tela.get_rect()
self.tela.blit(
score, (rec.centerx - score.get_rect().width / 2, rec.top + 50))
for bola in self.bolas:
self.tela.blit(bola.superficie, bola)
pygame.display.flip()
def inicializarSons(self):
self.sons = []
self.som2 = pygame.mixer.Sound("src/s/ping_pong_8bit_plop.ogg")
self.som3 = pygame.mixer.Sound("src/s/ping_pong_8bit_peeeeeep.ogg")
# i=1
# while(i<=14):
# self.sons.append(pygame.mixer.Sound("src/s/ping_pong_8bit_beeep"+str(i)+".ogg"))
# i+=1
import os
s = [
os.fsdecode("src/s/piano/" + x)
for x in sorted(os.listdir("src/s/piano"))
]
s = s[24:48]
self.sons = [pygame.mixer.Sound(x) for x in s if x.endswith(".wav")]
def atualizarCor(self):
acrescimo = 1 #random.randint(5,25)
n = random.randint(1, 3)
i = random.randint(0, 1)
if i == 0:
if n == 1:
self.r = (self.r + acrescimo) % 255
elif n == 2:
self.g = (self.g + acrescimo) % 255
else:
self.b = (self.b + acrescimo) % 255
elif i == 1:
if n == 1:
if self.r > acrescimo:
self.r -= acrescimo
elif n == 2:
if self.g > acrescimo:
self.g -= acrescimo
else:
if self.b > acrescimo:
self.b -= acrescimo
# elif i==2:
# if random.randint(0,512)==23:
# self.r = 255 - self.r
# self.g = 255 - self.g
# self.b = 255 - self.b
def tocar_som(self):
nch = pygame.mixer.get_num_channels()
channels = [pygame.mixer.Channel(x) for x in range(0, nch)]
h = self.jogador.height
i = 0
while True:
a = self.q.get() + self.jogador.height / 2
s = int(((a / h) * len(self.sons)))
if s < 0:
s = 0
elif s >= len(self.sons):
s = len(self.sons) - 1
print(s)
c = channels[i]
c.stop()
# c.play(self.sons[random.randint(0,len(self.sons)-1)])
c.play(self.sons[s])
i = (i + 1) % nch
