def partidaJogadores(funcaoJogador1, funcaoJogador2, numPartidas, log):
contEmpate = 0
cont1 = 0
cont2 = 0
for i in range(0, numPartidas):
ambiente = AmbienteTicTacToe(3)
partida = Partida(ambiente)
result = partida.partidaJogoDaVelha(funcaoJogador1, funcaoJogador2,
log)
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 jugarPartida(self):
while True:
opcion = self.menuTipoPartida()
if opcion == 1:
jugador1 = "jugador"
jugador2 = "jugador"
elif opcion == 2:
jugador1 = "jugador"
jugador2 = "cpu"
else:
jugador1 = "cpu"
jugador2 = "cpu"
self.partida = Partida(jugador1, jugador2)
ganador = self.partida.jugar()
self.actualizarStats(ganador)
respuesta = input("¿Quieres volver a jugar? (s/n): ")
while respuesta != "s" and respuesta != "n":
print("respuesta incorrecta")
respuesta = input("¿Quieres volver a jugar? (s/n): ")
if (respuesta == "n"):
break
print("Gracias por jugar!")
print(self.__str__())
def test_info_jugador_color(self):
p = Partida()
p.info_jugadores(2, "Adrian", "azul", "Alberto", "verde")
expected = "azul"
self.assertEqual(p.jugadores[0].color, expected)
expected = "verde"
self.assertEqual(p.jugadores[1].color, expected)
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 test_partida_2(self):
expected = 7
p = Partida()
l = Logica()
l.array_aldeas.append([(5, 5)])
p.info_jugadores(2, "Adrian", "rojo", "Alberto", "verde")
fichaA2 = p.saco.sacar_ficha(5) #tipo3 co
fichaA3 = p.saco.sacar_ficha(21) #tipo7
fichaA2.girar()
fichaA3.girar()
fichaA3.girar()
jugador = p.jugadores[0] #ADRIAN
p.jugar_turno(jugador, [4, 5], "SI", fichaA2, 8)
l.coloca_ficha_con_A(p.tablero, (4, 5))
next_jugador = p.pasar_turno(jugador)
p.jugar_turno(next_jugador, [3, 5], "NO", fichaA3)
l.coloca_ficha_con_A(p.tablero, (3, 5))
next_jugador = p.pasar_turno(next_jugador)
puntos = l.computar_puntos_turno(p.tablero, (3, 5), p.jugadores)
self.assertEqual(p.jugadores[0].puntuacion, expected)
def test_info_jugador_nombre(self):
p = Partida()
p.info_jugadores(2, "Adrian", "rojo", "Alberto", "verde")
expected = "Adrian"
self.assertEqual(p.jugadores[0].nombre, expected)
expected = "Alberto"
self.assertEqual(p.jugadores[1].nombre, expected)
return p
def test_colocar_seg(self):
p = Partida()
ficha = Fichas('A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
'A', 'A', [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
jugador = Jugador('Adrian', 'rojo')
expected = jugador.seguidores - 1
p.colocar_seguidor(ficha, jugador, 0)
self.assertEqual(expected, jugador.seguidores)
def InicializarPartida(self):
print("\n\n *** Inicializando nueva partida... ****\n")
self._userRows = self.ValidData("Filas")
self._userCols = self.ValidData("Columnas")
self._game = Partida(self._userRows, self._userCols)
print("\n\tCreando matriz 1...\n")
print("\tCreando matriz 2...\n")
print("\tCreando matriz resultado, iniciada con 0...\n")
print("\n*** Partida inicializada! ****\n")
self._initGame = True
class Breakout():
"""
Classe principal do jogo.
"""
def __init__(self):
self.JANELA = pygame.display.set_mode((LARGURA_TELA, ALTURA_TELA))
pygame.display.set_caption("Atari Breakout")
def iniciar_jogo(self):
"""
Inicia partida
"""
self.run = True
self.partida_ativa = Partida(1)
def clean(self, janela): # resets screen
janela.fill(WHITE)
def finalizar_jogo(self):
"""
Finaliza Partida
"""
self.run = False
self.partida_ativa = None
def checar_eventos(self):
"""
Trata eventos de entrada e do estado da partida
"""
if (not self.partida_ativa.estado):
self.finalizar_jogo()
for event in pygame.event.get():
# Se o usuário deseja fechar o programa
if event.type == pygame.QUIT:
self.run = False
self.menu = False
def main(self):
"""
Loop principal do jogo
"""
# Variáveis de loop para manter o jogo rodando
self.menu = True
while self.menu:
# TODO MENU
self.iniciar_jogo()
while self.run:
self.clean(self.JANELA)
self.checar_eventos()
self.partida_ativa.update(self.JANELA)
def _jugar_ronda(self):
tipo_partida = self._ronda % 2
partida = Partida(nombre, tipo_partida, self._jugadores)
self._ronda += 1
print('Comienza la partida')
while not partida.partida_terminada:
partida.jugar_turno()
print('La partida ha finalizado. Número de intentos: {}'.format(
partida.intentos()))
respuesta = input('¿Quieres jugar otra ronda? s/n: ')
self._jugar = respuesta.lower() == 's'
def test_jugadores(self):
p = Partida()
p.info_jugadores(5, "Adrian", "azul", "Alberto", "verde", "Sandra",
"rojo", "Diego", "amarillo", "Yo", "negro")
jugs = ["Adrian", "Alberto", "Sandra", "Diego", "Yo"]
cols = ["azul", "verde", "rojo", "amarillo", "negro"]
for n in range(4):
expected = jugs[n]
self.assertEqual(p.jugadores[n].nombre, expected)
expected2 = cols[n]
self.assertEqual(p.jugadores[n].color, expected2)
def test_colocar_seg(self):
p = Partida()
ficha = Fichas('A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
'A', 'A', [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
jugador = Jugador('Adrian', 'rojo')
p.colocar_seguidor(ficha, jugador, 0)
expected = [
"r", "r", "r", "r", "r", "r", "r", "r", "r", "r", "r", "r", "r",
"r", "r"
]
self.assertEqual(expected, ficha.zona_colorear)
def test_pintada_false(self):
p = Partida()
jugador = Jugador('Adrian', 'rojo')
ficha1 = ArrayFichas().sacar_ficha(70) #tipo19
ficha2 = ArrayFichas().sacar_ficha(35) #tipo11
p.actualizar_zonas(ficha1, (6, 5))
p.colocar_seguidor(ficha1, jugador, 13) #3 de arriba
p.tablero.insertar(ficha1, 6, 5)
p.algoritmo_relleno(6, 5)
p.pintada_false()
self.assertEqual(False, p.tablero.tablero[6][5].pintada)
def jugarPartida(self):
while True:
self.partida = Partida()
ganador = self.partida.jugar()
self.actualizarStats(ganador)
respuesta = input("¿Quieres volver a jugar? (s/n): ")
while respuesta != "s" and respuesta != "n":
print("respuesta incorrecta")
respuesta = input("¿Quieres volver a jugar? (s/n): ")
if (respuesta == "n"):
break
print("Gracias por jugar!")
print(self.__str__())
def test_comprueba_Ficha_conCA(self):
todos = []
p = Partida()
l = Logica()
l.array_aldeas.append([(2,2)]) #aldea de la fichaA1
l.array_aldeas.append([(2,4)]) #aldea de la fichaA2
l.array_aldeas.append([(1,1), (2,1), (3,1)])
l.array_caminos.append([(5,2), (5,3)])
l.array_caminos.append([(4,3)]) #camino de la fichaC1
l.array_caminos.append([(3,3)]) #camino de la fichaC2
fichaA1 = ArrayFichas().sacar_ficha(1) #tipo2
p.tablero.insertar(fichaA1, 2, 2)
fichaA2 = ArrayFichas().sacar_ficha(2) #tipo2
p.tablero.insertar(fichaA2, 2, 4)
fichaC1 = ArrayFichas().sacar_ficha(57) #tipo17
fichaC1.girar()
p.tablero.insertar(fichaC1, 4, 3)
fichaC2 = ArrayFichas().sacar_ficha(56) #tipo17
p.tablero.insertar(fichaC2, 3, 3)
mi_ficha = ArrayFichas().sacar_ficha(23) #tipo8
p.tablero.insertar(mi_ficha, 2, 3) #coloco mi_ficha entre la fichaA1 y la fichaA2 y encima de la fichaC2
l.comprueba_ficha(p.tablero, (2,3), mi_ficha)
todos.append(l.dame_aldea((2,3)))
todos.append(l.dame_camino((2,3)))
expected = [[(2,4), (2,3), (2,2)], [(3,3), (2,3)]]
self.assertEqual(expected, todos)
def test_comprueba_Ficha_conC(self):
p = Partida()
l = Logica()
l.array_aldeas.append([(2,2)]) #aldea de la fichaA1
l.array_aldeas.append([(2,4)]) #aldea de la fichaA2
l.array_aldeas.append([(1,1), (2,1), (3,1)])
l.array_caminos.append([(5,2), (5,1)])
l.array_caminos.append([(4,3)]) #camino de la fichaC1
fichaA1 = ArrayFichas().sacar_ficha(1) #tipo2
p.tablero.insertar(fichaA1, 2, 2)
fichaA2 = ArrayFichas().sacar_ficha(2) #tipo2
p.tablero.insertar(fichaA2, 2, 4)
fichaC1 = ArrayFichas().sacar_ficha(57) #tipo17
p.tablero.insertar(fichaC1, 4, 3)
mi_ficha = ArrayFichas().sacar_ficha(57) #tipo17
p.tablero.insertar(mi_ficha, 5, 3) #coloco mi_ficha debajo de la fichaC1
l.comprueba_ficha(p.tablero, (5,3), mi_ficha)
expected = [(4,3), (5,3)]
self.assertEqual(expected, l.dame_camino((5,3)))
def test_coloca_ficha_con_C_unionUnSoloCamino(self):
p = Partida()
l = Logica()
l.array_caminos.append([(2,4)]) #camino de la ficha1
l.array_caminos.append([(1,1), (2,1), (3,1)])
l.array_caminos.append([(4,3)])
ficha1 = ArrayFichas().sacar_ficha(57) #tipo17
ficha1.girar()
ficha1.girar()
ficha1.girar()
p.tablero.insertar(ficha1, 2, 4)
ficha2 = ArrayFichas().sacar_ficha(70) #tipo19
p.tablero.insertar(ficha2, 2, 2)
mi_ficha = ArrayFichas().sacar_ficha(66) #tipo18
mi_ficha.girar()
mi_ficha.girar()
mi_ficha.girar()
p.tablero.insertar(mi_ficha, 2, 3) #coloco mi_ficha entre la ficha1 y la ficha2
l.coloca_ficha_con_C(p.tablero, (2,3))
expected = [(2,4), (2,3)]
self.assertEqual(expected, l.dame_camino((2,3)))
def test_coloca_B2(self):
p=Partida();
l = Logica()
l.array_caminos.append([(2,2)]) #camino de la fichaC1
l.array_caminos.append([(2,2)]) #camino de la fichaC1
l.array_caminos.append([(2,2),(2,1)]) #camino de la fichaC1 y fichaC4
l.array_caminos.append([(2,4)]) #camino de la fichaC2
l.array_caminos.append([(3,3)]) #camino de la fichaC3
l.array_caminos.append([(3,3)]) #camino de la fichaC3
l.array_caminos.append([(3,3)]) #camino de la fichaC3
l.array_caminos.append([(3,3)]) #camino de la fichaC3
fichaC1 = ArrayFichas().sacar_ficha(41) #tipo13
fichaC2 = ArrayFichas().sacar_ficha(60) #tipo18
fichaC3 = ArrayFichas().sacar_ficha(45) #tipo15
fichaC4 = ArrayFichas().sacar_ficha(35) #tipo11
mi_ficha = ArrayFichas().sacar_ficha(48) #tipo16
p.tablero.insertar(mi_ficha, 2, 3)
p.tablero.insertar(fichaC1, 2, 2)
p.tablero.insertar(fichaC2, 2, 4)
p.tablero.insertar(fichaC3, 3, 3)
p.tablero.insertar(fichaC4, 2, 1)
l.comprueba_ficha(p.tablero, (2,3), mi_ficha)
expected=[[(2, 2)], [(2, 2), (2, 1)], [(3, 3)], [(3, 3)], [(3, 3)], [(3, 3), (2, 3)], [(2, 4), (2, 3)], [(2, 2), (2, 3)]]
self.assertEqual(expected, l.array_caminos)
def test_comprueba_Ficha_conDLA(self):
todos = []
p = Partida()
l = Logica()
l.array_aldeas.append([(1,1)]) #aldea de la fichaA1
l.array_aldeas.append([(2,2), (2,3)]) #aldea de la fichaA1 y fichaA2
l.array_aldeas.append([(2,3)]) #aldea de la fichaA1
l.array_aldeas.append([(2,3)]) #aldea de la fichaA3
l.array_aldeas.append([(2,3)]) #aldea de la fichaA3
fichaA1 = ArrayFichas().sacar_ficha(14) #tipo5
p.tablero.insertar(fichaA1, 2, 1)
fichaA2 = ArrayFichas().sacar_ficha(19) #tipo7
fichaA2.girar()
fichaA2.girar()
p.tablero.insertar(fichaA2, 1, 1)
fichaA3 = ArrayFichas().sacar_ficha(16) #tipo6
p.tablero.insertar(fichaA3, 2, 3)
mi_ficha = ArrayFichas().sacar_ficha(5) #tipo3
p.tablero.insertar(mi_ficha, 2, 2)
l.comprueba_ficha(p.tablero, (2,1), fichaA1)
expected = [[(1,1), (2,1)], [(2,1), (2,2), (2,3)], [(2,3)]]
self.assertEqual(expected, l.array_aldeas)
def cargarJuego(self, indice):
br = open(self.RUTAS[indice], "r")
if self.contPartida is self.CANTIDADPARTIDAS:
self.miPartida.pop(0)
self.miPartida.append(Partida(self.totalPartidas))
else:
self.miPartida.append(Partida(self.totalPartidas))
self.contPartida += 1
self.totalPartidas += 1
cantFichas = int(br.readline().replace("\n", ""))
for i in range(cantFichas):
self.miPartida[self.contPartida - 1].crearFicha(
br.readline().replace("\n", ""),
br.readline().replace("\n", ""))
br.close()
def __init__(self,
partida=Partida(),
ganadascpu=0,
ganadasjugador=0,
empatadas=0):
self.partida = partida
self.ganadascpu = ganadascpu
self.ganadasjugador = ganadasjugador
self.empatadas = empatadas
def test_dame_camino_valido_B(self):
todos = []
p = Partida()
l = Logica()
l.array_caminos.append([(4,3), (5,3)])
l.array_caminos.append([(4,3), (3,3), (3,2)])
l.array_caminos.append([(4,3)]) #la bifuracion se encuentra en la posicion (4,3)
expected = [(4,3)]
self.assertEqual(expected, l.dame_camino_valido_B((4,3)))
def test_dame_aldea_valida_DLA(self):
todos = []
p = Partida()
l = Logica()
l.array_aldeas.append([(4,3), (5,3)])
l.array_aldeas.append([(4,3), (3,3), (3,2)])
l.array_aldeas.append([(4,3)]) #la ficha de aldea con DLA se encuentra en la posicion (4,3)
expected = [(4,3)]
self.assertEqual(expected, l.dame_aldea_valida_DLA((4,3)))
def test_constructor_con_valores_iniciales_partida(self):
partida = Partida('python', 2, 'lenguaje de programacion', 'Claudio')
self.assertDictEqual(partida.__dict__, {'_palabra':
['P', 'Y', 'T', 'H', 'O', 'N'],
'_tipo_palabra':
'LENGUAJE DE PROGRAMACION',
'_intentos': 2,
'_nombre_jugador': 'CLAUDIO',
'_palabra_aciertos':
[None, None, None, None, None,
None], })
def test_actualizar_zonas(self):
p = Partida()
jugador = Jugador('Adrian', 'rojo')
ficha1 = ArrayFichas().sacar_ficha(70) #tipo19
ficha2 = ArrayFichas().sacar_ficha(35) #tipo11
p.actualizar_zonas(ficha1, (6, 6))
p.colocar_seguidor(ficha1, jugador, 3) #3 de arriba
p.tablero.insertar(ficha1, 6, 5)
p.actualizar_zonas(ficha2, (6, 6))
p.tablero.insertar(ficha2, 6, 6)
expected = [
"r", "r", "r", 2, 2, 2, "r", 3, 4, "r", 3, 4, "r", "r", "r"
]
self.assertEqual(expected, ficha2.zona_colorear)
def test_camino_no_completado(self):
p=Partida();
l = Logica()
l.array_caminos.append([(2,2), (3,2)]) #camino de las fichas
fichaC1 = ArrayFichas().sacar_ficha(23) #tipo8
fichaC2 = ArrayFichas().sacar_ficha(55) #tipo17
p.tablero.insertar(fichaC1, 2, 2)
p.tablero.insertar(fichaC2, 3, 2)
self.assertFalse(l.camino_completado(p.tablero,l.dame_camino((2,2))))
def test_coloca_ficha_con_B(self):
todos = []
p = Partida()
l = Logica()
#mi_ficha = ArrayFichas().sacar_ficha(44) #tipo15
mi_ficha = ArrayFichas().sacar_ficha(48) #tipo16
p.tablero.insertar(mi_ficha, 2, 3)
l.comprueba_ficha(p.tablero, (2,3), mi_ficha)
expected = [[(2,3)], [(2,3)], [(2,3)]]
self.assertEqual(expected, l.array_caminos)
def test_aldea_no_completada(self):
p=Partida();
l = Logica()
l.array_aldeas.append([(2,2), (2,3)]) #aldea de las fichas
fichaC1 = ArrayFichas().sacar_ficha(14) #tipo5
fichaC2 = ArrayFichas().sacar_ficha(6) #tipo3
p.tablero.insertar(fichaC1, 2, 2)
p.tablero.insertar(fichaC2, 2, 3)
self.assertFalse(l.aldea_completada(p.tablero,l.dame_aldea((2,2))))
def test_aldea_completada2(self):
p=Partida();
l = Logica()
l.array_aldeas.append([(2,2), (2,3), (2,4)]) #aldea de las fichas
fichaA1 = ArrayFichas().sacar_ficha(14) #tipo5
fichaA2 = ArrayFichas().sacar_ficha(5) #tipo3
fichaA3 = ArrayFichas().sacar_ficha(41) #tipo13
fichaA3.girar()
fichaA3.girar()
fichaA3.girar()
p.tablero.insertar(fichaA1, 2, 2)
p.tablero.insertar(fichaA2, 2, 3)
p.tablero.insertar(fichaA3, 2, 4)
self.assertTrue(l.aldea_completada(p.tablero,l.dame_aldea((2,2))))
def test_coloca_ficha_con_B2(self):
p = Partida()
l = Logica()
l.array_caminos.append([(2,4)]) #camino de la fichaC1
fichaC1 = ArrayFichas().sacar_ficha(66) #tipo18
p.tablero.insertar(fichaC1, 2, 4)
#mi_ficha = ArrayFichas().sacar_ficha(44) #tipo15
mi_ficha = ArrayFichas().sacar_ficha(48) #tipo16
p.tablero.insertar(mi_ficha, 2, 3)
l.comprueba_ficha(p.tablero, (2,3), mi_ficha)
expected = [[(2,3)], [(2,4), (2,3)], [(2,3)]]
self.assertEqual(expected, l.array_caminos)