Ejemplo n.º 1
0
def test_avanzar_cambia_pieza_actual_al_consolidar_superficie():
    siguiente_pieza = tetris.generar_pieza(pieza=tetris.T)
    juego = tetris.crear_juego(tetris.generar_pieza(tetris.L))

    llego_al_piso = False
    # Avanzar n veces hasta que la pieza L esté justo antes de tocar el piso
    for _ in range(ALTO_JUEGO):
        pieza_actual = tetris.pieza_actual(juego)
        if any(py == ALTO_JUEGO - 1 for _, py in pieza_actual):
            llego_al_piso = True
            break

        juego, cambiar_pieza = tetris.avanzar(juego, siguiente_pieza)
        if cambiar_pieza == True:  # Si se consolidó antes hay un bug.
            return False

    if not llego_al_piso:
        return False  # Iteramos ALTO_JUEGO veces y la pieza nunca llegó al piso

    pieza_actual = tetris.pieza_actual(juego)
    juego, cambiar_pieza = tetris.avanzar(juego, siguiente_pieza)

    if not cambiar_pieza:
        return False  # La pieza tenía que consolidarse y no lo hizo

    pieza_centrada = tetris.trasladar_pieza(siguiente_pieza, ANCHO_JUEGO // 2,
                                            0)
    return sorted(pieza_centrada) == sorted(tetris.pieza_actual(juego))
Ejemplo n.º 2
0
def test_avanzar_consolida_la_superficie_al_llegar_al_fondo():
    siguiente_pieza = tetris.generar_pieza(pieza=tetris.T)
    juego = tetris.crear_juego(tetris.generar_pieza(tetris.L))

    llego_al_piso = False
    # Avanzar n veces hasta que la pieza L esté justo antes de tocar el piso
    for _ in range(ALTO_JUEGO):
        pieza_actual = tetris.pieza_actual(juego)
        if any(py == ALTO_JUEGO - 1 for _, py in pieza_actual):
            llego_al_piso = True
            break

        juego, cambiar_pieza = tetris.avanzar(juego, siguiente_pieza)
        if cambiar_pieza == True:  # Si se consolidó antes hay un bug.
            return False

    if not llego_al_piso:
        return False  # Iteramos ALTO_JUEGO veces y la pieza nunca llegó al piso

    pieza_actual = tetris.pieza_actual(juego)
    juego, cambiar_pieza = tetris.avanzar(juego, siguiente_pieza)

    if not cambiar_pieza:
        return False  # La pieza tenía que consolidarse y no lo hizo

    # Debe haber superficie en todos los puntos que ocupaba la pieza actual antes de
    # consolidarse.
    superficie = []
    for py in range(ALTO_JUEGO):
        for px in range(ANCHO_JUEGO):
            if tetris.hay_superficie(juego, px, py):
                superficie.append((px, py))

    return sorted(superficie) == sorted(pieza_actual)
Ejemplo n.º 3
0
def test_eliminar_lineas_baja_las_lineas_superiores():
    pieza_i = tetris.generar_pieza(pieza=tetris.I)
    juego = tetris.crear_juego(pieza_i)

    # Generar esta superficie:
    #   T
    # T T T
    # I I I I I I I
    # I I I I I I I
    # I I I I I I I
    # I I I I I I I
    #
    # Y verificar que al poner la última I queda así:
    #   T
    # T T T
    pieza_t = tetris.generar_pieza(pieza=tetris.T)
    juego = _ubicar_piezas_I(juego, -4, -1, pieza_t)
    if not juego:
        return False

    # Ubicar la T
    for _ in range(4):
        juego = tetris.mover(juego, IZQUIERDA)

    # Bajar la T hasta consolidarla
    juego, cambiar_pieza = tetris.avanzar(juego, pieza_i)
    while not cambiar_pieza and not tetris.terminado(juego):
        juego, cambiar_pieza = tetris.avanzar(juego, pieza_i)

    if tetris.terminado(juego):
        return False

    # Ubicar el resto de las I
    juego = _ubicar_piezas_I(juego, -1, 5, pieza_i)
    if not juego:
        return False

    # Revisar que no haya superficie en ningún lado excepto en
    # donde está la T
    ancho, alto = tetris.dimensiones(juego)

    pieza_t = tetris.generar_pieza(pieza=tetris.T)
    pieza_t = tetris.trasladar_pieza(pieza_t, 0, alto - 2)

    for x in range(ancho):
        for y in range(alto):
            if tetris.hay_superficie(juego, x, y) and not (x, y) in pieza_t:
                print(f"f en {(x, y)}")
                return False

    for x, y in pieza_t:
        if not tetris.hay_superficie(juego, x, y):
            print("no pieza t")
            return False

    return True
