def test_partida(self):
p = self.test_info_jugador_nombre()
ficha1 = ArrayFichas().sacar_ficha(0) # FICHA IGLESIA
ficha2 = ArrayFichas().sacar_ficha(16) # ficha tipo 6
ficha3 = ArrayFichas().sacar_ficha(12) # tipo 4
p.actualizar_zonas(ficha2, (7, 4))
p.colocar_seguidor(ficha2, p.jugadores[0], 10)
p.tablero.insertar(ficha2, 7, 4)
p.algoritmo_relleno(7, 4)
p.pintada_false()
self.test_pasar_turno()
p.actualizar_zonas(ficha3, (7, 6))
p.colocar_seguidor(ficha3, p.jugadores[1], 12)
p.tablero.insertar(ficha3, 7, 6)
p.algoritmo_relleno(7, 6)
p.pintada_false()
p.actualizar_zonas(ficha1, (7, 5))
p.tablero.insertar(ficha1, 7, 5)
p.algoritmo_relleno(7, 5)
p.pintada_false()
expected = """P1 P1 P1
A2 P1 Ar
A2 P1 Ar
A2 P1 Ar
P1 P1 P1
"""
self.assertEqual(expected, p.tablero.tablero[7][4].imprimir())
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_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_todas_pos_validas(self):
t = Tablero()
ficha1 = ArrayFichas().sacar_ficha(0) #Todo aldea
t.insertar(ficha1, 2, 2)
ficha2 = ArrayFichas().sacar_ficha(22) #Solo un lado con aldea
expected = [[3, 2]]
self.assertEqual(expected, t.todas_pos_validas(ficha2))
def test_es_valida(self):
t = Tablero()
ficha1 = ArrayFichas().sacar_ficha(0) #Todo aldea
t.insertar(ficha1, 1, 1)
ficha2 = ArrayFichas().sacar_ficha(70) #tipo19
ficha3 = ArrayFichas().sacar_ficha(1) #tipo2
self.assertFalse(t.es_valida(ficha2, 1, 2))
self.assertTrue(t.es_valida(ficha3, 1, 2))
def test_sacar_medio_ficha(self):
f = ArrayFichas().sacar_ficha(25)
expected = """A1 A1 A1
A1 A1 A1
A1 A1 A1
A1 A1 A1
P2 C3 P4
"""
self.assertEqual(f.imprimir(), expected)
def test_sacar_ult_ficha(self):
f = ArrayFichas().sacar_ficha(70)
expected = """P2 P2 P2
P2 I1 P2
P2 I1 P2
P2 I1 P2
P2 P2 P2
"""
self.assertEqual(f.imprimir(), expected)
def test_comprobacion_ficha_valida(self):
t = Tablero()
ficha1 = ArrayFichas().sacar_ficha(
21) # tipo7 Aldea por arriba y el resto pradera
t.insertar(ficha1, 2, 2)
ficha2 = ArrayFichas().sacar_ficha(
24) # tipo8 Aldea por 3 lados y camino por abajo
ficha3 = ArrayFichas().sacar_ficha(48) #tipo 15Todo camino
self.assertTrue(t.comprobacion_ficha_valida(ficha2))
def __init__(self):
#Construye una matriz y la rellena con fichas de tipo vacia.
#La matriz funciona con un margen de una fila por cada lado
self.w = 10
self.h = 10
ficha = ArrayFichas().vacia
inicial = ArrayFichas().inicial
self.tablero = [[ficha for y in range(0, self.w)]
for x in range(0, self.h)]
self.tablero[int(round(
(self.w - 1) / 2.0))][int(round((self.h - 1) / 2.0))] = inicial
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 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_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_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_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_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 test_computar_puntos_camino(self):
p=Partida()
l = Logica()
l.array_caminos.append([(1,2), (2,2), (3,2)]) #camino de las fichas
p.info_jugadores(2,"Adrian","rojo","Alberto","verde")
fichaC1 = ArrayFichas().sacar_ficha(49) #tipo15
fichaC2 = ArrayFichas().sacar_ficha(52) #tipo17
fichaC3 = ArrayFichas().sacar_ficha(46) #tipo16
p.colocar_seguidor(fichaC1,p.jugadores[1],7)
p.tablero.insertar(fichaC1, 1, 2)
p.tablero.insertar(fichaC2, 2, 2)
p.tablero.insertar(fichaC3, 3, 2)
expected=4
puntos = l.computar_puntos_turno(p.tablero,(2,2),p.jugadores)
self.assertEqual(p.jugadores[1].puntuacion,expected)
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)
def test_coloca_ficha_con_A_sinUnion(self):
p = Partida()
l = Logica()
l.array_aldeas.append([(4,4), (4,5)])
l.array_aldeas.append([(1,1), (2,1), (3,1)])
ficha1 = ArrayFichas().sacar_ficha(69) #tipo19
p.tablero.insertar(ficha1, 2, 4)
ficha2 = ArrayFichas().sacar_ficha(70) #tipo19
p.tablero.insertar(ficha2, 2, 2)
mi_ficha = ArrayFichas().sacar_ficha(18) #tipo6
p.tablero.insertar(mi_ficha, 2, 3) #coloco mi_ficha entre la ficha1 y la ficha2
l.coloca_ficha_con_A(p.tablero, (2,3))
expected = [(2,3)]
self.assertEqual(expected, l.dame_aldea((2,3)))
def insertar_ficha_tablero(self):
t = Tablero()
ficha = ArrayFichas().tipo1
t.insertar(ficha, 2, 2)
expected = """A0 A0 A0
A0 A1 A0
A0 A0 A0
A0 A0 A0
A0 A0 A0
"""
self.assertEqual(expected, t.tablero[2][2].imprimir())
def test_algoritmo_relleno(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.tablero.insertar(ficha1, 6, 5)
p.actualizar_zonas(ficha2, (6, 6))
p.colocar_seguidor(ficha2, jugador, 13) #3 de arriba
p.tablero.insertar(ficha2, 6, 6)
p.algoritmo_relleno(6, 6)
p.pintada_false()
expected = """A2 A2 A2
P4 C1 P4
C1 C1 C1
Pr C1 Pr
Pr Pr Pr
"""
self.assertEqual(expected, p.tablero.tablero[5][5].imprimir())
def test_coloca_ficha_con_A_aldeasInconexas(self):
p = Partida()
l = Logica()
l.array_aldeas.append([(2,2)]) #aldea de la ficha1
l.array_aldeas.append([(2,4)]) #aldea de la ficha2
l.array_aldeas.append([(1,1), (2,1), (3,1)])
l.array_aldeas.append([(4,3)])
ficha1 = ArrayFichas().sacar_ficha(1) #tipo2
p.tablero.insertar(ficha1, 2, 2)
ficha2 = ArrayFichas().sacar_ficha(2) #tipo2
p.tablero.insertar(ficha2, 2, 4)
mi_ficha = ArrayFichas().sacar_ficha(5) #tipo3
p.tablero.insertar(mi_ficha, 2, 3) #coloco mi_ficha entre la ficha1 y la ficha2
l.coloca_ficha_con_A(p.tablero, (2,3))
expected = [(2,4), (2,3), (2,2)]
self.assertEqual(expected, l.dame_aldea((2,3)))
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_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 es_bifurcacion_y_aldea(self, ficha):
return ArrayFichas().type(ficha) == 13
def test_algoritmo_relleno2(self):
p = Partida()
jugador = Jugador('Adrian', 'rojo')
jugador1 = Jugador('Alberto', 'verde')
ficha1 = ArrayFichas().sacar_ficha(70) # FICHA IGLESIA
ficha2 = ArrayFichas().sacar_ficha(20) # tipo7
ficha3 = ArrayFichas().sacar_ficha(21) # tipo7
ficha4 = ArrayFichas().sacar_ficha(24) #tipo8
ficha5 = ArrayFichas().sacar_ficha(47) #tipo16
ficha6 = ArrayFichas().sacar_ficha(51) #tipo18
ficha7 = ArrayFichas().sacar_ficha(52) #tipo18
ficha8 = ArrayFichas().sacar_ficha(
46) # tipo 15 --- bifurcacion 4 caminos
ficha9 = ArrayFichas().sacar_ficha(18) # tipo 6
ficha9.girar()
ficha9.girar()
ficha4.girar()
ficha4.girar()
ficha4.girar()
ficha5.girar()
ficha5.girar()
ficha6.girar()
ficha8.girar()
ficha8.girar()
ficha2.girar()
ficha2.girar()
ficha3.girar()
p.tablero.insertar(ficha6, 5, 6)
p.tablero.insertar(ficha8, 5, 4)
p.tablero.insertar(ficha4, 5, 3)
p.tablero.insertar(ficha7, 4, 4)
p.tablero.insertar(ficha1, 6, 5)
p.tablero.insertar(ficha2, 7, 5)
p.actualizar_zonas(ficha3, (7, 6))
p.colocar_seguidor(ficha3, jugador, 13)
p.tablero.insertar(ficha3, 7, 6)
p.algoritmo_relleno(7, 6)
p.pintada_false()
p.actualizar_zonas(ficha9, (4, 5))
p.colocar_seguidor(ficha9, jugador1, 7)
p.tablero.insertar(ficha9, 4, 5)
p.algoritmo_relleno(4, 5)
p.pintada_false()
expected = """Av Av Av
P4 C1 P4
C1 C1 C1
Pr C1 Pr
Pr Pr Pr
"""
self.assertEqual(expected, p.tablero.tablero[5][5].imprimir())
def es_bifurcacion(self, ficha):
return ArrayFichas().type(ficha) in [15, 16]
def es_doble_limite_aldea(self, ficha):
return ArrayFichas().type(ficha) in [5, 6]
def es_limite_camino(self, ficha):
return ArrayFichas().type(ficha) in [8, 10, 13, 15, 16]
def test_dame_ficha(self):
t = Tablero()
ficha1 = ArrayFichas().sacar_ficha(21) # tipo7
t.insertar(ficha1, 2, 2)
expected = ArrayFichas().type(ficha1)
self.assertEqual(expected, ArrayFichas().type(t.dame_ficha((2, 2))))
def contiene_camino_y_aldea(self, ficha):
return ArrayFichas().type(ficha) in [8, 9, 11, 12, 14]
