Update app.py

app.py

@@ -12,6 +12,7 @@ genai.configure(api_key=gemini_api_key)
 model = genai.GenerativeModel('gemini-pro')
 
 def get_game_state():
+    """Obtiene el estado actual del juego."""
     if 'aciertos' not in st.session_state:
         st.session_state.aciertos = 0
     if 'errores' not in st.session_state:
@@ -24,10 +25,10 @@ def get_game_state():
         st.session_state.respuestas = None
     if 'respuesta_correcta' not in st.session_state:
         st.session_state.respuesta_correcta = None
-    return (st.session_state.aciertos, st.session_state.errores, st.session_state.nivel,
-            st.session_state.problema, st.session_state.respuestas, st.session_state.respuesta_correcta)
+    return (st.session_state.aciertos, st.session_state.errores, st.session_state.nivel, st.session_state.problema, st.session_state.respuestas, st.session_state.respuesta_correcta)
 
 def update_game_state(aciertos, errores, nivel, problema, respuestas, respuesta_correcta):
+    """Actualiza el estado del juego."""
     st.session_state.aciertos = aciertos
     st.session_state.errores = errores
     st.session_state.nivel = nivel
@@ -36,6 +37,7 @@ def update_game_state(aciertos, errores, nivel, problema, respuestas, respuesta_
     st.session_state.respuesta_correcta = respuesta_correcta
 
 def chat_with_model(user_input):
+    """Envía una pregunta al modelo de IA y obtiene una respuesta."""
     try:
         response = model.generate_content(user_input)
         return response.text
@@ -43,6 +45,7 @@ def chat_with_model(user_input):
         return f"Error al generar contenido: {e}"
 
 def tiene_solucion_unica(matriz_coeficientes, matriz_resultados):
+    """Determina si un sistema de ecuaciones tiene solución única."""
     try:
         np.linalg.solve(matriz_coeficientes, matriz_resultados)
         return True
@@ -71,16 +74,14 @@ def generar_sistema_ecuaciones_2x2_y_respuestas():
         c, d, f = random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
         if tiene_solucion_unica(np.array([[a, b], [c, d]]), np.array([e, f])):
             break
-    matriz_coeficientes = np.array([[a, b], [c, d]])
-    matriz_resultados = np.array([e, f])
-    soluciones = np.linalg.solve(matriz_coeficientes, matriz_resultados)
+    soluciones = np.linalg.solve(np.array([[a, b], [c, d]]), np.array([e, f]))
     respuestas_incorrectas = {(round(soluciones[0] + random.choice([-2, -1, 1, 2]) * random.random(), 2), 
                                round(soluciones[1] + random.choice([-2, -1, 1, 2]) * random.random(), 2)) 
                               for _ in range(3)}
     respuestas_correctas = (round(soluciones[0], 2), round(soluciones[1], 2))
     respuestas = list(respuestas_incorrectas) + [respuestas_correctas]
     random.shuffle(respuestas)
-    sistema = f"{a}x + {b}y = {e}\n\n\n{c}x + {d}y = {f}"
+    sistema = f"{a}x + {b}y = {e}\n{c}x + {d}y = {f}"
     return sistema, respuestas, respuestas_correctas
 
 def generar_sistema_ecuaciones_3x3_y_respuestas():
@@ -89,49 +90,57 @@ def generar_sistema_ecuaciones_3x3_y_respuestas():
         a, b, c, e = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
         d, f, g, h = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
         i, j, k, l = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
-        matriz_coeficientes = np.array([[a, b, c], [d, f, g], [i, j, k]])
-        matriz_resultados = np.array([e, h, l])
-        if tiene_solucion_unica(matriz_coeficientes, matriz_resultados):
+        if tiene_solucion_unica(np.array([[a, b, c], [d, f, g], [i, j, k]]), np.array([e, h, l])):
             break
-    soluciones = np.linalg.solve(matriz_coeficientes, matriz_resultados)
+    soluciones = np.linalg.solve(np.array([[a, b, c], [d, f, g], [i, j, k]]), np.array([e, h, l]))
     respuestas_incorrectas = {(round(soluciones[0] + random.choice([-2, -1, 1, 2]) * random.random(), 2),
                                round(soluciones[1] + random.choice([-2, -1, 1, 2]) * random.random(), 2),
-                               round(soluciones[2] + random.choice([-2, -1, 1, 2]) * random.random(), 2)) 
+                               round(soluciones[2] + random.choice([-2, -1, 1, 2]) * random.random(), 2))
                               for _ in range(3)}
     respuestas_correctas = (round(soluciones[0], 2), round(soluciones[1], 2), round(soluciones[2], 2))
     respuestas = list(respuestas_incorrectas) + [respuestas_correctas]
     random.shuffle(respuestas)
