juego_embbedings_chat.py

# %%
import json
import pickle as pk
import random
import threading
from datetime import datetime
import time
import gradio as gr
import numpy as np
from display import display_words
from gensim.models import KeyedVectors
from pistas import curiosity, hint
from seguimiento import calculate_moving_average, calculate_tendency_slope
from sentence_transformers import SentenceTransformer

model = KeyedVectors(768)
model_st = SentenceTransformer(
    "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
)

embeddings_dict = {}

config_file_path = "config/lang.json"
secret_file_path = "config/secret.json"


class DictWrapper:
    def __init__(self, data_dict):
        self.__dict__.update(data_dict)


with open(config_file_path, "r") as file:
    Config_full = json.load(file)

with open(secret_file_path, "r") as file:
    secret = json.load(file)

lang = 0

if lang == 0:
    Config = DictWrapper(Config_full["SPA"]["Game"])
    secret_dict = secret["SPA"]
elif lang == 1:
    Config = DictWrapper(Config_full["ENG"]["Game"])
    secret_dict = secret["ENG"]
else:
    Config = DictWrapper(Config_full["SPA"]["Game"])
    secret_dict = secret["SPA"]


with open("ranking.txt", "w+") as file:
    file.write("---------------------------")

pca = pk.load(open("pca_mpnet.pkl", "rb"))

# print(Config.Difficulty_presentation_Full)
# difficulty = int(input(Config.Difficulty + ": "))
difficulty = -1

def prepare_game():
    global secret, secret_list, words, scores, word_vect, thread, win, n, recent_hint, f_dev_avg, last_hint, difficulty
    while difficulty == -1:
        print("waiting for difficulty") 

    secret_list = secret_dict["basic"] if difficulty <= 2 else secret_dict["advanced"]

    secret = secret_list.pop(random.randint(0, len(secret_list) - 1))
    secret = secret.lower()

    words = [Config.secret_word]
    scores = [10]

    if secret not in embeddings_dict.keys():
        embeddings_dict[secret] = model_st.encode(secret, convert_to_tensor=True)
        model.add_vector(secret, embeddings_dict[secret].tolist())

    word_vect = [embeddings_dict[secret].tolist()]

    thread = threading.Thread(
        target=display_words, args=(words, pca.transform(word_vect), scores, -1)
    )
    thread.start()

    win = False
    n = 0
    recent_hint = 0
    f_dev_avg = 0
    last_hint = -1

    if difficulty == 1:
        n = 3


def preproc_vectors(words, word_vect, scores, repeated):
    ascending_indices = np.argsort(scores)
    descending_indices = list(ascending_indices[::-1])
    ranking_data = []
    k = len(words) - 1
    if repeated != -1:
        k = repeated

    ranking_data.append(["#" + str(k), words[k], scores[k]])

    ranking_data.append("---------------------------")
    for i in descending_indices:
        if i == 0:
            continue
        ranking_data.append(["#" + str(i), words[i], scores[i]])

    with open("ranking.txt", "w+") as file:
        for item in ranking_data:
            file.write("%s\n" % item)

    if len(words) > 11:
        if k in descending_indices[:11]:
            descending_indices = descending_indices[:11]
        else:
            descending_indices = descending_indices[:11]
            descending_indices.append(k)
        words_display = [words[i] for i in descending_indices]
        displayvect_display = pca.transform([word_vect[i] for i in descending_indices])
        scores_display = [scores[i] for i in descending_indices]
        bold = descending_indices.index(k)

    else:
        words_display = words
        displayvect_display = pca.transform(word_vect)
        scores_display = scores
        bold = k

    return (
        words_display,
        displayvect_display,
        scores_display,
        bold,
    )


    