Ejemplo n.º 4
0
def test_juego_termina_si_no_se_puede_agregar_mas_piezas():
    pieza_i = tetris.generar_pieza(pieza=tetris.I)
    juego = tetris.crear_juego(pieza_i)

    # Está calculado que si ALTO_JUEGO es 18 se debe avanzar 35 veces
    # (incorporando únicamente nuevas piezas I) hasta perder el juego.
    for _ in range(35):
        juego, _ = tetris.avanzar(juego, pieza_i)
        if tetris.terminado(juego):
            return False  # El juego se perdió antes

    juego, _ = tetris.avanzar(juego, pieza_i)
    return tetris.terminado(juego)
Ejemplo n.º 5
0
def test_juego_terminado_sigue_terminado_al_avanzar():
    pieza_i = tetris.generar_pieza(pieza=tetris.I)
    juego = tetris.crear_juego(pieza_i)

    for _ in range(35):
        juego, _ = tetris.avanzar(juego, pieza_i)
        if tetris.terminado(juego):
            return False  # El juego se perdió antes

    ultimo_juego, _ = tetris.avanzar(juego, pieza_i)
    if not tetris.terminado(ultimo_juego):
        return False  # El juego no terminó cuando debía

    for _ in range(10):
        if tetris.avanzar(ultimo_juego, pieza_i) != (ultimo_juego, False):
            return False

    return True
Ejemplo n.º 6
0
def test_avanzar_baja_la_pieza_una_posicion():
    siguiente_pieza = tetris.generar_pieza(pieza=tetris.T)
    juego = tetris.crear_juego(tetris.generar_pieza(tetris.L))
    pieza_actual = tetris.pieza_actual(juego)

    juego, _ = tetris.avanzar(juego, siguiente_pieza)

    pieza_trasladada = tetris.trasladar_pieza(pieza_actual, 0, 1)
    return sorted(pieza_trasladada) == sorted(tetris.pieza_actual(juego))
Ejemplo n.º 7
0
def main():
    # Inicializar el estado del juego
    #siguiente_pieza = tetris.generar_pieza()
    siguiente = tetris.generar_pieza()
    t1= time.time()
    juego = tetris.crear_juego(tetris.generar_pieza())
    ancho, alto = tetris.dimensiones(juego)
    lista_teclas = leer_teclas()  
    gamelib.resize(800, 900)
    timer_bajar = ESPERA_DESCENDER
    while gamelib.loop(fps=30):
        gamelib.draw_begin()
        dibujar_superficie(juego)
        dibujar_pieza(juego)
        dibujar_siguiente(juego, siguiente)
        gamelib.draw_end()  
        for event in gamelib.get_events():
          if not event:
              break
          if event.type == gamelib.EventType.KeyPress:
              tecla = event.key
              if tecla == lista_teclas[1]:
                juego = tetris.mover(juego, -1)
              if tecla == lista_teclas[3]:
                juego = tetris.mover(juego, 1) 
              if tecla == lista_teclas[5]:
                juego = tetris.mover(juego, 2)
              if tecla == lista_teclas[0]:
                return
              if tecla == lista_teclas[6]:
                juego = tetris.rotar(juego)    
              if tecla == lista_teclas[4]:
                guardar_partida(juego)
              if tecla == lista_teclas[2]:
                juego = recuperar_partida()                           
              # Actualizar el juego, según la tecla presionada
        timer_bajar -= 1
        if timer_bajar == 0:  
            timer_bajar = ESPERA_DESCENDER 
            juego, siguiente_pieza = tetris.avanzar(juego, siguiente)
            if siguiente_pieza:
              siguiente = tetris.generar_pieza()
            if tetris.terminado(juego):
              gamelib.draw_image('img/perdiste.gif', 50, 200)
              t2 = time.time()
              tiempo_final = t2- t1
              gamelib.draw_rectangle(0, 0, 595, 60, outline='white', fill='salmon')
              gamelib.draw_text('Tu tiempo fue de {} segundos'.format(tiempo_final), 10, 17, fill='#000', size=18, anchor='nw')
              puntuaciones(tiempo_final)
              break

    while gamelib.is_alive():
      ordenar_puntuaciones()
      event = gamelib.wait(gamelib.EventType.KeyPress)
