Esempio n. 1
0
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))
Esempio n. 2
0
    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__())
Esempio n. 3
0
 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)
Esempio n. 4
0
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))
Esempio n. 5
0
    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)
Esempio n. 6
0
 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
Esempio n. 7
0
 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)
Esempio n. 8
0
 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
Esempio n. 9
0
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)
Esempio n. 10
0
 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'
Esempio n. 11
0
    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)
Esempio n. 12
0
 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)
Esempio n. 13
0
    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)
Esempio n. 14
0
    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__())
Esempio n. 15
0
    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)
Esempio n. 16
0
    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)))
Esempio n. 17
0
    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)))
Esempio n. 18
0
    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)
Esempio n. 19
0
    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)
Esempio n. 20
0
    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()
Esempio n. 21
0
 def __init__(self,
              partida=Partida(),
              ganadascpu=0,
              ganadasjugador=0,
              empatadas=0):
     self.partida = partida
     self.ganadascpu = ganadascpu
     self.ganadasjugador = ganadasjugador
     self.empatadas = empatadas
Esempio n. 22
0
    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)))
Esempio n. 23
0
    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)))
Esempio n. 24
0
 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], })
Esempio n. 25
0
 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)
Esempio n. 26
0
    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))))
Esempio n. 27
0
    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)
Esempio n. 28
0
    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))))
Esempio n. 29
0
    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))))
Esempio n. 30
0
    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)