def test_pieza_inicial_esta_arriba_en_el_medio_al_iniciar():
pieza_inicial = tetris.generar_pieza(pieza=tetris.T)
juego = tetris.crear_juego(pieza_inicial)
pieza_centrada = tetris.trasladar_pieza(pieza_inicial, ANCHO_JUEGO // 2, 0)
return sorted(pieza_centrada) == sorted(tetris.pieza_actual(juego))
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))
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)
def test_mover_pieza_s_a_derecha():
juego = tetris.crear_juego(tetris.generar_pieza(pieza=tetris.S))
pieza_actual = tetris.pieza_actual(juego)
juego = tetris.mover(juego, DERECHA)
pieza_trasladada = tetris.trasladar_pieza(pieza_actual, DERECHA, 0)
return sorted(pieza_trasladada) == sorted(tetris.pieza_actual(juego))
def test_mover_pieza_i_a_izquierda():
juego = tetris.crear_juego(tetris.generar_pieza(pieza=tetris.I))
pieza_actual = tetris.pieza_actual(juego)
juego = tetris.mover(juego, IZQUIERDA)
pieza_trasladada = tetris.trasladar_pieza(pieza_actual, IZQUIERDA, 0)
return sorted(pieza_trasladada) == sorted(tetris.pieza_actual(juego))
def test_mover_l_contra_pared_izquierda():
pieza_inicial = tetris.generar_pieza(tetris.L)
juego = tetris.crear_juego(pieza_inicial)
for _ in range(ANCHO_JUEGO + 5):
juego = tetris.mover(juego, IZQUIERDA)
return sorted(pieza_inicial) == sorted(tetris.pieza_actual(juego))
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))
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
def test_mover_l_contra_pared_derecha():
pieza_inicial = tetris.generar_pieza(tetris.L)
juego = tetris.crear_juego(pieza_inicial)
for _ in range(ANCHO_JUEGO + 5):
juego = tetris.mover(juego, DERECHA)
pieza_trasladada = tetris.trasladar_pieza(pieza_inicial, ANCHO_JUEGO - 2,
0)
return sorted(pieza_trasladada) == sorted(tetris.pieza_actual(juego))
def test_grilla_esta_vacia_al_iniciar():
pieza_inicial = tetris.generar_pieza(tetris.T)
juego = tetris.crear_juego(pieza_inicial)
ancho, alto = tetris.dimensiones(juego)
for y in range(alto):
for x in range(ancho):
if tetris.hay_superficie(juego, x, y):
return False
return True
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)
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)
def crear_juego(filas, columnas):
grilla = {}
for y in range(filas):
for x in range(columnas):
inicio_cuadrado = (LADO_CUADRADOS * (x + 1),
LADO_CUADRADOS * (y + 2))
final_cuadrado = (LADO_CUADRADOS * (x + 2),
LADO_CUADRADOS * (y + 3))
grilla[(x, y)] = [inicio_cuadrado, final_cuadrado]
pieza_inicial = tetris.generar_pieza()
game = tetris.crear_juego(pieza_inicial)
juego = Juego(grilla, game)
return juego
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 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
def test_eliminar_todas_las_lineas():
pieza_i = tetris.generar_pieza(pieza=tetris.I)
juego = tetris.crear_juego(pieza_i)
# Acomodar todas piezas I y verificar que se eliminan todas
# las líneas
juego = _ubicar_piezas_I(juego, -4, 5, pieza_i)
if not juego: # El juego terminó antes de poder ubicar las I.
return False
# Revisar que no haya superficie en ningún lado
ancho, alto = tetris.dimensiones(juego)
for x in range(ancho):
for y in range(alto):
if tetris.hay_superficie(juego, x, y):
return False
return True
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
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
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)
def test_dimensiones_correctas():
pieza_inicial = tetris.generar_pieza(tetris.T)
juego = tetris.crear_juego(pieza_inicial)
ancho, alto = tetris.dimensiones(juego)
return ancho == ANCHO_JUEGO and alto == ALTO_JUEGO
def test_juego_no_esta_terminado_al_iniciar():
juego = tetris.crear_juego(tetris.generar_pieza(pieza=tetris.T))
return not tetris.terminado(juego)
