Update app.py

app.py

@@ -1,117 +1,203 @@
 import gradio as gr
-from transformers import pipeline
+import random
 
-# Load TinyLlama model for text generation
-generator = pipeline("text-generation", model="TinyLlama/TinyLlama-1.1B-Chat-v1.0")
+# Word lists for different categories
+WORD_LISTS = {
+    "animals": ["elephant", "penguin", "giraffe", "dolphin", "tiger", "lion", "zebra"],
+    "food": ["pizza", "burger", "pasta", "sushi", "taco", "cookie", "salad"],
+    "colors": ["purple", "orange", "yellow", "green", "brown", "black", "white"],
+    "countries": ["france", "japan", "india", "brazil", "egypt", "spain", "italy"]
+}
 
-# Store the current story and last options in global variables
-current_story = ""
-last_options = []
+CLUES = {
+    "elephant": [
+        "I am the largest land mammal",
+        "I have a long trunk",
+        "I have big ears and tusks",
+        "I never forget",
+        "I live in Africa or Asia"
+    ],
+    "penguin": [
+        "I am a flightless bird",
+        "I love the cold",
+        "I waddle when I walk",
+        "I wear a natural tuxedo",
+        "I swim very well"
+    ],
+    # Add more pre-generated clues for each word...
+}
 
