Update app.py

app.py

@@ -1,6 +1,6 @@
 """
 ================================================================================
-                    INTERACTIVE FACTORIZATION v1.4 EN
+                    INTERACTIVE FACTORIZATION v1.5 EN
 ================================================================================
 Main Developer: Marcos Autuori | Author: Autuori
 ================================================================================
@@ -8,13 +8,10 @@ Main Developer: Marcos Autuori | Author: Autuori
 
 import gradio as gr
 import time
-import wave
-import struct
-import math
 import os
 import base64
 
-# --- DATA ---
+# --- CONFIGURAÇÕES ---
 GRID_NUMBERS = [
     10, 12, 14, 15, 16, 18, 20, 21,
     24, 25, 27, 28, 30, 32, 35, 36,
@@ -22,143 +19,156 @@ GRID_NUMBERS = [
     63, 64, 70, 72, 80, 81, 90, 100
 ]
 KEYBOARD_KEYS = [2, 3, 4, 5, 6, 7, 8, 9, 10]
-MAX_TIME = 150
-
-# --- AUDIO GENERATION & ENCODING ---
-def create_audio_base64(freq, duration=0.15):
-    """Gera o som e converte para Base64 para o JS tocar instantaneamente"""
-    sample_rate = 44100
-    n_samples = int(sample_rate * duration)
-    buffer = []
-    for i in range(n_samples):
-        val = int(0.3 * 32767.0 * math.sin(2.0 * math.pi * freq * i / sample_rate))
-        buffer.append(struct.pack('<h', val))
-    
-    # Criar um stream de bytes wave
-    import io
-    byte_io = io.BytesIO()
-    with wave.open(byte_io, 'wb') as wav_file:
-        wav_file.setnchannels(1)
-        wav_file.setsampwidth(2)
-        wav_file.setframerate(sample_rate)
-        wav_file.writeframes(b"".join(buffer))
-    
-    return "data:audio/wav;base64," + base64.b64encode(byte_io.getvalue()).decode()
+MAX_TIME = 200  # Tempo aumentado conforme solicitado
 
-# Pre-encodando os sons
-SOUND_DATA = {
-    "click": create_audio_base64(440, 0.05),
-    "correct": create_audio_base64(880, 0.2),
-    "wrong": create_audio_base64(220, 0.3)
+# --- CARREGAMENTO DE ÁUDIO (BASE64) ---
+def get_audio_base64(filename):
+    path = os.path.join("sounds", filename)
+    if os.path.exists(path):
+        with open(path, "rb") as f:
+            data = f.read()
+            return "data:audio/wav;base64," + base64.b64encode(data).decode()
+    return ""
+
+# Pré-carrega os sons da pasta /sounds para o dicionário JS
+SOUNDS = {
+    "click": get_audio_base64("click.wav"),
+    "correct": get_audio_base64("correct.wav"),
+    "wrong": get_audio_base64("wrong.wav"),
+    "complete": get_audio_base64("complete.wav")
 }
 
-# --- JAVASCRIPT TRIGGERS ---
-# Esse script injetado toca o som sem latência de rede
+# --- JAVASCRIPT PARA PLAYBACK IMEDIATO ---
 js_sound_trigger = """
 (tag) => {
     if (!tag) return;
-    const sounds = {
-        'click': '""" + SOUND_DATA["click"] + """',
-        'correct': '""" + SOUND_DATA["correct"] + """',
-        'wrong': '""" + SOUND_DATA["wrong"] + """'
-    };
-    const audio = new Audio(sounds[tag]);
-    audio.play().catch(e => console.log('Autoplay blocked or fast-click error'));
-    return tag; 
+    const soundData = """ + str(SOUNDS) + """;
+    if (soundData[tag]) {
+        const audio = new Audio(soundData[tag]);
+        audio.play().catch(e => console.log("Audio playback blocked"));
+    }
+    return tag;
 }
 """
 
-# --- LOGIC ---
+# --- LÓGICA DO JOGO ---
 def get_empty_state():
     return {
-        "solved": [False] * 32, "selected_idx": None, "current_factors": [],
-        "start_time": time.time(), "game_over": False, "score": MAX_TIME
+        "solved": [False] * 32,
+        "selected_idx": None,
+        "current_factors": [],
+        "start_time": time.time(),
+        "game_over": False,
+        "score": MAX_TIME
     }
 
 def handle_game_logic(state, action_type, value=None):
-    if state["game_over"]: return state, "Game Over!", ""
-    
-    feedback = "Select a target..."
+    if state["game_over"]:
+        return state, "Game Over!", ""
+
+    feedback = "Select a target number..."
     sound_key = "click"
     
     if action_type == "select_target":
         state["selected_idx"] = value
         state["current_factors"] = []
         feedback = f"Factoring: {GRID_NUMBERS[value]}"
-    
+        
     elif action_type == "select_factor":
         if state["selected_idx"] is None:
-            feedback = "⚠️ Select a number first!"
+            feedback = "⚠️ Select a grid number first!"
             sound_key = "wrong"
         else:
             state["current_factors"].append(int(value))
             if len(state["current_factors"]) == 2:
                 a, b = state["current_factors"]
                 target = GRID_NUMBERS[state["selected_idx"]]
+                
                 if a * b == target:
                     state["solved"][state["selected_idx"]] = True
-                    feedback = f"✔️ Correct: {target}!"
+                    feedback = f"✔️ {a} x {b} = {target}! Correct!"
                     sound_key = "correct"
                     state["selected_idx"] = None
                 else:
-                    feedback = f"❌ Wrong for {target}!"
+                    feedback = f"❌ {a} x {b} = {a*b} (Wrong for {target})."
                     sound_key = "wrong"
                 state["current_factors"] = []
+
+    # Cálculo do Score
+    elapsed = int(time.time() - state["start_time"])
+    state["score"] = max(0, MAX_TIME - elapsed)
     
-    state["score"] = max(0, MAX_TIME - int(time.time() - state["start_time"]))
     if all(state["solved"]):
         state["game_over"] = True
-        feedback = "🏆 VICTORY!"
-        
+        feedback = f"🏆 VICTORY! Final Score: {state['score']}"
+        sound_key = "complete" # Som final solicitado
+
     return state, feedback, sound_key
 
-# --- UI ---
-custom_css = ".grid-btn { min-width: 80px !important; height: 80px !important; font-size: 20px !important; }"
+# --- INTERFACE ---
+custom_css = """
+.grid-btn { min-width: 80px !important; height: 80px !important; font-size: 20px !important; margin: 2px !important; }
+.kb-btn { min-width: 60px !important; height: 50px !important; }
+"""
 
 with gr.Blocks(title="Autuori - Factorization Game", css=custom_css) as demo:
     state = gr.State(get_empty_state())
     
-    # Hidden Trigger for JS Sound
+    # Campo invisível que dispara o som via JS
     sound_trigger = gr.Textbox(visible=False)
     sound_trigger.change(None, inputs=sound_trigger, js=js_sound_trigger)
 
-    gr.Markdown("# 🎮 Interactive Factorization v1.4 EN\n**Developer: Marcos Autuori**")
+    gr.Markdown("# 🎮 Interactive Factorization v1.5 EN\n**Developer: Marcos Autuori**")
     
     with gr.Row():
         with gr.Column(scale=4):
-            grid_btns = []
+            grid_buttons = []
             for r in range(4):
                 with gr.Row():
                     for c in range(8):
-                        idx = r*8+c
+                        idx = r * 8 + c
                         btn = gr.Button(str(GRID_NUMBERS[idx]), elem_classes="grid-btn")
-                        grid_btns.append(btn)
+                        grid_buttons.append(btn)
         
         with gr.Column(scale=1):
-            status = gr.Textbox(label="Status", value="Select a target", interactive=False)
-            score = gr.Number(label="Score", value=MAX_TIME, interactive=False)
-            kb_btns = [gr.Button(str(v), variant="secondary") for v in KEYBOARD_KEYS]
-            reset = gr.Button("Restart", variant="stop")
+            status_box = gr.Textbox(label="Status", value="Select a blue target", interactive=False)
+            score_display = gr.Number(label="Score", value=MAX_TIME, interactive=False)
+            
+            gr.Markdown("### Factors")
+            keyboard_btns = []
+            for val in KEYBOARD_KEYS:
+                kb_btn = gr.Button(str(val), variant="secondary", elem_classes="kb-btn")
+                keyboard_btns.append(kb_btn)
+            
+            reset_btn = gr.Button("Restart Game", variant="stop")
 
     def update_ui(s):
-        return [gr.update(value=f"✅ {GRID_NUMBERS[i]}" if s["solved"][i] else str(GRID_NUMBERS[i]), 
-                         variant="success" if s["solved"][i] else ("primary" if s["selected_idx"]==i else "secondary"),
-                         interactive=not s["solved"][i]) for i in range(32)] + [s["score"]]
-
-    # Event Mapping
-    for i, b in enumerate(grid_btns):
-        b.click(fn=lambda s, idx=i: handle_game_logic(s, "select_target", idx),
-                inputs=[state], outputs=[state, status, sound_trigger]).then(
-                fn=update_ui, inputs=[state], outputs=grid_btns + [score])
-
-    for b in kb_btns:
-        b.click(fn=lambda s, v=b.value: handle_game_logic(s, "select_factor", v),
-                inputs=[state], outputs=[state, status, sound_trigger]).then(
-                fn=update_ui, inputs=[state], outputs=grid_btns + [score])
-
-    reset.click(fn=lambda: [get_empty_state(), "New Game!", ""], 
-                outputs=[state, status, sound_trigger]).then(
-                fn=update_ui, inputs=[state], outputs=grid_buttons + [score] if 'grid_buttons' in locals() else grid_btns + [score])
+        updates = []
+        for i in range(32):
+            label = f"✅ {GRID_NUMBERS[i]}" if s["solved"][i] else str(GRID_NUMBERS[i])
+            variant = "success" if s["solved"][i] else ("primary" if s["selected_idx"] == i else "secondary")
+            updates.append(gr.update(value=label, variant=variant, interactive=not s["solved"][i]))
+        return updates + [s["score"]]
+
+    # Eventos
+    for i, btn in enumerate(grid_buttons):
+        btn.click(
+            fn=lambda s, idx=i: handle_game_logic(s, "select_target", idx),
+            inputs=[state], outputs=[state, status_box, sound_trigger]
+        ).then(fn=update_ui, inputs=[state], outputs=grid_buttons + [score_display])
+
+    for kb_btn in keyboard_btns:
+        kb_btn.click(
+            fn=lambda s, v=kb_btn.value: handle_game_logic(s, "select_factor", v),
+            inputs=[state], outputs=[state, status_box, sound_trigger]
+        ).then(fn=update_ui, inputs=[state], outputs=grid_buttons + [score_display])
+
+    def reset_all():
+        s = get_empty_state()
+        u = [gr.update(value=str(n), variant="secondary", interactive=True) for n in GRID_NUMBERS]
+        return [s, "Game Restarted!", ""] + u + [MAX_TIME]
+
+    reset_btn.click(fn=reset_all, outputs=[state, status_box, sound_trigger] + grid_buttons + [score_display])
 
 if __name__ == "__main__":
     demo.launch()