예제 #1
0
    def test_juego_cambia_el_turno_al_dar_pista(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        juego.dar_pista("Número", 1, "Ramón")

        self.assertEqual("Ramón", juego.turno_de())
예제 #2
0
    def test_juego_no_se_agregan_pistas_si_no_se_agrega_carta(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3, Repartidor(self.mezclar_mazo_minimal))
        juego.descartar(0)

        pistas_de = juego.pistas_por_jugador()

        self.assertEqual(4, len(pistas_de["Román"]))
예제 #3
0
    def test_juego_descartar_carta_no_recupera_con_mazo_vacio(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3, Repartidor(self.mezclar_mazo_minimal))
        juego.descartar(0)

        cartas_de = juego.cartas_por_jugador()

        self.assertEqual(4, len(cartas_de["Román"]))
        self.assertFalse((1, "Azul") in cartas_de["Román"])
예제 #4
0
    def test_juego_pista_tiene_que_ser_de_alguien_en_partida(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        self.assertRaises(JuegoPistaSinDestinatarioException, juego.dar_pista,
                          "Color", "Blanco", "Mirtha")
        self.assertEqual(7, juego.pistas_restantes())
        self.assertEqual("Román", juego.turno_de())
예제 #5
0
    def test_juego_no_se_puede_dar_pista_a_si_mismo(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        self.assertRaises(JuegoPistaASiMismoException, juego.dar_pista,
                          "Número", 1, "Román")
        self.assertEqual(7, juego.pistas_restantes())
        self.assertEqual("Román", juego.turno_de())
예제 #6
0
    def test_juego_tipo_de_pista_invalida(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        self.assertRaises(JuegoTipoDePistaInvalidoException, juego.dar_pista,
                          "Sonamos", 1, "Ramón")
        self.assertEqual(7, juego.pistas_restantes())
        self.assertEqual("Román", juego.turno_de())
예제 #7
0
    def test_juego_descartar_tiene_que_ser_carta_de_la_mano(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 5)

        mano_ramon = [carta for carta in juego.cartas_por_jugador()["Román"]]

        self.assertRaises(JuegoDescartaCartaFueraDeManoException,
                          juego.descartar, 10)
        self.assertEqual(mano_ramon, juego.cartas_por_jugador()["Román"])
        self.assertEqual("Román", juego.turno_de())
예제 #8
0
    def test_juego_dar_pista_sobre_numero(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        juego.dar_pista("Número", 1, "Ramón")

        pistas_de = juego.pistas_por_jugador()
        self.assertTrue(all("1" in pistas_de["Ramón"][i] for i in [0, 1]))
        self.assertTrue(all(
            len(pistas_de["Ramón"][i]) == 0 for i in [2, 3, 4]))
예제 #9
0
    def test_juego_dar_pista_sobre_color(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        juego.dar_pista("Color", "Amarillo", "Ramón")

        pistas_de = juego.pistas_por_jugador()
        self.assertTrue(
            all("Amarillo" in pistas_de["Ramón"][i] for i in [0, 2, 4]))
        self.assertTrue(all(len(pistas_de["Ramón"][i]) == 0 for i in [1, 3]))
예제 #10
0
	def test_juego_registra_jugadores(self) -> None:
		juego = Juego.iniciar(jugadores=['Articuno', 'Zapdos'])
		jugadores = juego.jugadores()

		self.assertIn('Articuno', jugadores)
		self.assertIn('Zapdos', jugadores)
		self.assertEqual(2, len(jugadores))
예제 #11
0
 def test_juego_inicia_en_blanco(self) -> None:
     jugadores = ["Román", "Ramón"]
     juego = Juego(jugadores, 3)
     self.assertEqual(0, juego.puntaje())
     self.assertEqual(3, juego.vidas())
     self.assertEqual(7, juego.pistas_restantes())
     self.assertEqual(jugadores, juego.jugadores())
     self.assertEqual("Román", juego.turno_de())
     self.assertFalse(juego.terminado())
예제 #12
0
    def iniciar_juego_en(self, lobby_id: str) -> None:
        lobby = self._lobby_por_lid(lobby_id)

        self._assertLobbyNoVacio(lobby)
        self._assertJuegoNoEstaEnCurso(lobby_id)

        juego = Juego.iniciar(jugadores=lobby.jugadores())
        self._juegos_por_lid[lobby_id] = juego
예제 #13
0
    def test_juego_descartar_carta_recupera_pista(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        juego.dar_pista("Número", 1, "Ramón")
        self.assertEqual(6, juego.pistas_restantes())

        juego.descartar(0)
        self.assertEqual(7, juego.pistas_restantes())
예제 #14
0
    def test_juego_tomar_accion_de_dar_pista(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        accion = {
            'jugador': "Román",
            'accion': 'PISTA',
            'pista_a': "Ramón",
            'tipo': "Color",
            'valor': "Amarillo"
        }

        juego.tomar_accion(accion)

        pistas_de = juego.pistas_por_jugador()
        self.assertTrue(
            all("Amarillo" in pistas_de["Ramón"][i] for i in [0, 2, 4]))
        self.assertTrue(all(len(pistas_de["Ramón"][i]) == 0 for i in [1, 3]))
예제 #15
0
	def test_jugadores_tienen_cartas_distintas(self) -> None:
		juego = Juego.iniciar_en_nivel(jugadores=['Articuno', 'Zapdos'], nivel=3)
		cartas_de = juego.cartas_por_jugador()

		cartas_todas = [
			carta for jug, cartas in cartas_de.items()
			for carta in cartas
		]

		self.assertUnique(cartas_todas)
예제 #16
0
    def test_juego_se_descartan_las_pistas_junto_con_la_carta(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        juego.dar_pista("Número", 1, "Ramón")
        juego.descartar(0)

        pistas_de = juego.pistas_por_jugador()
        self.assertTrue(len(pistas_de["Ramón"][-1]) == 0)
예제 #17
0
    def test_juego_tienen_que_haber_pistas_disponibles(self) -> None:
        jugadores = ["Román", "Ramón"]
        juego = Juego(jugadores, 3,
                      Repartidor(self.mezclar_mazo_minimal_mezcladito))

        for _ in range(3):
            juego.dar_pista("Número", 1, "Ramón")
            juego.dar_pista("Número", 1, "Román")
        juego.dar_pista("Número", 1, "Ramón")

        self.assertRaises(JuegoSinPistasDisponiblesException, juego.dar_pista,
                          "Número", 1, "Román")
        self.assertEqual(0, juego.pistas_restantes())
        self.assertEqual("Ramón", juego.turno_de())
예제 #18
0
def crear_juego_test(
	jugadores : Optional[List[str]] = None,
	mesa : Optional[int] = None,
	nivel : Optional[int] = None,
	vidas : Optional[int] = None,
	cartas_por_jugador : Optional[Dict[str, List[int]]] = None,
	premios_vidas : Optional[List[int]] = None
) -> Juego:

	return Juego(
		jugadores = ordefault(jugadores, ['Articuno', 'Zapdos']),
		mesa = ordefault(mesa, 0),
		nivel = ordefault(nivel, 1),
		vidas = ordefault(vidas, 3),
		cartas_por_jugador = ordefault(cartas_por_jugador, {
			'Articuno': [1, 3],
			'Zapdos': [2, 4]
		}),
		premios_vidas = ordefault(premios_vidas, [3, 6, 9])
	)
예제 #19
0
	def test_juego_sube_nivel_correctamente(self) -> None:
		juego = Juego.iniciar_en_nivel(jugadores=['Articuno', 'Zapdos'], nivel=3)
		self.assertEqual(3, juego.nivel())
예제 #20
0
    def iniciar_juego_en(self, lobby_id: str) -> None:
        self._validar_lobby_existente(lobby_id)
        self._validar_partida_no_iniciada(lobby_id)

        jugadores = self._lobbies_por_id[lobby_id].jugadores()
        self._juegos_por_id[lobby_id] = Juego(jugadores, 3, Repartidor(self._mezcladora))
예제 #21
0
	def test_jugadores_tienen_una_carta_al_inicio(self) -> None:
		juego = Juego.iniciar(jugadores=['Articuno', 'Zapdos'])
		cartas_de = juego.cartas_por_jugador()
		self.assertEqual(1, len(cartas_de['Articuno']))
		self.assertEqual(1, len(cartas_de['Zapdos']))
예제 #22
0
	def test_jugadores_tienen_cartas_igual_nivel(self) -> None:
		juego = Juego.iniciar_en_nivel(jugadores=['Articuno', 'Zapdos'], nivel=3)
		cartas_de = juego.cartas_por_jugador()
		self.assertEqual(3, len(cartas_de['Articuno']))
		self.assertEqual(3, len(cartas_de['Zapdos']))
예제 #23
0
 def juego_default_4p(self) -> 'Juego':
     jugadores = ["Román", "Ramón", "Morán", "norMa"]
     repartidor = self.repartidor_rojo_verde()
     juego = Juego(jugadores, 3, repartidor)
     return juego