def main():
"""
Función que muestra la ventana de top de puntajes.
El usuario puede ver el top de todos los niveles y un top general (incluye todos los niveles).
"""
ultimo_presionado = "general"
top = leer_top()
tabla = cargar_tabla()
window = crear_ventana_tops(tabla["general"])
while True:
event = leer_evento(window)[0]
if event in (None, "volver"):
break
elif event == "resetear":
resetear(top, tabla, ultimo_presionado, window)
else:
ultimo_presionado = mostrar_top(ultimo_presionado, event, tabla[event], window)
window.Close()
def main():
"""
Función que muestra la ventana de reglas.
Informa el tipo de palabras válidas y tamaño del tablero de acuerdo
al nivel seleccionado.
"""
ultimo_presionado = ""
window = crear_ventana_reglas()
while True:
event = leer_evento(window)[0]
if event == "mas_informacion":
open(
"https://github.com/ValentinGiorgetti/ScrabbleAR/blob/master/README.md#reglas-del-juego"
)
continue
if event in (None, "Volver"):
break
else:
ultimo_presionado = mostrar_texto(window, event, ultimo_presionado)
window.Close()
def main(window, tablero, parametros):
"""
Función que muestra una ventana donde el jugador puede cambiar algunas o todas sus fichas.
Parámetros:
- window (sg.Window): ventana del tablero.
- tablero (dict): diccionario con la información del tablero.
- parametros (dict): diccionario con párametros que controlan la lógica del juego.
"""
jugador = tablero["jugador"]
letras_jugador = jugador.fichas
bolsa_de_fichas = tablero["bolsa_de_fichas"]
if parametros["jugada"]:
sg.Popup("Primero debe levantar sus fichas\n", **parametros_popup)
return
ventana = crear_ventana_cambio_fichas(letras_jugador)
fichas = fichas_totales(bolsa_de_fichas)
seleccionadas = {}
cambio = False
while not cambio:
event, values, tiempo = leer_evento(ventana, 1000, "esperar")
parametros["fin_juego"], tablero["contador"] = actualizar_tiempo(
window, tablero["contador"], tiempo)
if parametros["fin_juego"] or event in ("cancelar", None):
break
elif event == "esperar":
continue
elif event == "todas":
cambio = cambiar_todas(window, bolsa_de_fichas, parametros,
letras_jugador)
elif event == "algunas":
cambio = cambiar_seleccionadas(window, bolsa_de_fichas,
seleccionadas, letras_jugador,
parametros)
else:
seleccionar_ficha(ventana, event, seleccionadas,
letras_jugador[event])
ventana.Close()
if cambio:
actualizar_tablero(window, tablero, parametros, jugador)
def ventana_palabras_ingresadas(window, tablero, parametros, comenzar):
"""
Función que muestra una ventana con información sobre las palabras formadas
durante la partida.
Parámetros:
- window (sg.Window): ventana del tablero.
- tablero (dict): diccionario que contiene información del tablero.
- parametros (dict): diccionario que contiene párametros usados para controlar la lógica del juego.
- comenzar (bool): indica si la partida está pausada.
"""
palabras_ingresadas = tablero["palabras_ingresadas"]
if not palabras_ingresadas:
sg.Popup("No se ingresó ninguna palabra\n", **parametros_popup)
return
layout = [[
sg.Text("Palabras ingresadas durante la partida",
**titulos,
size=(40, 1))
], [sg.Text("")],
[
sg.Table(
sorted(palabras_ingresadas,
key=lambda x: x[2],
reverse=True),
[" Palabra ", "Clasifiación", "Puntos", "Usuario"],
justification="center",
)
], [sg.Text("")], [sg.Button(" Volver ")]]
ventana = sg.Window(" Palabras ingresadas", layout, **parametros_ventana)
partida_finalizada = parametros["fin_juego"]
while True:
event, values, tiempo = leer_evento(ventana, 1000)
if not partida_finalizada and comenzar:
parametros["fin_juego"], tablero["contador"] = actualizar_tiempo(
window, tablero["contador"], tiempo)
if parametros["fin_juego"]:
break
if event in (" Volver ", None):
break
ventana.Close()
def main():
"""
Función que muestra una ventana donde el usuario puede modificar diferentes parámetros de la partida.
El usuario puede configurar el nivel y tiempo de la partida, asi como también el puntaje y cantidad de
fichas de cada letra para todos los niveles.
Siempre se muestra la última configuración seleccionada, la cuál inicialmente coincide con la configuración
por defecto. El usuario tiene la posibilidad de reestablecer las configuraciones a valores por defecto.
Retorna:
- configuracion_seleccionada (dict): diccionario que contiene la configuración seleccionada.
"""
configuracion_seleccionada = leer_ultima_configuracion()
ultimo_presionado = configuracion_seleccionada[
"nivel_seleccionado"].capitalize()
window = crear_ventana_configuracion(ultimo_presionado,
configuracion_seleccionada)
while True:
event, values, tiempo = leer_evento(window)
if event in (None, " Aceptar "):
break
elif event == "restablecer":
restablecer_configuracion(window, ultimo_presionado,
configuracion_seleccionada)
elif event == "confirmar_tiempo":
confirmar_tiempo(values["tiempo"], configuracion_seleccionada,
window)
elif event == "confirmar_letra":
confirmar_letra(values, configuracion_seleccionada, window)
elif event == "confirmar_nick":
confirmar_nick(values, configuracion_seleccionada, window)
elif event in ("Fácil", "Medio", "Difícil"):
ultimo_presionado = seleccionar_dificultad(
configuracion_seleccionada, ultimo_presionado, event, window)
window.Close()
guardar_ultima_configuracion(configuracion_seleccionada)
return configuracion_seleccionada
def main():
"""
Función que muestra la ventana principal del programa.
Muestra un menú con opciones para acceder a la ventana de configuración, reglas, top de
puntajes, reanundar o iniciar una partida nueva.
"""
partida_guardada = leer_partida_guardada()
configuracion_seleccionada = leer_ultima_configuracion()
ventana_principal = crear_ventana_main(partida_guardada)
while True:
event = leer_evento(ventana_principal)[0]
if event in (None, "Salir"):
break
if event == "github":
open("https://github.com/ValentinGiorgetti/ScrabbleAR")
continue
ventana_principal.Hide()
if event == "reglas":
reglas()
elif event == "top_puntajes":
top_puntajes()
elif event == "configuracion":
configuracion_seleccionada = cargar_configuracion()
elif event == "jugar":
partida_guardada = comenzar_juego(configuracion_seleccionada,
partida_guardada,
ventana_principal)
elif event == "reanudar":
partida_guardada = reanudar_juego(configuracion_seleccionada,
partida_guardada,
ventana_principal)
ventana_principal.UnHide()
ventana_principal.Close()
def main(configuracion, partida_anterior):
"""
Función donde se muestra el tablero de juego y se leen los diferentes eventos.
Parámetros:
- configuracion (dict): diccionario que contiene la configuración de la partida.
- partida_anterior (dict): diccionario que contiene información de la partida anterior.
Retorna:
- partida_guardada (dict): diccionario con la partida jugada.
- tablero["jugador"] (Jugador): instancia de la clase Jugador que representa al usuario.
- tablero["computadora"] (Jugador): instancia de la clase Jugador que representa a la computadora.
"""
tablero, parametros = inicializar_parametros(configuracion,
partida_anterior)
window = crear_ventana_tablero(tablero, parametros, partida_anterior)
comenzar = partida_guardada = partida_finalizada = None
while True:
event, values, tiempo = leer_evento(window, 1000)
if event == "Salir" and confirmar_salir(parametros["fin_juego"]):
break
elif event == "Iniciar":
comenzar = iniciar_partida(window, parametros, partida_anterior)
elif event == "Pausa":
comenzar = pausar(window, comenzar)
elif event == "palabras_ingresadas":
ventana_palabras_ingresadas(window, tablero, parametros, comenzar)
elif event == "Posponer":
salir, partida_guardada = posponer(tablero, parametros["jugada"])
if salir:
break
elif event == "Terminar":
comenzar = finalizar_partida(window, tablero, parametros)
elif comenzar:
parametros["fin_juego"], tablero["contador"] = actualizar_tiempo(
window, tablero["contador"], tiempo)
if tablero["turno"] == "Computadora":
jugar_computadora(window, parametros, tablero)
elif tablero["turno"] == "Jugador":
if event == "cambiar":
cambiar_fichas(window, tablero, parametros)
elif event == "Pasar":
pasar(window, parametros, tablero)
elif event == "confirmar":
confirmar_palabra(window, parametros, tablero)
elif event in range(7):
seleccionar_ficha(window, parametros, event,
tablero["jugador"].color)
elif event:
colocar_ficha(window, parametros, tablero, event)
if parametros["fin_juego"]:
comenzar = finalizar_partida(window, tablero, parametros)
window["cantidad_fichas"].Update(
len(fichas_totales(tablero["bolsa_de_fichas"])))
window.Close()
return partida_guardada, tablero["jugador"], tablero["computadora"]