Ejemplo n.º 8
0
def actualizar_juego(juego, tecla=None):
    if tecla == "r":
        juego.superficies[0] = tetris.rotar(juego.superficies)
    if tecla == None or tecla == "s":
        juego.superficies, cambiar_pieza, puntaje = tetris.avanzar(
            juego.superficies, juego.siguiente_pieza)
        juego.puntaje += puntaje
        if cambiar_pieza == True:
            juego.siguiente_pieza = tetris.generar_pieza()
    if tecla == "a":
        juego.superficies = tetris.mover(juego.superficies, tetris.IZQUIERDA)
    elif tecla == "d":
        juego.superficies = tetris.mover(juego.superficies, tetris.DERECHA)
Ejemplo n.º 9
0
def _ubicar_piezas_I(juego, min_x, max_x, ultima_pieza):
    '''
    Función auxiliar para las pruebas
    Ubica piezas I en las columnas del rango [min_x, max_x).
    '''
    pieza_i = tetris.generar_pieza(pieza=tetris.I)
    piezas_siguientes = [pieza_i
                         for x in range(min_x, max_x - 1)] + [ultima_pieza]
    for dx, proxima_pieza in zip(range(min_x, max_x), piezas_siguientes):
        # Mover dx veces
        for _ in range(abs(dx)):
            juego = tetris.mover(juego, IZQUIERDA if dx < 0 else DERECHA)

        # Bajar la pieza hasta consolidarla
        juego, cambiar_pieza = tetris.avanzar(juego, proxima_pieza)
        while not cambiar_pieza and not tetris.terminado(juego):
            juego, cambiar_pieza = tetris.avanzar(juego, proxima_pieza)

        if tetris.terminado(juego):
            return None

    return juego
Ejemplo n.º 10
0
def test_eliminar_filas_superiores():
    pieza_t = tetris.generar_pieza(tetris.T)
    juego = tetris.crear_juego(pieza_t)

    for _ in range(tetris.dimensiones(juego)[1]):
        juego = tetris.mover(juego, IZQUIERDA)

    juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)
    while not cambiar_pieza and not tetris.terminado(juego):
        juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)

    for _ in range(tetris.dimensiones(juego)[1]):
        juego = tetris.mover(juego, DERECHA)

    juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)
    while not cambiar_pieza and not tetris.terminado(juego):
        juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)

    # Se consolida la siguiente superficie:
    #
    #    T T T T T T T T T
    #      T     T     T

    # La cual al eliminar las filas debería resultar en
    #
    #
    #      T     T     T

    juego = tetris.mover(juego, IZQUIERDA)
    juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)
    while not cambiar_pieza and not tetris.terminado(juego):
        juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)

    juego, cambiar_pieza = tetris.avanzar(juego, pieza_t)

    ancho, alto = tetris.dimensiones(juego)
    superficies_esperadas = [(1, 17), (4, 17), (7, 17)]
    for j in range(alto):
        for i in range(ancho):

            # Superficie esperada no se encuenta en el juego
            if (i, j) in superficies_esperadas:
                if not tetris.hay_superficie(juego, i, j):
                    return False

            # Se encontro una superficie no esperada en el juego
            elif tetris.hay_superficie(juego, i, j):
                return False

    return True