-def start_story(prompt):
-    global current_story, last_options
-    # Generate the initial story segment
-    formatted_prompt = f"Human: Write a creative story starting with: '{prompt}' in about 100-150 words."
-    story_result = generator(
-        formatted_prompt,
-        max_new_tokens=150,  # ~10 lines (100-150 words)
-        temperature=0.7,
-        top_k=50,
-        do_sample=True,
-        truncation=True
-    )[0]["generated_text"]
-    current_story = story_result.replace(formatted_prompt, "").strip()
-    
-    # Generate story-specific options
-    options_prompt = f"Human: Based on this story: '{current_story}', suggest three distinct options for what happens next. Each option should be 10-20 words and continue the narrative logically."
-    options_result = generator(
-        options_prompt,
-        max_new_tokens=100,  # Enough for 3 options
-        temperature=0.8,     # Slightly higher for variety
-        top_k=50,
-        do_sample=True,
-        truncation=True
-    )[0]["generated_text"]
-    options_text = options_result.replace(options_prompt, "").strip()
-    
-    # Parse options, with fallback if generation is messy
-    options_lines = [line.strip() for line in options_text.split("\n") if line.strip()]
-    last_options = options_lines[:3] if len(options_lines) >= 3 else [
-        "The story took an unexpected twist.",
-        "A new challenge emerged from the shadows.",
-        "The journey led to an unlikely ally."
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.current_word = ""
+        self.clues_shown = 0
+        self.guesses_left = 5
+        self.category = ""
+        
+    def reset(self):
+        self.__init__()
+
+game = GameState()
+
+def get_random_clues(word):
+    """Get pre-written clues or generate simple ones."""
+    if word in CLUES:
+        return CLUES[word]
+    
+    # Fallback clues if word not in CLUES dictionary
+    return [
+        f"This word has {len(word)} letters",
+        f"It starts with '{word[0]}'",
+        f"It ends with '{word[-1]}'",
+        f"It belongs to category: {game.category}",
+        "This is your last clue!"
     ]
+
+def start_game(category):
+    """Start a new game with selected category."""
+    if not category:
+        return "Please select a category first!", "", get_status(), False
     
-    options_display = "\n\n**Choose an option:**\n" + "\n".join([f"{i+1}. {opt}" for i, opt in enumerate(last_options)])
-    return current_story + options_display
+    game.reset()
+    game.category = category
+    game.current_word = random.choice(WORD_LISTS[category])
+    game.clues_shown = 0
+    clue = get_random_clues(game.current_word)[0]
+    
+    return (
+        f"Category: {category}\nFirst clue: {clue}",
+        "",
+        get_status(),
+        True
+    )
 
-def continue_story(option_num):
-    global current_story, last_options
-    if not current_story:
-        return "Please start a story first!"
-    if not last_options or not (1 <= int(option_num) <= 3):
-        return "Invalid option! Choose 1, 2, or 3."
-    
-    # Continue the story with the chosen option
-    chosen_option = last_options[int(option_num) - 1]
-    formatted_prompt = f"Human: Continue this story: '{current_story}' with this direction: '{chosen_option}' in about 100-150 words."
-    story_result = generator(
-        formatted_prompt,
-        max_new_tokens=150,  # ~10 lines
-        temperature=0.7,
-        top_k=50,
-        do_sample=True,
-        truncation=True
-    )[0]["generated_text"]
-    current_story = story_result.replace(formatted_prompt, "").strip()
-    
-    # Generate new story-specific options
-    options_prompt = f"Human: Based on this story: '{current_story}', suggest three distinct options for what happens next. Each option should be 10-20 words and continue the narrative logically."
-    options_result = generator(
-        options_prompt,
-        max_new_tokens=100,
-        temperature=0.8,
-        top_k=50,
-        do_sample=True,
-        truncation=True
-    )[0]["generated_text"]
-    options_text = options_result.replace(options_prompt, "").strip()
-    
-    options_lines = [line.strip() for line in options_text.split("\n") if line.strip()]
-    last_options = options_lines[:3] if len(options_lines) >= 3 else [
-        "The story took an unexpected twist.",
-        "A new challenge emerged from the shadows.",
-        "The journey led to an unlikely ally."
-    ]
+def make_guess(guess, interface_state):
+    """Process the player's guess."""
+    if not interface_state:
+        return "Please start a new game first!", "", get_status(), False
+    
+    if not guess:
+        return "Please enter a guess!", "", get_status(), interface_state
+    
+    guess = guess.lower().strip()
     
-    options_display = "\n\n**Choose an option:**\n" + "\n".join([f"{i+1}. {opt}" for i, opt in enumerate(last_options)])
-    return current_story + options_display
+    if guess == game.current_word:
+        score_increase = (game.guesses_left * 20) - (game.clues_shown * 5)
+        game.score += score_increase
+        return (
+            f"🎉 Correct! +{score_increase} points! The word was: {game.current_word}",
+            "",
+            get_status(),
+            False
+        )
+    
+    game.guesses_left -= 1
+    
+    if game.guesses_left <= 0:
+        return (
+            f"Game Over! The word was: {game.current_word}",
+            "",
+            get_status(),
+            False
+        )
+    
+    feedback = generate_feedback(guess)
+    return feedback, "", get_status(), interface_state
 
-def reset_story():
-    global current_story, last_options
-    current_story = ""
-    last_options = []
-    return "Story reset. Enter a new prompt to begin!"
+def get_hint(interface_state):
+    """Provide next clue for the current word."""
+    if not interface_state:
+        return "Please start a new game first!", "", get_status(), False
+    
+    clues = get_random_clues(game.current_word)
+    game.clues_shown += 1
+    
+    if game.clues_shown >= len(clues):
+        return "No more clues available!", "", get_status(), interface_state
+    
+    return f"Clue #{game.clues_shown + 1}: {clues[game.clues_shown]}", "", get_status(), interface_state
 
-# Create the Gradio interface
-with gr.Blocks(title="AI Story Game") as demo:
-    gr.Markdown("# AI Story Game")
-    gr.Markdown("Start your adventure with a prompt, then guide the story with options or reset it!")
-    
-    # Input for the initial prompt
-    prompt_input = gr.Textbox(label="Start your story with a prompt", placeholder="E.g., 'A thief crept through the shadows...'")
-    output = gr.Textbox(label="Your Story", lines=15)
-    
-    # Option input and buttons
-    option_input = gr.Textbox(label="Enter option number (1-3)", placeholder="E.g., 1", lines=1)
-    start_button = gr.Button("Start Story")
-    continue_button = gr.Button("Continue Story")
-    reset_button = gr.Button("Reset Story")
-    
-    # Connect buttons to functions
-    start_button.click(fn=start_story, inputs=prompt_input, outputs=output)
-    continue_button.click(fn=continue_story, inputs=option_input, outputs=output)
-    reset_button.click(fn=reset_story, inputs=None, outputs=output)
+def generate_feedback(guess):
+    """Generate helpful feedback for incorrect guesses."""
+    word = game.current_word
+    
+    if len(guess) != len(word):
+        return f"The word has {len(word)} letters (your guess had {len(guess)})"
+    
+    correct_pos = sum(1 for a, b in zip(guess, word) if a == b)
+    correct_letters = len(set(guess) & set(word))
+    
+    return f"'{guess}' is not correct. {correct_pos} letters in correct position, {correct_letters} correct letters. {game.guesses_left} guesses left!"
+
+def get_status():
+    """Get current game status."""
+    return f"""
+🎮 Game Status:
+Score: {game.score}
+Guesses Left: {game.guesses_left}
+Hints Used: {game.clues_shown}
+"""
+
+# Gradio interface
+with gr.Blocks(title="Word Guessing Game") as demo:
+    gr.Markdown("# 🎮 Word Guessing Game")
+    gr.Markdown("Guess the word from the clues! Get bonus points for using fewer hints and guesses.")
+    
+    # Game state (hidden)
+    interface_state = gr.State(False)
+    
+    # Game status
+    status_display = gr.Textbox(
+        label="Game Status",
+        value=get_status(),
+        interactive=False
+    )
+    
+    # Category selection
+    category_select = gr.Dropdown(
+        choices=list(WORD_LISTS.keys()),
+        label="Choose Category"
+    )
+    
+    # Game display
+    game_display = gr.Textbox(
+        label="Game Progress",
+        interactive=False,
+        lines=3
+    )
+    
+    # Player input
+    with gr.Row():
+        guess_input = gr.Textbox(
+            label="Your Guess",
+            placeholder="Type your guess here..."
+        )
+        guess_button = gr.Button("🎯 Make Guess")
+    
+    # Hint button
+    hint_button = gr.Button("💡 Get Hint")
+    
+    # Start new game button
+    start_button = gr.Button("🎲 Start New Game")
+    
+    # Event handlers
+    start_button.click(
+        fn=start_game,
+        inputs=[category_select],
+        outputs=[game_display, guess_input, status_display, interface_state]
+    )
+    
+    guess_button.click(
+        fn=make_guess,
+        inputs=[guess_input, interface_state],
+        outputs=[game_display, guess_input, status_display, interface_state]
+    )
+    
+    hint_button.click(
+        fn=get_hint,
+        inputs=[interface_state],
+        outputs=[game_display, guess_input, status_display, interface_state]
+    )
 
-# Launch the app
 demo.launch()