def play_game(word):
    global win, n, recent_hint, f_dev_avg, last_hint, words, word_vect, scores, thread

    word = word.lower()
    if word == "give_up":
        return "Game Over"

    if word in words:
        repeated = words.index(word)
    else:
        repeated = -1
        words.append(word)

    thread.join()

    if word not in embeddings_dict.keys():
        embedding = model_st.encode(word, convert_to_tensor=True)
        embeddings_dict[word] = embedding
        model.add_vector(word, embedding.tolist())

    if repeated == -1:
        word_vect.append(embeddings_dict[word].tolist())

    score = round(model.similarity(secret, word) * 10, 2)

    if repeated == -1:
        scores.append(score)

    if score <= 2.5:
        feedback = Config.Feedback_0 + str(score)
    elif score > 2.5 and score <= 4.0:
        feedback = Config.Feedback_1 + str(score)
    elif score > 4.0 and score <= 6.0:
        feedback = Config.Feedback_2 + str(score)
    elif score > 6.0 and score <= 7.5:
        feedback = Config.Feedback_3 + str(score)
    elif score > 7.5 and score <= 8.0:
        feedback = Config.Feedback_4 + str(score)
    elif score > 8.0 and score < 10.0:
        feedback = Config.Feedback_5 + str(score)
    else:
        win = True
        feedback = Config.Feedback_8
        words[0] = secret
        words.pop(len(words) - 1)
        word_vect.pop(len(word_vect) - 1)
        scores.pop(len(scores) - 1)

    if score > scores[len(scores) - 2] and win == False:
        feedback += "\n" + Config.Feedback_6
    elif score < scores[len(scores) - 2] and win == False:
        feedback += "\n" + Config.Feedback_7

    if difficulty != 4:
        mov_avg = calculate_moving_average(scores[1:], 5)

        if len(mov_avg) > 1 and win == False:
            f_dev = calculate_tendency_slope(mov_avg)
            f_dev_avg = calculate_moving_average(f_dev, 3)
            if f_dev_avg[len(f_dev_avg) - 1] < 0 and recent_hint == 0:
                i = random.randint(0, len(Config.hint_intro) - 1)
                feedback += "\n\n" + Config.hint_intro[i]
                hint_text, n, last_hint = hint(
                    secret,
                    n,
                    model_st,
                    last_hint,
                    lang,
                    (
                        DictWrapper(Config_full["SPA"]["Hint"])
                        if lang == 0
                        else DictWrapper(Config_full["ENG"]["Hint"])
                    ),
                )
                feedback += "\n" + hint_text
                recent_hint = 3

        if recent_hint != 0:
            recent_hint -= 1

    (
        words_display,
        displayvect_display,
        scores_display,
        bold_display,
    ) = preproc_vectors(words, word_vect, scores, repeated)

    if win:
        bold_display = 0

    thread = threading.Thread(
        target=display_words,
        args=(words_display, displayvect_display, scores_display, bold_display),
    )
    thread.start()

    if win:
        feedback += "\nCongratulations! You guessed the secret word."

    return feedback



i = -1