def main():
    # Inicializar el estado del juego
    gamelib.resize(RES, RES)
    teclas = tetris.cargar_teclas(RUTA_TECLAS_CONFIG)
    piezas = tetris.cargar_piezas(RUTA_PIEZAS)
    siguiente_pieza = tetris.generar_pieza(piezas)
    juego = tetris.crear_juego(tetris.generar_pieza(piezas))
    tabla_record = tetris.mostrar_tabla_records(RUTA_PUNTUAJES)
    juego_terminado = False
    puntuaje = 0
    salir = False

    timer_bajar = ESPERA_DESCENDER
    while gamelib.loop(fps=30) and not salir:
        gamelib.draw_begin()
        # Dibujar la pantalla
        dibujar_grilla(juego)
        dibujar_pieza(juego)
        dibujar_siguiente(juego, siguiente_pieza)
        dibujar_superficie(juego)
        dibujar_puntuaje(juego, puntuaje)
        if juego_terminado:
            dibujar_game_over(tabla_record)
            anotar = tetris.es_record(puntuaje, tabla_record)
            if anotar:
                nombre = gamelib.input("Ingresar nombre: ")
                tetris.guardar_puntuaje(RUTA_PUNTUAJES, nombre, int(puntuaje))
            dibujar_game_over(tabla_record)
            break
        gamelib.draw_end()

        for event in gamelib.get_events():
            if not event:
                break
            if event.type == gamelib.EventType.KeyPress:
                tecla = event.key
                # Actualizar el juego, según la tecla presionada
                if tecla in teclas:
                    if teclas[tecla] == "IZQUIERDA":
                        juego = tetris.mover(juego, -1)
                    elif teclas[tecla] == "DERECHA":
                        juego = tetris.mover(juego, 1)
                    elif teclas[tecla] == "DESCENDER":
                        timer_bajar = 1
                    elif teclas[tecla] == "SALIR":
                        salir = True
                    elif teclas[tecla] == "ROTAR":
                        juego = tetris.rotar(juego, piezas)
                    elif teclas[tecla] == "GUARDAR":
                        tetris.guardar_partida(
                            RUTA_PARTIDA, juego, puntuaje, siguiente_pieza
                        )
                    elif teclas[tecla] == "CARGAR":
                        partida = tetris.cargar_partida(RUTA_PARTIDA)
                        juego = partida["juego"]
                        siguiente_pieza = partida["siguiente_pieza"]
                        puntuaje = partida["puntuaje"]

        if not tetris.terminado(juego) and not juego_terminado:
            timer_bajar -= 1
            if timer_bajar == 0:
                timer_bajar = ESPERA_DESCENDER
                puntuaje += 0.3
                # Descender la pieza automáticamente
                juego, prox = tetris.avanzar(juego, siguiente_pieza)
                if prox:
                    siguiente_pieza = tetris.generar_pieza(piezas)
        else:
            juego_terminado = True
Ejemplo n.º 12
0
def main():

    # Inicializar el estado del juego
    gamelib.resize(400, 450)
    pieza = tetris.generar_pieza()
    juego = tetris.crear_juego(pieza)
    pieza_i = tetris.generar_pieza()
    timer_bajar = ESPERA_DESCENDER
    while gamelib.loop(fps=10):

        gamelib.draw_begin()
        gamelib.draw_text("SIGUIENTE PIEZA: ", 300, 20)
        gamelib.draw_text("PUNTAJE:", 275, 300)
        #lineas verticales
        for i in range(1, 10):
            gamelib.draw_line(TAMANOCELDA * i, 0, TAMANOCELDA * i, ALTOTABLERO)
        #lineas horizontales
        for i in range(1, tetris.ALTO_JUEGO):
            gamelib.draw_line(0, TAMANOCELDA * i, ANCHOTABLERO,
                              TAMANOCELDA * i)
        # Dibujar la pantalla
        gamelib.draw_end()

        for event in gamelib.get_events():
            if not event:
                break

            if event.type == gamelib.EventType.KeyPress:
                tecla = event.key
                dicteclas = tetris.pasar_a_diccionario("teclas.txt")
                a = dicteclas.get(tecla, None)

                if a == "ROTAR":
                    juego = tetris.rotar(juego)

                if a == "DESCENDER":
                    juego, _ = tetris.avanzar(juego, pieza_i)
                    if _:
                        pieza_i = tetris.generar_pieza()
                if a == "IZQUIERDA":
                    juego = tetris.mover(juego, tetris.IZQUIERDA)

                if a == "DERECHA":
                    juego = tetris.mover(juego, tetris.DERECHA)
                if a == "GUARDAR":
                    juego = tetris.guardar_partida(juego, "partida.txt")
                if a == "CARGAR":
                    juego = tetris.cargar_partida("partida.txt")
                if a == "SALIR":
                    return

                # Actualizar el juego, según la tecla presionada

        timer_bajar -= 1
        if timer_bajar == 0:

            juego, _ = tetris.avanzar(juego, pieza_i)
            if _:
                pieza_i = tetris.generar_pieza()
            timer_bajar = ESPERA_DESCENDER

            # Descender la pieza automáticamente

        if tetris.terminado(juego):
            pieza, superficie, puntuacion = juego
            gamelib.draw_text("PERDISTE", 175, 80, size=40)
            nombre = gamelib.input("ingrese su nombre")
            listapuntuaciones = procesarpuntuaciones("puntuaciones.txt")
            listapuntuaciones.append((nombre, int(puntuacion)))
            lista = ordenarseleccionpuntuaciones(listapuntuaciones)
            lista.reverse(
            )  #la damos vuelta porque esta ordenada de menor a mayor y queremos que el archivo empieze leyendo de mayor a menor

            if len(lista) > 10:
                lista = lista[:10]

            subirpuntuaciones("puntuaciones.txt", lista)

            break

        mostrar_juego(juego)
        dibujar_siguiente(pieza_i)
