def test_selecionar_tabuleiro(self):
BD.limpar_tabuleiro(conexao_bd)
BD.adicionar_tabuleiro(conexao_bd, 1, 2, 3, False, True)
x = BD.selecionar_tabuleiro(conexao_bd, peao=1)
r = {
'id': 1,
'pos': 2,
'pos_inicial': 3,
'eh_inicio': False,
'eh_finalizado': True
}
self.assertDictEqual(r, x, 'selecionando tabuleiro')
x = BD.selecionar_tabuleiro(conexao_bd, pos=2)
self.assertDictEqual(x[0], r, 'selecionando tabuleiro 2')
def mover_peao(c, id_peao, mov):
"""
Move o peao. Admite-se que a movimentacao ja foi valida. Retorna:
posicao se o movimento foi feito com sucesso,
-1 se o id nao existir,
-2 se o peao chegou na ultima casa.
OBS: nunca retornara a posicao da ultima casa.
"""
# i = _achar_peao(id_peao)
# if i == -1:
# return -1
# p = tabela_peoes[i]
p = baseDados.selecionar_tabuleiro(c, peao=id_peao)
if p == -1:
return -1
pos = p['pos']
pos_inicial = p['pos_inicial']
time = pos_inicial // 100 # diz se o time ("cor") eh 1, 2, 3 ou 4.
if p['eh_inicio']: # ele vai colocar na casa de saida
p['eh_inicio'] = False
new_pos = 13 * (time - 1)
p['pos'] = new_pos
baseDados.modificar_tabuleiro(c, id_peao, p['pos'], p['pos_inicial'],
p['eh_inicio'], p['eh_finalizado'])
return new_pos
if pos >= 1000: # reta final. Confere se o peao finalizou
new_pos = pos + mov
p['pos'] = new_pos
if new_pos % 1000 == 5:
p['eh_finalizado'] = True
baseDados.modificar_tabuleiro(c, id_peao, p['pos'],
p['pos_inicial'], p['eh_inicio'],
p['eh_finalizado'])
return -2
baseDados.modificar_tabuleiro(c, id_peao, p['pos'], p['pos_inicial'],
p['eh_inicio'], p['eh_finalizado'])
return new_pos
# primeiro calcula a casa para entrar na reta final
casa_entrada = (13 *
(time - 1) + 50) % 52 # primeira casa + 50, dando a volta
new_pos = (pos + mov) # primeiro vejo sem dar a volta
if pos <= casa_entrada < new_pos: # ele deve entrar na reta final
new_pos = (new_pos - casa_entrada - 1) + time * 1000
else:
new_pos = new_pos % 52 # senao, so corrige a posicao
p['pos'] = new_pos # salva e retorna
baseDados.modificar_tabuleiro(c, id_peao, p['pos'], p['pos_inicial'],
p['eh_inicio'], p['eh_finalizado'])
return new_pos
def acessar_posicao(c, pos):
"""Retorna uma lista dos ids naquela posicao, 0 se a casa for segura."""
if pos in lista_posicao_seguras:
return 0
# pega o id do x da tabela se x esta na posicao 'pos'
# return [x['id'] for x in tabela_peoes if x['pos'] == pos]
return [x['id'] for x in baseDados.selecionar_tabuleiro(c, pos=pos)]
def _achar_peao(c, id_peao):
"""
Recebe um id, retorna suas informacoes, -1 se nao existir.
"""
# for i, p in enumerate(tabela_peoes):
# if p['id'] == id_peao:
# return i
return baseDados.selecionar_tabuleiro(c, peao=id_peao)
def test_modificar_tabuleiro(self):
BD.limpar_tabuleiro(conexao_bd)
BD.adicionar_tabuleiro(conexao_bd, 2, 0, 0, True, False)
x = BD.modificar_tabuleiro(conexao_bd, 2, 10, 20, False, False)
self.assertEqual(x, 0, 'modificando tabuleiro')
x = BD.selecionar_tabuleiro(conexao_bd, peao=2)
r = {
'id': 2,
'pos': 10,
'pos_inicial': 20,
'eh_inicio': False,
'eh_finalizado': False
}
self.assertDictEqual(r, x, 'modificando tabuleiro 2')
def adicionar_peoes(c, lista_ids, lista_posicoes=None):
"""
Recebe uma lista de peoes e uma lista de posicoes atuais e salva na tabela.
Retorna 0 se sucesso,
1 se id repetido,
2 se lista de posicoes invalida,
3 se ja foram acrescentadas todas as cores,
"""
global cores_acrescentadas
# tamanhos de listas diferentes
if lista_posicoes is not None and len(lista_ids) != len(lista_posicoes):
return 2
# ja acrescentaram todas as cores
if cores_acrescentadas == N_CORES:
return 3
# quantidade de um time diferente de quantidade definida de peoes
if len(lista_ids) != N_PEOES:
return 2
for i, id_peao in enumerate(lista_ids):
# for p in tabela_peoes:
# if id_peao == p['id']:
# return 1
if baseDados.selecionar_tabuleiro(c, id_peao) != -1:
return 1
d = dict()
d['id'] = id_peao
d['pos_inicial'] = lista_posicao_iniciais[cores_acrescentadas][i]
if lista_posicoes is not None:
d['pos'] = lista_posicoes[i]
d['eh_finalizado'] = lista_posicoes[i] in lista_posicao_finais
d['eh_inicio'] = lista_posicoes[i] in lista_posicao_iniciais
else:
d['pos'] = d['pos_inicial']
d['eh_finalizado'] = False
d['eh_inicio'] = True
# tabela_peoes.append(d)
baseDados.adicionar_tabuleiro(c, d['id'], d['pos'], d['pos_inicial'],
d['eh_inicio'], d['eh_finalizado'])
cores_acrescentadas += 1
return 0
def escolhe_peao(c, lista):
"""
Retorna o indice do peao selecionado na lista fornecida.
Fica nessa funcao ate o jogador selecionar algum peao.
"""
# lista de posicoes de cada peao
posicoes_lista = [
dict_posicoes[baseDados.selecionar_tabuleiro(c, peao=x)['pos']]
for x in lista
]
while True:
pos = _checa_eventos()
if pos is not None: # o mouse foi clicado
x, y = pos # posicao do mouse
for i, pos1 in enumerate(posicoes_lista):
x1, y1 = pos1 # posicao do peao
x1 += 280 # offset do canto da tela (deve ser corrigido se alterar as posicoes
if x1 <= x <= x1 + 48 and y1 <= y <= y1 + 48:
return i
def reiniciar_peao(c, id_peao):
"""
Realoca o peao para a posicao inicial, reiniciando seus dados.
0 se sucesso,
-1 se nao houver esse id.
"""
# i = _achar_peao(id_peao)
# if i == -1:
# return -1
p = baseDados.selecionar_tabuleiro(c, peao=id_peao)
if p == -1:
return -1
# p = tabela_peoes[i]
p['pos'] = p['pos_inicial']
p['eh_finalizado'] = False
p['eh_inicio'] = True
baseDados.modificar_tabuleiro(c, id_peao, p['pos'], p['pos_inicial'],
p['eh_inicio'], p['eh_finalizado'])
return 0
def movimentacao_possivel(c, id_peao, mov):
"""
Retorna se eh possivel movimentar o peao.
0 se for possivel,
1 se impossivel,
2 se finalizado
-1 se nao existir esse id.
"""
# i = _achar_peao(id_peao)
# if i == -1:
# return -1
# p = tabela_peoes[i]
p = baseDados.selecionar_tabuleiro(c, peao=id_peao)
if p == -1:
return -1
pos = p['pos']
eh_inicio = p['eh_inicio']
eh_finalizado = p['eh_finalizado']
if eh_finalizado or (pos >= 1000
and pos % 1000 == 5): # se ele ja acabou o jogo
# essa verificacao da posicao novamente foi colocada
# pois um fechamento indevido pode acabar não salvando o estado do peao. Por isso, eh uma redundancia
return 2
if eh_inicio: # se ele esta na base ainda
return 0 if mov == 6 else 1 # se nao tirou 6, nao pode se mover
if pos >= 1000: # se esta nas casas finais
x = 5 - (pos % 1000)
return 1 if mov > x else 0 # se mov > quanto falta, nao pode se mover
# em qualquer outro caso, o peao pode ser movido
return 0
def _atualiza_peao(c, i):
"""Recebe um id, e atualiza o cache interno."""
p = baseDados.selecionar_tabuleiro(c, peao=i)
dict_peoes[i][1] = p['pos']
def test_limpando_tabuleiro(self):
BD.adicionar_tabuleiro(conexao_bd, 99, 0, 0, False, False)
x = BD.limpar_tabuleiro(conexao_bd)
self.assertEqual(0, x, 'limpando tabuleiro')
x = BD.selecionar_tabuleiro(conexao_bd, 99)
self.assertEqual(-1, x, 'limpando tabuleiro 2')