-    sistema = f"{a}x + {b}y + {c}z = {e}\n\n\n{d}x + {f}y + {g}z = {h}\n\n\n{i}x + {j}y + {k}z = {l}"
+    sistema = f"{a}x + {b}y + {c}z = {e}\n{d}x + {f}y + {g}z = {h}\n{i}x + {j}y + {k}z = {l}"
     return sistema, respuestas, respuestas_correctas
 
 def get_ui_elements():
+    """Genera los elementos de la interfaz de usuario según el nivel actual"""
     nivel = st.session_state.nivel
-    if nivel == 2:
+    problema, respuestas, respuesta_correcta = None, None, None
+    if nivel == 2:  # Sistema 3x3
         problema, respuestas, respuesta_correcta = generar_sistema_ecuaciones_3x3_y_respuestas()
-    elif nivel == 1:
+    elif nivel == 1:  # Sistema 2x2
         problema, respuestas, respuesta_correcta = generar_sistema_ecuaciones_2x2_y_respuestas()
-    else:
+    else:  # Ecuación lineal
         problema, respuestas, respuesta_correcta = generar_ecuacion_y_respuestas()
     opciones = [", ".join(map(str, r)) if isinstance(r, tuple) else str(r) for r in respuestas]
     return problema, opciones, respuesta_correcta
 
 def manejar_respuesta(respuesta_elegida, respuesta_correcta, nivel, problema):
+    """Evalúa la respuesta del usuario, proporcionando retroalimentación y una explicación detallada."""
     tolerancia = 1e-9
     correcto = False
-    if nivel in [1, 2]:
+    if nivel in [1, 2]:  # Para sistemas de ecuaciones 2x2 y 3x3
         correcto = all(abs(e - c) < tolerancia for e, c in zip(respuesta_elegida, respuesta_correcta))
-    else:
+    else:  # Para ecuaciones lineales
         correcto = abs(respuesta_elegida - respuesta_correcta) < tolerancia
     
     resultado = "¡Correcto! +1 punto." if correcto else "Incorrecto, sigue practicando."
     explicacion = chat_with_model(f"Explica el problema '{problema}' y por qué la respuesta {respuesta_elegida} es {'correcta' if correcto else 'incorrecta'}.")
     
-    # Actualiza el estado del juego aquí
-
+    aciertos, errores, nivel_actual, _, _, _ = get_game_state()
+    if correcto:
+        aciertos += 1
+        if (aciertos == 5 and nivel_actual == 0) or (aciertos == 10 and nivel_actual == 1):
+            nivel_actual += 1
+            nivel_mensaje = ["Principiante", "Intermedio", "Difícil"][nivel_actual]
+            st.success(f"¡Felicitaciones, has pasado al nivel {nivel_mensaje}!")
+    else:
+        errores += 1
+    
+    update_game_state(aciertos, errores, nivel_actual, None, None, None)
     return f"{resultado} La explicación es: {explicacion}"
 
-
-
 # Interfaz de usuario y lógica de la aplicación
 st.title("Desafío de Matemáticas")
 st.markdown("Intenta resolver el problema y selecciona tu respuesta.")
@@ -153,7 +162,7 @@ seleccion = st.radio("Elige tu respuesta", respuestas, key="opciones")
 respuesta_elegida = tuple(map(float, seleccion.split(', '))) if "," in seleccion else float(seleccion)
 
 if st.button("Enviar"):
-    resultado = manejar_respuesta(respuesta_elegida, respuesta_correcta, nivel)
+    resultado = manejar_respuesta(respuesta_elegida, respuesta_correcta, nivel, problema)
     st.write(resultado)
 
 boton_nuevo_problema = st.button("Generar Nuevo Problema")