def preencher_jogadores(self):
self.__jogadores.extend([
Jogador('Jonatha', 1),
Jogador('Pedro'),
Jogador('Letícia'),
Jogador('João')
])
def main():
print("-" * 50)
nome = input("Olá, digite o seu nome: ")
#cria o objeto jogador e game
jogador = Jogador(nome)
game = Jogo(jogador)
#laço de repetição onde verifica se o jogador deseja continuar
while True:
#cria o menu
print('-' * 50)
print(' ' * 15, jogador.nome, ' xXx CPU')
print('-' * 50)
#recebe a escolha do jogador
opcao = int(
input(
"\nDigite um número para iniciar o jogo, sendo:\n0 = Pedra\n1 = Papel\n2 = Tesoura\n"
))
if not jogador.escolher(opcao):
print("Opção inválida, digite novamente")
continue
#chama o metodo onde ira iniciar o jogo
game.iniciar()
continuar = input(
"\nDeseja continuar jogando? 1: Sair, 2: Continuar\n")
if continuar != "2":
print("Fim de jogo")
break
def carregar_jogador():
nome = input('digite o seu nome: ')
jogador = Jogador.buscar_jogador(nome)
if jogador is None:
jogador = Jogador(nome)
return jogador
def test_proxima_posicao():
POS = 4
tabuleiro = Tabuleiro()
# Testa se a proxima posiçao fica de 1 a 6 casas a frente
jogador = Jogador("Manuel")
jogador.posicao = POS
proxima_posicao = tabuleiro.proxima_posicao(jogador)
assert proxima_posicao >= POS + 1 and \
proxima_posicao <= POS + 6
def __criarJogador(self, nome, id):
if len(nome) < 1:
nome = 'jogador_' + str(id)
j = self.__tabela_jogadores.get_jogador(nome)
if j == None:
j = Jogador(nome, self.cores[id])
j.setId(id)
self.__jogadores.append(j)
self.__atualizarJogadores_ip()
def test_perde_propriedade():
jogador1 = Jogador("Manuel")
jogador2 = Jogador("Antonio")
for i in range(0, len(tabuleiro.propriedades) - 1, 2):
tabuleiro.propriedades[i].dono = jogador1
tabuleiro.propriedades[i + 1].dono = jogador2
tabuleiro.perde_propriedades(jogador1)
assert len([p for p in tabuleiro.propriedades if p.dono == jogador1]) == 0
def geraJogadoresNovos (self):
listaJogadores = []
for index in range (self.numeroJogadoresNovosGeracao):
jogador = Jogador ()
listaJogadores.append (jogador)
jogador.salvaModelo ()
print ("Jogador criado: " + str (jogador.nomeJogador))
self.fileResultados.write ("Jogador criado: " + str (jogador.nomeJogador) + "\n")
return listaJogadores
def inicializar_jogador(self):
nome = input("Qual nome do Jogador 1:")
jogador = Jogador(nome, self.mapa)
nNavios = int(input("Quantos navios serão criados:"))
for i in range(nNavios):
cordIX = int(input("Qual a coordenada x inicial:"))
cordIY = int(input("Qual a coordenada y inicial:"))
cordFX = int(input("Qual a coordenada x final:"))
cordFY = int(input("Qual a coordenada y final:"))
jogador.criar_navio(cordIX, cordIY, cordFX, cordFY)
return jogador
def geraJogadoresIniciais (self):
listaJogadores = []
for index in range (self.numeroJogadoresIniciais):
jogador = Jogador ()
listaJogadores.append (jogador)
self.listaJogadoresBase.append (copy.deepcopy(jogador))
jogador.salvaModelo ()
print ("Jogador criado: " + str (jogador.nomeJogador))
self.fileResultados.write ("Jogador criado: " + str (jogador.nomeJogador) + "\n")
return listaJogadores
def verificar_novo_jogador(jnome, jtoken):
jnome = str(input("\nIntroduza o seu nome: "))
if jnome in nomes: #caso ja exista
opcao_igual = True
while opcao_igual:
escolha = str(
input(
"O jogador {} ja existe.\n\nDeseja usar esse jogador?(S/N) "
.format(jnome)))
if escolha == "S": #e queira usar o que existe
opcao_igual = False
jtoken = selecionar_jogador(caminho_ficheiro, jnome, jtoken)
return False, Jogador(jnome, jtoken)
elif escolha == "N": #se quiser criar um jogador novo
jnome = str(input("\nIntroduza um nome diferente: "))
if jnome not in nomes: #quando acertar
opcao_igual = False
jtoken = str(
input(
"\nIntroduza um token para o representar no jogo: "
))
if jtoken in tokens:
opcao_igual = True
while opcao_igual:
escolha = str(
input(
"\nO token {} ja esta a ser usado por outro jogador.\n\nPor favor escolha outro token: "
.format(jtoken)))
if escolha not in tokens:
jogador_novo = [[jnome, jtoken, 0, 0]]
opcao_igual = False
return jogador_novo, Jogador(jnome, jtoken)
else:
print("\nApenas sao aceites as letras S ou N como resposta")
else:
jtoken = str(
input("\nIntroduza um token para o representar no jogo: "))
if jtoken in tokens:
opcao_igual = True
while opcao_igual:
escolha = str(
input(
"\nO token {} ja esta a ser usado por outro jogador.\n\nPor favor escolha outro token: "
.format(jtoken)))
if escolha not in tokens:
jogador_novo = [[jnome, jtoken, 0, 0]]
opcao_igual = False
return jogador_novo, Jogador(jnome, jtoken)
else:
jogador_novo = [[jnome, jtoken, 0, 0]]
return jogador_novo, Jogador(jnome, jtoken)
def iniciar():
global jogador, passar_turno, turno_atual, dicionario, dicionario_ordenado, modo_jogo
tabuleiro = Tabuleiro(DL, TL, DP, TP)
pacote = Pacote()
jogador = []
passar_turno = 0
turno_atual = 1
dicionario = set()
dicionario_ordenado = {}
pkl_file = open('dicionario.pkl', 'rb')
dicionario = pickle.load(pkl_file)
pkl_file.close()
pkl_file = open('dicionario_ordenado.pkl', 'rb')
dicionario_ordenado = pickle.load(pkl_file)
pkl_file.close()
if dicionario == "":
print("ERRO - Dicionario não foi carregado corretamente")
# MENU DE INICIO
os.system('cls' if os.name == 'nt' else 'clear')
print("#-----------------------------------------------#")
print("| SCRABBLE - PROJETO E ANÁLISE DE ALGORITIMOS |")
print("| TeamR |")
print("| Luiz Eduardo Pereira - 0021619 |")
print("| Rafaela Martins Vieira - 0002852 |")
print("#-----------------------------------------------#")
print("\n\n\n")
print("Modos de Jogo:")
print(" 1 - Jogador vs Jogador")
print(" 2 - Jogador vs Computador")
modo_jogo = int(input("Escolha uma opção: "))
while ((modo_jogo < 1) or (modo_jogo > 2)):
modo_jogo = int(input("Escolha uma opção válida (1 / 2): "))
# ESCOLHA DE NOMES DOS JOGADORES
jogador.append(Jogador(pacote))
jogador[0].setNome(input("Nome do Jogador 1: "))
jogador.append(Jogador(pacote))
if (modo_jogo == 1):
jogador[1].setNome(input("Nome do Jogador 2: "))
else:
jogador[1].setNome("Computador")
jogador_atual = jogador[0]
turno(jogador_atual, tabuleiro, pacote)
def test_retira_dono():
propriedade = Propriedade(200, 30, "Loja - Vila Mariana")
jogador = Jogador("Alberto")
propriedade.dono = jogador
assert propriedade.dono == jogador
propriedade.retira_dono()
assert propriedade.dono == SEM_DONO
def add_new_players(self, jogadores, new_players):
for new_player in new_players:
jogador = Jogador(nome=new_player['jogador'],
ratings=new_player['ratings'])
jogadores.append(jogador)
return jogadores
def main():
global jogador
nome_random = choice(
['Arther', 'Frery', 'Remonnet', 'Richessa', 'Adelie', 'Mirielda'])
# ============================== LAYOUT GLOBAL MENU ============================== #
layout_menu = [[sg.Text('# ----- NOME ----- #', font='Any 12')],
[
sg.InputText(default_text=nome_random,
size=(30, 1),
key='_nome_p_')
], [sg.Text('# ----- SEXO ----- #', font='Any 12')],
[sg.Checkbox(' Masculino'),
sg.Checkbox(' Feminino')],
[sg.Button('Iniciar', size=(30, 1), key='_iniciar_')],
[sg.Button('Sair', size=(30, 1), key='Cancel')]]
window = sg.Window(title='DUNGEON',
layout=layout_menu,
element_justification='c')
while True:
event, values = window.read()
if event == sg.WIN_CLOSED or event == 'Cancel': # if user closes window or clicks cancel
break
if event == '_iniciar_':
jogador = Jogador(values['_nome_p_'])
sg.popup('Jogo iniciado!')
window.Close()
game()
window.Close()
def __init__(self):
# Model
self.__FPS = FPS
self.__caption = TITULO
self.__sprites = pg.sprite.Group()
self.__jogador = Jogador()
self.__level = Level(world)
self.__background = pg.image.load("data/teste.png")
self.__bg_x = 0
# VIEW
# inicializa a janela do pygame
pg.init()
# inicializa o audio
pg.mixer.init()
# define o titulo
pg.display.set_caption(self.__caption)
# Model
self.__clock = pg.time.Clock()
# VIEW
self.__sprites.add(self.__jogador, self.__level.platforms,
self.__level.items, self.__level.exit)
self.__screen = pg.display.set_mode((WIDTH, HEIGHT))
self.__running = True
def incricao_de_jogadores(self):
continuar_adicionando = True
while continuar_adicionando:
self.jogadores.append(Jogador(str(input("Nome do jogador: "))))
encerrar_inscricao = input(
"Continuar adicionando jogadores (Y/N)? ").upper()
continuar_adicionando = (encerrar_inscricao == "Y")
def _cria_jogadores(self, qtd_jogadores):
self.jogadores = []
for i in range(1, qtd_jogadores + 1):
comp = random.choice(self._tipos_jogadores) if self.tipos_jogador_aleatorio else \
self._tipos_jogadores[(i-1) % 4]
self.jogadores.append([
Jogador(f"Jogador {i}", comp),
0 # posição
])
def menu():
while True:
print('-- JOGO DA FORCA -- ')
print('1 - Ver placar')
print('2 - Jogar')
print('3 - Sair')
opcao = int(input('Digite a opção selecionada:'))
if opcao == 1:
Jogador.mostrar_pontuacao()
elif opcao == 2:
jogar()
elif opcao == 3:
Jogador.salvar_jogadores('jogadores.txt')
break
else:
print('opcao invalida')
def add_players(team, fake):
# add goalkeeper
for i in range(1):
team.add(Jogador(fake.name_male(), randint(20, 35), 'Goleiro'))
# add centre backs
for i in range(2):
team.add(Jogador(fake.name_male(), randint(20, 35), 'Zagueiro'))
# add wing backs
for i in range(2):
team.add(Jogador(fake.name_male(), randint(20, 35), 'Lateral'))
# add midfielders
for i in range(4):
team.add(Jogador(fake.name_male(), randint(20, 35), 'Meio-campista'))
# add strikers
for i in range(2):
team.add(Jogador(fake.name_male(), randint(20, 35), 'Atacante'))
def get_jogador(self, nome):
jogador_data = self.read_query(f"""
select * from JOGADORES where nome = '{nome}'
""")
if jogador_data != []:
jogador_data = jogador_data[0]
jogador = Jogador(nome=jogador_data[0],
cor=(jogador_data[1], jogador_data[2],
jogador_data[3]))
return jogador
else:
return None
def jogar():
palavras = ler_arquivo('forca_python.txt')
palavra = (random.choice(palavras)).upper()
aPalavra = list('_' * len(palavra))
Jogador.importar_jogadores()
nome = (input('informe o nome do jogador ')).upper()
counter = 0
ntentativas = 0
while counter < len(palavra) and ntentativas < 6:
letra = (input('digite uma letra ')).upper()
if letra in palavra:
for index, l in enumerate(palavra):
if letra == l:
aPalavra[index] = letra
counter += 1
else:
ntentativas += 1
print(aPalavra)
if ntentativas >= 6:
print('Enforcado')
else:
print('Ganhou')
jogador = Jogador.buscar_jogador(nome)
if jogador != None:
jogador.pontuacao += 1
else:
Jogador(nome, 1)
Jogador.salvar_jogadores()
def __init__(self, superficie, nivel):
self.__superficie = superficie
self.__background_colour = (150, 220, 255) # Cor do fundo
(width, height) = superficie.get_size()
self.__campo_visivel = pygame.Rect(0, 0, width, height)
self.__comeco = 0
self.__tempo_maximo = 350
self.__fonte = pygame.font.SysFont('Arial', 20)
self.__atrasofim = 0
##### ENTRADAS DO JOGADOR #####
self.__cima, self.__baixo, self.__direita, self.__esquerda = 0, 0, 0, 0
self.__atrito = 0.5
self.__espaco = False
self.__bola_fogo = False
###### INSTANCIAS DE OBJETOS ######
self.__jogador = Jogador('mario', 200, 550, 0, 1)
##### MAPA #####
self.__mapa = Mapa((width, height))
self.__mapa.iniciar([nivel[0].copy(), nivel[1].copy()])
self.__comeco = pygame.time.get_ticks() / 1000
def configuraNome(self,nomeJogador):
if nomeJogador == '':
return 0
jgdAtual = len(self.jogador) + 1
self.jogador.append(Jogador(nomeJogador,0))
self.lbjogador.setText('Informe o nome do '+str(jgdAtual+1)+'º Jogador:')
self.dejogador.focus=1
self.dejogador.enterText("")
if jgdAtual >= NUM_JOGADORES:
self.lbjogador.destroy()
self.dejogador.destroy()
self.backGround[0].destroy()
def __init__(self):
# configs
self.__FPS = FPS
self.__caption = TITULO
self.__sprites = pg.sprite.Group()
self.__jogador = Jogador()
# inicializa a janela do pygame
pg.init()
# inicializa o audio
pg.mixer.init()
# define o titulo
pg.display.set_caption(self.__caption)
# define o clock
self.__clock = pg.time.Clock()
# adiciona sprites ao grupo sprites
self.__sprites.add(self.__jogador)
self.__screen = pg.display.set_mode((WIDTH, HEIGHT))
self.__running = True
def get_jogadores_do_dia_pela_lista(self, lista_ids):
'''
Retorna uma lista dos jogadores do dia do raxa
'''
lista_nomes_jogadores = self.get_lista_jogadores()
lista_jogadores = []
data_util = self.get_util_data()
for nome_jogador in lista_nomes_jogadores:
if nome_jogador in data_util.Jogador.tolist():
jogador_data = data_util[data_util['Jogador'] == nome_jogador]
ratings = jogador_data['Rating'].tolist()
jogador = Jogador(nome=nome_jogador, ratings=ratings)
lista_jogadores.append(jogador)
return lista_jogadores
def reset(self, altura, largura):
self.score = 0
self.objetos = []
self.deletar = []
self.start = False
self.time = 0
self.haJogadores = True
self.telaAlt = altura
self.telaLarg = largura
fundo = Objeto(0, -30, "imagens/fundo.png", "background")
fundo.velX = -1
gramado = Objeto(0, altura - 80, "imagens/gramado.png", "gramado")
gramado.velX = -2
chão = Objeto(0, altura - 30, "imagens/chão.png", "chão")
chão.velX = -5
flappy = Jogador(largura // 4, altura // 2, "imagens/flappy.png",
"flappy")
self.adicionarObjeto(fundo)
self.adicionarObjeto(gramado)
self.adicionarObjeto(chão)
self.adicionarObjeto(flappy)
def repdroduzJogador (self, jogador):
# tau = 0.0839
tau = 1/math.sqrt(2 * math.sqrt (jogador.calculaQuantidadeDePesos ()))
novoSigma = []
for listaWeights in jogador.listaSigmas:
novaListaWeights = []
changedGaussWeights = self.geraExponencialDeGaussianas (listaWeights[0].shape[0], listaWeights[0].shape[1], tau)
changedGaussBiases = self.geraExponencialDeGaussianasArray (listaWeights[1].shape[0], tau)
novoWeights = np.multiply (listaWeights [0], changedGaussWeights)
# novoWeights [novoWeights > 0] = self.forcedSigma
# novoWeights [novoWeights < 0.005] = 0.005
novoBiases = np.multiply (listaWeights [1], changedGaussBiases)
# novoBiases [novoBiases > 0] = self.forcedSigma
# novoBiases [novoBiases < 0.005] = 0.005
novaListaWeights.append (novoWeights)
novaListaWeights.append (novoBiases)
novoSigma.append (copy.deepcopy(novaListaWeights))
novoModel = copy.deepcopy (jogador.model)
for layerIndex in range (3):
layer = novoModel.get_layer (index = layerIndex)
layerWeights = layer.get_weights()
changedGaussWeights = self.geraMatrizDeVariaveisGaussianas (layerWeights[0].shape[0], layerWeights[0].shape[1])
changedGaussBiases = self.geraArrayDeVariaveisGaussianas (layerWeights[1].shape[0])
layerWeightsWeights = np.add (layerWeights [0], np.multiply (novoSigma [layerIndex] [0], changedGaussWeights))
layerWeightsBiases = np.add (layerWeights [1], np.multiply (novoSigma [layerIndex] [1], changedGaussBiases))
novaListaWeights = []
novaListaWeights.append (layerWeightsWeights)
# print ("Diferença total entre os pesos layer " + str(layerIndex) + " do " + str (jogador.nomeJogador) + " : " + str(np.sum (layerWeights[0] - layerWeightsWeights)))
# print ("Diferença total entre os biases layer " + str(layerIndex) + " do " + str (jogador.nomeJogador) + " : " + str(np.sum (layerWeights[1] - layerWeightsBiases)))
novaListaWeights.append (layerWeightsBiases)
layer.set_weights(novaListaWeights)
novoValorDama = max (min (jogador.valorDama * math.exp((1/math.sqrt(2)) *gauss (self.meanDama, self.varianceDama)), 3), 1)
jogadorFilho = Jogador (novoModel, novoValorDama, novoSigma, jogador.geracao + 1, jogador.genealogia)
return jogadorFilho
def iniciar(self, fase, dicionaro_mapa, poder_atual, poder_armazenado, paletas):
"""define outras propriedades do mapa fora do __init__()
return o objeto jogador a ser utilizado"""
##### LEITURA DAS FASES A PARTIR DO ARQUIVO JSON #####
lista_todos = dicionaro_mapa[fase]
objetos_no_mapa = lista_todos[0]
for item in objetos_no_mapa:
for classe in classes_instanciaveis:
if item[0] == classe.__name__:
parametros = item[1] #Sim eh so pra ser maneiro
objeto = classe(*parametros)
self.__lista_de_entidades.append(objeto)
self.__tamanho = lista_todos[1]
self.__proxima_fase = lista_todos[2]
self.__fase = fase
##### INSTANCIACAO DO JOGADOR #####
self.__jogador = Jogador("rabisco", 200, self.tamanho[1] - 50, poder_atual, poder_armazenado, paletas)
##### CARREGAMENTO DAS IMAGENS DAS ENTIDADES #####
for entidade in self.__lista_de_entidades:
if entidade.imagem != "0": entidade.sprite = Sprite(entidade.imagem)
return self.__jogador
def __init__(self):
# Pygame
self.__pygame = pygame
self.__pygame.init()
self.__pygame.font.init()
self.__pygame.mixer.init()
self.__FPS = 30
self.__FramePerSec = pygame.time.Clock()
self.__pygame.display.set_caption("coRUNavirus")
self.__tela = Tela()
self.__jogador = Jogador([pygame.image.load("Materials/p1.png").convert_alpha(self.__tela.display),
pygame.image.load("Materials/p2.png").convert_alpha(self.__tela.display),
pygame.image.load("Materials/p1.png").convert_alpha(self.__tela.display),
pygame.image.load("Materials/p3.png").convert_alpha(self.__tela.display)])
self.__obstaculo_controller = ObstaculoController(self.__jogador)
self.__efeito_controller = EfeitoController(self.__jogador)
self.__estados = {"inicial": EstadoInicial(self.__jogador),
"jogando": EstadoJogando(self.__jogador, self.__obstaculo_controller, self.__efeito_controller),
"pausa": EstadoPausa(self.__jogador, self.__obstaculo_controller, self.__efeito_controller),
"derrota": EstadoDerrota(self.__jogador, self.__obstaculo_controller, self.__efeito_controller),
"recorde": EstadoRecorde(),
"regras": EstadoRegras(),
"som": EstadoSom(),
"developers": EstadoDevelopers()}
from jogador import Jogador
#instaciação ou criação de um objeto(Jogador1)
jogador1 = Jogador('Neymar', 'PSG', 10, 9.5)
print('Nome: ', jogador1.getNome())
print('Time: ', jogador1.getTime())
print('Camisa: ', jogador1.getCamisa())
print('Velocidade: ', jogador1.getVelocidade())