Ejemplo n.º 13
0
def main():
    '''
    Funcion principal del juego. Mantiene la interfaz grafica y evalua las teclas recibidas y si el juego esta terminado 
    '''
    # Inicializar el estado del juego
    tetris.importar_piezas(tetris.RUTA_PIEZAS)

    juego = tetris.crear_juego(tetris.generar_pieza())
    salir = False

    puntaje_juego = 0
    ingreso_puntaje = False

    cambiar_ficha = False
    siguiente_ficha = tetris.generar_pieza()

    gamelib.resize(grafico.ANCHO_PANT, grafico.ALTO_PANT)
    gamelib.play_sound("sound/bradinsky.wav")

    teclas = importar_teclas(tetris.RUTA_TECLAS)

    timer_bajar = ESPERA_DESCENDER
    while gamelib.loop(fps=30):
        gamelib.draw_begin()
        gamelib.title("TETRIS")
        # Dibujar la pantalla
        grafico.tablero(puntaje_juego)
        grafico.piezas(juego, siguiente_ficha)

        if salir:
            break

        if tetris.terminado(juego):
            grafico.terminado()
            if not ingreso_puntaje:
                leaderboard = tetris.cargar_leaderboard()
                leaderboard, ingreso_puntaje = grafico.top_puntajes(
                    leaderboard, puntaje_juego)
            grafico.imprimir_puntajes(leaderboard)

        gamelib.draw_end()
        for event in gamelib.get_events():
            if not event:
                break
            if event.type == gamelib.EventType.KeyPress:
                tecla = event.key
                # Actualizar el juego, según la tecla presionada ( ROTAR ( w) , MOVER izq der abajo, guardar, cargar )

                juego = actualizar_movimiento(juego, tecla, teclas)

                if tecla in teclas["GUARDAR"]:
                    tetris.guardar_partida(juego, siguiente_ficha,
                                           puntaje_juego)
                if tecla in teclas["CARGAR"]:
                    juego, siguiente_ficha, puntaje_juego = tetris.cargar_partida(
                    )
                if tecla in teclas["DESCENDER"]:
                    juego, cambiar_ficha = tetris.avanzar(
                        juego, siguiente_ficha)
                    puntaje_juego += 1
                    continue
                if tecla in teclas["SALIR"]:
                    salir = True

        timer_bajar -= 1
        if timer_bajar == 0:
            timer_bajar = ESPERA_DESCENDER
            # Descender la pieza automáticamente

            if cambiar_ficha == True:
                siguiente_ficha = tetris.generar_pieza()
            juego, cambiar_ficha = tetris.avanzar(juego, siguiente_ficha)
            if not tetris.terminado(juego):
                puntaje_juego += 1