with gr.Blocks() as demo:
    gr.Markdown(
        """
    <p style="text-align:center"> SEMANTRIX: JUEGO DE LA ADIVINANZA SEMÁNTICA </p>
    """
    )
    lang = {
        "Introduction_0": "Bienvenido a Semantrix, el emocionante Juego de la Adivinanza Semántica.",
        "Introduction_1": "¿Quieres saber cómo se juega?",
        "Rules_1": "Tu misión es adivinar una palabra secreta que yo he escogido, pero no te preocupes, te ayudaré en el camino. \n\nLanza al aire la primera palabra que se te ocurra. Te daré pistas diciéndote si estás caliente, es decir muy cerca de adivinarla o frío, es decir, muy lejos de la palabra.",
        "Rules_3": "Adicionalmente, Cada palabra que propongas recibirá una puntuación entre 0 y 10, un puntaje alto significa que estás muy cerca de adivinar la palabra secreta\n\nSi veo que estás un poco perdido, estaré aquí para darte pistas que te ayudarán a acercarte a la palabra secreta.",
        "Rules_5": "Como ayuda extra, mostraré un ranking de todas las palabras que has propuesto, ordenadas según su puntuación. Así podrás tener una idea mejor de qué tan cerca están y qué palabras funcionan mejor.",
        "Rules_6": "Serás el ganador cuando adivines correctamente la palabra secreta. ¡No desistas, lo tienes al alcance!\n\nAsí que, ¡enciende tu mente, confía en tus ideas y por sobre todo, pasa un buen rato! Este es un juego en el que cada palabra, cada puntuación y cada pista te acerca a tu victoria. ¡Mucha suerte!",
        "Difficulty_presentation_Full": "En este emocionante desafío de adivinanza semántica, puedes elegir cuán grande quieres que sea el reto. Aquí te presento los niveles de dificultad:\n\nFácil: ¡Es hora de calentar motores! En este nivel, te daré pistas evidentes para que puedas adivinar la palabra secreta de manera más rápida. Si estás comenzando a jugar o simplemente quieres pasar un buen rato sin mucha presión, ¡este es tu nivel!\n\nNormal: Aquí es donde las cosas comienzan a ponerse interesantes. En este nivel, solo te daré pistas cuando te vea muy perdido. Es bueno para aquellos jugadores que quieren un reto, pero sin ser tan duros consigo mismos.\n\nDifícil: ¿Listo para un verdadero desafío? En este nivel, te ayudaré solo cuando te vea realmente perdido, y prepárate, porque las palabras pueden llegar a ser más complejas. Para esos pensadores agudos que les encanta una buena cabeza rompecabezas.\n\nExperto: ¿Eres un maestro de las palabras? Este es el camino menos transitado, para aquellos campeones de la semántica que buscan la pura adrenalina del reto. No te daré ninguna pista y las palabras serán complejas. Aquí es donde puedes demostrar tu verdadero poder.\n\nRecuerda, ganes o pierdas, cada nivel está diseñado para hacerte disfrutar y mejorar tus habilidades de adivinanza y comprensión de las palabras. ¡Escoge tu nivel y empieza a jugar!",
        "Difficulty": "Elige tu nivel de dificultad",
        "New_word": "Nueva palabra: ",
        "Feedback_0": "Helado, puntuación: ",
        "Feedback_1": "Frío, puntuación: ",
        "Feedback_2": "Templado, puntuación: ",
        "Feedback_3": "Caliente, puntuación: ",
        "Feedback_4": "Quemando, puntuación: ",
        "Feedback_5": "Ardiendo, puntuación: ",
        "Feedback_6": "Te estás acercando",
        "Feedback_7": "Te estás alejando",
        "Feedback_8": "¡Has ganado, ENHORABUENA!",
        "Feedback_9": "La palabra secreta era: ",
        "Feedback_10": "Aunque no fue una victoria esta vez, ¡no temas! ¡Cada intento es una nueva oportunidad para brillar! ¡Sigue adelante!",
        "secret_word": "PALABRA SECRETA",
        "hint_intro": [
            "Parece que las palabras están jugando al escondite contigo. ¿Necesitas una ayudita? Aquí va una pista:",
            "¡Vamos, estás tan cerca de descifrar el enigma semántico! Pero si sientes que te falta un empujón, aquí tienes una pista:",
            "Tu mente está explorando este campo semántico como un detective, ¡pero incluso los detectives a veces necesitan pistas extra! Así que, aquí va una para ti:",
            "El camino semántico puede volverse un poco sinuoso a veces. No te preocupes, estoy aquí para allanar el camino con una pista:",
            "Las palabras son como piezas de un rompecabezas, y sé que estás cerca de completar la imagen. Aquí va una pista para encajar las piezas restantes:",
            "Estás navegando por las aguas semánticas con destreza, ¡pero incluso los capitanes expertos pueden necesitar un faro de vez en cuando! Aquí está tu faro, tu pista:",
            "La danza de las palabras puede ser complicada, pero no te preocupes, estoy aquí para ser tu guía de baile. Aquí tienes una pista para que sigas moviéndote con gracia:",
        ],
    }

    def reset():
        global i
        i = -1
        return gr.Textbox(visible=False, placeholder=lang[list(lang.keys())[0]], min_width=15),gr.Textbox(visible=False),gr.Image(interactive=False, visible=False),gr.Button("Empezar"),gr.Radio(["SÍ", "NO"], visible=False)
    def change(radio):
        global i
        i = i + 1
        if i == 2 and radio == "NO":
            i = 7
        #   txt=gr.Textbox(lang[list(lang.keys())[i]],visible=True,label='')
        # else:
        txt = gr.Textbox(lang[list(lang.keys())[i]], visible=True, label="")
        return txt

    def button_name(radio):
        global i, difficulty
        output = []
        if i == 1:
            output.extend(
                [
                    gr.Button("Si", visible=False),
                    gr.Radio(["SÍ", "NO"], label="", visible=True),
                ]
            )
        elif i == 2:
            if radio == "NO":
                output.extend(
                    [
                        gr.Button("Introducir", visible=True),
                        gr.Radio(["SÍ", "NO"], visible=False),
                    ]
                )
            else:
                output.extend(
                    [
                        gr.Button("Siguiente", visible=True),
                        gr.Radio(["SÍ", "NO"], visible=False),
                    ]
                )
        elif i == 7:
            output.extend(
                [
                    gr.Button("Siguiente", visible=False),
                    gr.Radio(["Fácil", "Normal", "Dificil", "Experto"], visible=True),
                ]
            )
        elif i == 8:
            if radio == "Fácil":
                difficulty = 1
            elif radio == "Normal":
                difficulty = 2
            elif radio == "Dificil":
                difficulty = 3
            else:
                difficulty = 4
            output.extend(
                [
                    gr.Button("Empezar", visible=True),
                    gr.Radio(["Fácil", "Normal", "Dificil", "Experto"], visible=False),
                ]
            )
            print(difficulty)
        else:
            output.extend(
                [
                    gr.Button("Siguiente", visible=True),
                    gr.Radio(["SÍ", "NO"], label="", visible=False),
                ]
            )
        return output

    img = gr.Image(interactive=False, visible=False)
    out = gr.Textbox(
        visible=False, placeholder=lang[list(lang.keys())[0]], min_width=15
    )
    radio = gr.Radio(["SÍ", "NO"], visible=False)
    with gr.Row():
        inp = gr.Textbox(visible=False)
        but = gr.Button("Empezar")

    but.click(change, inputs=radio, outputs=out)
    radio.input(change, inputs=radio, outputs=out)
    demo.load(reset,outputs=[out,inp,img, but, radio])
    out.change(button_name, inputs=radio, outputs=[but, radio])


if __name__ == "__main__":
    demo.launch()