def criaTabuleiroAPartirDeUmMovimento(self, movimento):
novoTabuleiro = Tabuleiro(self.tabuleiro.tabuleiroConfiguracao)
if (novoTabuleiro.doAnyMovement(movimento)):
return novoTabuleiro
else:
return None
def criaTabuleiroAPartirDeUmaListaDeMovimentos(self, listaMovimento):
novoTabuleiro = Tabuleiro(self.tabuleiro.tabuleiroConfiguracao)
if (novoTabuleiro.doMultipleMovementsComer(listaMovimento)):
return novoTabuleiro
else:
return None
def main():
tabuleiroInicial = Tabuleiro()
pos_i = random.randint(0,2)
pos_c = random.randint(0,2)
tabuleiroInicial.board[pos_i][pos_c] = 'X'
estadoinicial = Estado(tabuleiroInicial, None, 0, 'Max')
estadoinicial.tabuleiro.imprimetabuleiro()
def jogar(self):
maior_utilidade = Nodo.MIN
melhor_jogada = Jogada(0, 0, 1)
nivel = 1
# [0,1,2,3,4,5,6]
# sort by next play utility
# for i in range(7):
# tabuleiro = Tabuleiro(0, 0, [list(linha) for linha in self.tabuleiro.celulas])
# if Nodo.N_JOGADAS is 8:
# Nodo.NIVEL_MAX = 11
# elif Nodo.N_JOGADAS is 9:
# Nodo.NIVEL_MAX = 14
# elif Nodo.N_JOGADAS >= 10:
# Nodo.NIVEL_MAX = 20
Nodo.NIVEL_MAX = 9 + Nodo.tamanho_colunas.count(7) * 3
for i in [3,2,4,1,5,0,6]:
# tabuleiro = copy.deepcopy(self.tabuleiro)
if Nodo.tamanho_colunas[i] is 7:
continue
tabuleiro = Tabuleiro(0,0,[list(linha) for linha in self.tabuleiro.celulas])
linha = tabuleiro.inserirPeca(i, Jogador.COMPUTADOR)
if linha is None:
continue
nodo = Nodo(tabuleiro)
jogada = Jogada(linha, i, Jogador.COMPUTADOR)
utilidade = nodo.visitar(nivel, Nodo.MIN, Nodo.MAX, jogada)
if utilidade > maior_utilidade:
melhor_jogada = jogada
maior_utilidade = utilidade
return melhor_jogada
def visitar(self, nivel, alpha, beta, jogada):
if nivel == Nodo.NIVEL_MAX or self.tabuleiro.verificarVitoria(jogada):
return self.tabuleiro.utilidade(jogada)
jogador = Jogador.HUMANO if jogada.jogador is Jogador.COMPUTADOR else Jogador.COMPUTADOR
for i in [3,2,4,1,5,0,6]:
# tabuleiro = copy.deepcopy(self.tabuleiro)
tabuleiro = Tabuleiro(0,0,[list(linha) for linha in self.tabuleiro.celulas])
linha = tabuleiro.inserirPeca(i, jogador)
if linha is None:
continue
nodo = Nodo(tabuleiro)
jogada = Jogada(linha, i, jogador)
utilidade = nodo.visitar(nivel+1, alpha, beta, jogada)
if jogador is Jogador.COMPUTADOR:
if utilidade > alpha:
alpha = utilidade
else:
if utilidade < beta:
beta = utilidade
if alpha >= beta:
if jogador is Jogador.COMPUTADOR:
return alpha
else:
return beta
if jogador is Jogador.COMPUTADOR:
return alpha
else:
return beta
class Meme:
"""Base do jogo com tabuleiro e uma mao."""
def __init__(self, gui):
"""Constroi a casa que indica a peca que foi selecionada. """
self.gui = gui
self.casa = Casa(gui,self,99)
self.fase = 0
def build_base(self,gui):
"""Constroi as partes do Jogo. """
self.build_tabuleiro(gui)
self.build_mao(gui)
def build_tabuleiro(self,gui):
"""Constroi o tabuleiro onde as pecas sao jogadas."""
self.tabuleiro =Tabuleiro(gui,self)
def build_mao(self,gui):
"""Constroi os dois espacos onde as pecas se iniciam."""
self.mao1 =Mao(gui,self,0)
self.pecas = [peca for peca in self.mao1.pecas]
def avanca_fase(self):
self.fase += 1
self.gui.send("phase", fas = self.fase,
pcs = [peca.local.name for peca in self.pecas])
if self.fase >= 5:
self.gui.send("end", fim = self.fase)
return self.tabuleiro.finaliza()
self.tabuleiro.inicia(self.fase)
self.mao1.inicia(self.fase)
def remove(self, esta_peca, desta_casa):
"desfaz vencedora se for o caso, retroage o puzzle"
self.tabuleiro.remove(esta_peca, desta_casa)
def recebe(self, peca, casa):
"notificacao inocua de recebimento da peca pela casa da base"
pass
def test_inicializa_dois_jogadores():
jogador_1 = Jogador(impulsivo)
jogador_2 = Jogador(impulsivo)
lista_jogadores = [jogador_1, jogador_2]
tabuleiro = Tabuleiro(propriedades=lista_propriedades(), jogadores=lista_jogadores)
assert tabuleiro.posicao(jogador_1) == 0
assert tabuleiro.posicao(jogador_2) == 0
def tabuleiro_linhas_intercaladas():
tabuleiro = Tabuleiro()
for linha in range(1, len(tabuleiro.matriz) - 1, 2):
for coluna in range(1, len(tabuleiro.matriz[0]) - 1):
tabuleiro.matriz[linha][coluna] = 2
return tabuleiro
def tabuleiro_lotado():
tabuleiro = Tabuleiro()
for linha in range(1, len(tabuleiro.matriz) - 1):
for coluna in range(1, len(tabuleiro.matriz[0]) - 1):
tabuleiro.matriz[linha][coluna] = 2
return tabuleiro
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 tabuleiro_quase_cheio():
tabuleiro = Tabuleiro()
for linha in range(1, len(tabuleiro.matriz) - 1):
if linha != 8:
for coluna in range(1, len(tabuleiro.matriz[0]) - 1):
tabuleiro.matriz[linha][coluna] = 2
return tabuleiro
def __init__(self, jogador1, jogador2, debug=False):
self.tabuleiro = Tabuleiro(VariaveisGlobais.TABULEIRO_INICIAL)
self.jogador1 = jogador1
self.jogador2 = jogador2
self.turnoJogador1 = True
self.debug = debug
def __init__(self):
self.tabuleiro = Tabuleiro()
self._atualizacao = True
self._escape = False
self._promocao = None
self._click = None
self._qsize = 0, 0
self.movimento: tp.movements | None = None
def hillClimb():
tabuleiro = gerarTabuleiro()
while (1):
vizinho = Tabuleiro()
vizinho.tabuleiro = deepcopy(tabuleiro.tabuleiro)
moverUmaRainha(vizinho)
if (vizinho.custo >= tabuleiro.custo):
return tabuleiro
tabuleiro = vizinho
def __init__(self, jogador):
self.tamanho = 3 # tamanho do tabuleiro 3x3
self.jogador = jogador # peça correspondente ao jogador
self.maquina = Tabuleiro.XIS # peça correspondente à jogador
if jogador == Tabuleiro.XIS:
self.maquina = Tabuleiro.BOLA
self.tabuleiro = Tabuleiro(
self.tamanho) # tabuleiro do jogo, alterado a cada jogada
self.arvore = Jogada(self.tabuleiro, None,
self.maquina) # arvore de jogadas
def gerarTabuleiro():
tabuleiro = Tabuleiro()
tabuleiro.tabuleiro = [['_' for x in range(8)] for x in range(8)]
for coluna in range(8):
linha = randint(0, 7)
tabuleiro.tabuleiro[linha][coluna] = "Q"
tabuleiro.custo = calculaColisoes(tabuleiro.tabuleiro)
return tabuleiro
def __init__(self,
jogadorHumano,
jogador,
turnoJogador1=True,
debug=False):
self.tabuleiro = Tabuleiro(VariaveisGlobais.TABULEIRO_INICIAL)
self.jogadorHumano = jogadorHumano
self.jogador = jogador
self.turnoJogador1 = turnoJogador1
self.debug = debug
class Main:
def __init__(self):
self.tabuleiro = Tabuleiro()
def jogar(self):
while(not self.tabuleiro.jogo_acabou()):
self.tabuleiro.imprimir()
self.processar_jogada()
self.tabuleiro.imprimir()
print
print
print self.tabuleiro.mensagem_final()
def processar_jogada(self):
jogada = sys.stdin.readline()
regex = re.search("^([ABC])([123])$", jogada)
if(not regex): return self.erro_jogada()
x = bytearray(regex.group(1))[0] - 65
y = int(regex.group(2)) - 1
if(not self.tabuleiro.preencher(x, y)):
print "Quadrado já está preenchido!"
def erro_jogada(self):
print "Erro na jogada: jogada deve ser A1, A2, B2, etc."
def test_move_jogador_um_passo_com_dado():
jogador = Jogador(impulsivo)
tabuleiro = Tabuleiro(propriedades=lista_propriedades(), jogadores=[jogador])
assert tabuleiro.posicao(jogador) == 0
random.seed(2)
passo = dado()
tabuleiro.movimenta(jogador, passos=passo)
assert tabuleiro.posicao(jogador) == 1
tabuleiro.movimenta(jogador, passos=dado())
assert tabuleiro.posicao(jogador) == 2
random.seed()
def __init__(self, posicoes, objetivo):
self.posicoes = posicoes
self.objetivo = objetivo
self.tabuleiro = Tabuleiro(posicoes, self.objetivo)
self.visitados = []
self.paraVisitar = []
self.tabuleiroFinal = self.algoritimoA()
class MeuSemaforo:
# Tabuleiro
jogo = Tabuleiro()
# controlador começando aberto
controle = Semaphore(1)
# Joga um peca X ou O no tabuleiro
def jogarPeca(self, nome, jogador):
self.controle.acquire()
if (self.jogo.existeVencedor()):
self.controle.release()
return
print("\n" + nome + " " + self.jogo.pecas[jogador] + " pensando....")
# verificar se pode jogar
x = random.randrange(0, 2)
y = random.randrange(0, 2)
while not self.jogo.posicaoValida(x, y, jogador):
x = random.randrange(0, 3)
y = random.randrange(0, 3)
time.sleep(1)
print("Jogada do " + nome + " " + self.jogo.pecas[jogador])
self.jogo.colocarPeca(x, y, jogador)
# Finalizando area de excução da thread atual para a proxima usar
self.controle.release()
print(self.jogo.imprimir())
def main():
tabuleiro = Tabuleiro()
estadoinicial = Estado(tabuleiro, None, 0, 'Max')
listaEsperada = estadoinicial.possiveisJogadas()
for estado in listaEsperada:
estado.tabuleiro.imprimetabuleiro()
print(estadoinicial.verificaEstadoFinal())
def tabuleiro_celulas_intercaladas():
tabuleiro = Tabuleiro()
ultima_linha_de_celulas = len(tabuleiro.matriz) - 2
for coluna in range(1, len(tabuleiro.matriz[0]) - 1):
tabuleiro.matriz[ultima_linha_de_celulas][coluna] = 2
for linha in range(0, ultima_linha_de_celulas):
if linha % 2 == 0:
primeira_coluna = 2
else:
primeira_coluna = 1
for coluna in range(primeira_coluna, len(tabuleiro.matriz[0]) - 1, 2):
tabuleiro.matriz[linha][coluna] = 2
return tabuleiro
def main():
numero_de_jogadas = 0
tabuleiro = Tabuleiro(6, 7)
jogador_atual = game_input.solicitarJogadorIniciante()
jogo_nao_acabou = True
print "\n", tabuleiro
while jogo_nao_acabou:
print "Vez do jogador", jogador_atual
if jogador_atual is Jogador.COMPUTADOR:
start = time.time()
jogada = Nodo(copy.deepcopy(tabuleiro)).jogar();
end = time.time()
print "tempo: ", end - start
tabuleiro.inserirPeca(jogada.coluna, jogador_atual)
else:
coluna = game_input.solicitarColuna()
linha = tabuleiro.inserirPeca(coluna, jogador_atual)
jogada = Jogada(linha, coluna, jogador_atual)
numero_de_jogadas += 1
jogada_vitoriosa = tabuleiro.verificarVitoria(jogada)
Nodo.tamanho_colunas[jogada.coluna] +=1
# print "linha: ", str(jogada.linha + 1)
print "coluna: ", str(jogada.coluna + 1)
print "\n", tabuleiro
if jogada_vitoriosa:
if jogador_atual is Jogador.COMPUTADOR:
print "Perdeu playboy!!"
else:
print "Voce ganhou, mas isso nao acaba aqui. Te pego na saida"
jogo_nao_acabou = False
else:
if numero_de_jogadas is 42:
print "Empate!"
jogo_nao_acabou = False
jogador_atual = Jogador.HUMANO if jogador_atual is Jogador.COMPUTADOR else Jogador.COMPUTADOR
def test_se_jogador_volta_ao_inicio():
jogador = Jogador(impulsivo)
tabuleiro = Tabuleiro(propriedades=lista_propriedades(), jogadores=[jogador])
assert tabuleiro.posicao(jogador) == 0
tabuleiro.movimenta(jogador, passos=25)
assert tabuleiro.posicao(jogador) == 5
assert jogador.saldo == 400
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 simulatedAnnealing():
Ti = 100
Tf = 0.1
taxa = 0.8
S0 = gerarTabuleiro() #Solução Inicial
S = S0 #(Solucao Atual)
n_iteracoes = 50
melhor_solucao = S0
T = Ti
while (T > Tf):
for x in range(n_iteracoes):
vizinho = Tabuleiro()
vizinho.tabuleiro = deepcopy(S.tabuleiro)
moverUmaRainha(vizinho)
deltaCusto = vizinho.custo - S.custo
if deltaCusto < 0:
S = vizinho
else:
numero_random = uniform(0, 1)
## Aceita estados piores
## A função exp diminue conforme T diminue
if numero_random < math.exp(-deltaCusto / T):
S = vizinho
if (S.custo < melhor_solucao.custo):
melhor_solucao = S
T = taxa * T
return melhor_solucao
def test_move_jogador_um_passo_com_propriedade():
jogador = Jogador(impulsivo)
propriedade = Propriedade(preco=100)
tabuleiro = Tabuleiro(propriedades=[propriedade], jogadores=[jogador])
assert tabuleiro.posicao(jogador) == 0
tabuleiro.movimenta(jogador, passos=1)
assert tabuleiro.posicao(jogador) == 1
assert jogador.saldo == 200
assert propriedade.proprietario == jogador
def run(self):
tabuleiro = self.tabuleiro #Copia o tabuleiro
tabuleiro_atual = self.tabuleiro.rainhas[:] #Copia a lista de rainhas
achou_solucao = False
if Tabuleiro.calculaConflitos(
tabuleiro_atual
) == 0: #Testa pra saber se o tabuleiro já é uma solução
print("Solução:")
print(Tabuleiro.show(tabuleiro_atual))
achou_solucao = True
return
for k in range(0, 1000000000):
#Realiza a pertubação em uma iteração
tabuleiro.permutacao(
tabuleiro.rainhas
) #Vai para a próxima posição vizinha aleatória
proximo_tabuleiro = tabuleiro.rainhas[:] #guarda as novas posições das rainhas
delta = Tabuleiro.calculaConflitos(
proximo_tabuleiro) - Tabuleiro.calculaConflitos(
tabuleiro_atual)
prob = 0
if (delta > 0):
prob = exp(
(-delta) / (self.temperatura)) #Cálculo da probabilidade
#Teste de aceitação de uma nova solução
# Tomada de decisao com base na movimentação(se é boa) e na probabilidade
if delta < 0 or random.uniform(0, 1) < prob:
tabuleiro_atual = proximo_tabuleiro[:]
#Testa se não existem conflitos entre as rainhas, solução encontrada!
if Tabuleiro.calculaConflitos(tabuleiro_atual) == 0:
#print Solução
print("Solução:")
print(Tabuleiro.show(tabuleiro_atual))
achou_solucao = True
break
#Redução geometrica da Temperatura
self.temperatura *= self.variacao
#caso ao final de todo o Loop principal se encerre sem solução
if achou_solucao == False:
print("Não foi possivel encontrar solução.")
"""
Created on Sun Jun 16 23:06:45 2019
@author: nocera
"""
from tabuleiro import Tabuleiro
from gerenciadorDeTabuleiros import GerenciadorDeTabuleiros
from variaveisGlobais import VariaveisGlobais
# Tester calcula Movimentos possiveis
# TESTE 1
print("Comecando teste 1:")
print("Tabuleiro inicial teste 1:")
tabuleiro = Tabuleiro(VariaveisGlobais.TABULEIRO_TESTE_7)
tabuleiro.printaTabuleiro()
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
print("Printando tabuleiros possiveis:")
if (not listaTabuleiros is None and len(listaTabuleiros) > 0):
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
tabuleiro.printaTabuleiro()
else:
lista_jogadores_completa = lista_jogadores_csv(caminho_ficheiro)
lista_jogadores = [jogador1, jogador2] #apenas e possivel criar esta lista depois de definir o jogador1 e jogador2, dai nao estar perto das outras variaveis
jogador1.nome = str(jogador1.nome)
jogador1.token = str(jogador1.token)
jogador1.pontos = int(jogador1.pontos)
jogador1.jogos = int(jogador1.jogos)
jogador2.nome = str(jogador2.nome)
jogador2.token = str(jogador2.token)
jogador2.pontos = int(jogador2.pontos)
jogador2.jogos = int(jogador2.jogos)
print("\nA qualquer momento pode desistir ao escrever \"desisto\" como coordenada.\n")
tabuleiro = Tabuleiro() #construir o tabuleiro
print(tabuleiro) #mostrar o tabuleiro vazio
quantidade_jogadores = len(lista_jogadores_completa)
i = 0 #inicio do contador while (vai simular um ciclo for, explicado noutro comentario mais a baixo)
while i < 9: #foi necessario usar um ciclo while porque nao era possivel alterar o i do for i in... dentro do ciclo for
num_jogador = abs(num_jogador) #para ir alternando de jogadores
validade = False
while not validade: #determinar se a jogada pode acontecer para passar para o proximo jogador
jogada = input("\nJogador {}: Escreva coordenadas (Ex: A1) > ".format(lista_jogadores[num_jogador].nome))
if jogada in JOGADASVALIDAS: #verificar se e uma coordenada
coluna = jogada[0]
linha = jogada[1]
linha = int(linha)
j2token = str(input("Introduza um token para o representar no jogo: "))
if j1token == j2token:
print("Esse token ja esta a ser utilizado por outro jogador, escolha outro: ")
else:
break
jogador1 = Jogador(j1nome, j1token)
jogador2 = Jogador(j2nome, j2token)
print("\nA qualquer momento pode desistir ao escrever 'desisto' como coordenada.\n")
"""
jogador1 = Jogador("a", "a")
jogador2 = Jogador("b", "b")
final = Tabuleiro() #vai fazer o tabuleiro pela primeira vez
print(final) #e imprimi-lo
for i in range(1,10): #ciclo for que nos vai facilitar a descobrir empates
if i != 9: #serve para saber se nao estamos na jogada 10(ou seja, se tivermos a certeza que ainda nao houve empate)
validade = False
while validade == False:#com este ciclo vamos introduzindo as coordenadas ate colocarmos uma correta
if i % 2 != 0: #para verificar se quem vai jogar é o jogador 1
jogada = input("\nJogador 1: Escreva coordenadas (Ex: A1) > ")
if jogada in playsvalidas:
jogar(jogada, final, jogador1.token, jogador1.nome)
else: #se não for o jogador1, só pode ser o jogador 2
jogada = input("\nJogador 2: Escreva coordenadas (Ex: A1) > ")
if jogada in playsvalidas:
jogar(jogada, final, jogador2.token, jogador2.nome)
else: #caso o jogo chegue à 10ª jogada, o programa acaba
print("O jogo terminou num empate.")
from tabuleiro import Tabuleiro
from jogador import Jogador
from propriedade import Propriedade, SEM_DONO
tabuleiro = Tabuleiro()
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 test_proxima_posicao_ultima_casa():
POS = 20
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 >= 1 and \
proxima_posicao <= 6
def test_perde_propriedade():
jogador1 = Jogador("Manuel")
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
grey = (128, 128, 128)
MOUSE_LEFT = 1
MOUSE_RIGHT = 3
#Telas para vencedores
overmelhovenceu = pygame.image.load("Vitoriadovermelho.jpg")
overdevenceu = pygame.image.load("Vitoriadoverde.jpg")
# inicializando o pygame e a tela
pygame.init()
playSurface = pygame.display.set_mode(size)
playSurface.fill(grey)
pygame.display.set_caption("Chinese Checkers")
tabuleiro = Tabuleiro()
tabuleiro.desenha_estrela(playSurface)
tabuleiro.desenha_estrela(playSurface)
jogador_vermelho = "vermelho"
jogador_verde = "verde"
# setando p sempre o jogador verde comecar
jogador_atual = jogador_verde
# inicializando o botao de passar turno
botao_passar_turno = Botao("Passar a vez", (0, 0, 0), blue)
botao_passar_turno.desenha_botao(playSurface, 150, 450, 200, 50)
# inicializando o botao de enviar mensagens
send_mensage_button = Botao("Enviar", (255, 1, 127), white)
send_message_button_rect = send_mensage_button.desenha_botao(
playSurface, 920, 490, 200, 50)
# inicializando o botao de desistir , mas nao ta funcionando ainda
server_log = pygame_gui.elements.UITextBox(relative_rect=pygame.Rect(
(205, 20), (270, 39)),
html_text='',
manager=manager2)
button = pygame_gui.elements.UIButton(relative_rect=pygame.Rect((730, 25),
(180, 30)),
text='Reiniciar Partida',
manager=manager)
id = client.nick
turno = client.getTurno()
screen.fill([203, 237, 216])
clock = pygame.time.Clock()
table = Tabuleiro(screen)
table.desenha_tabuleiro(mapa)
table.distribuir_pecas(mapa)
client.setMapeamentopeca(mapa.mapeamento_peca)
client.server_backup(mapa.mapeamento_peca)
manager.draw_ui(screen)
manager2.draw_ui(screen)
pygame.display.flip()
running = True
ganhador = False
recieve = len(client.chat_history)
click_cont = 0
while running:
if turno == 0:
def build_tabuleiro(self,gui):
"""Constroi o tabuleiro onde as pecas sao jogadas."""
self.tabuleiro =Tabuleiro(gui,self)
def __init__(self):
self.tabuleiro = Tabuleiro()
