stuff

README.md

@@ -17,8 +17,6 @@ However, you can only say one word at a time, taking turns with another AI.
 
 You need Node.js and npm installed on your system.
 
-Add a .env file with `VITE_MISTRAL_API_KEY=xxx` to query Mistral LLM from your local environment.
-
 ```
 npm i
 npm run dev

src/components/GameContainer.tsx

@@ -1,5 +1,7 @@
 import { useState, KeyboardEvent, useEffect, useContext } from "react";
-import { getRandomWord } from "@/lib/words";
+import { getRandomWord } from "@/lib/words-standard";
+import { getRandomSportsWord } from "@/lib/words-sports";
+import { getRandomFoodWord } from "@/lib/words-food";
 import { motion } from "framer-motion";
 import { generateAIResponse, guessWord } from "@/services/mistralService";
 import { getThemedWord } from "@/services/themeService";
@@ -10,6 +12,7 @@ import { SentenceBuilder } from "./game/SentenceBuilder";
 import { GuessDisplay } from "./game/GuessDisplay";
 import { useTranslation } from "@/hooks/useTranslation";
 import { LanguageContext } from "@/contexts/LanguageContext";
+import { supabase } from "@/integrations/supabase/client";
 
 type GameState = "welcome" | "theme-selection" | "building-sentence" | "showing-guess";
 
@@ -25,6 +28,7 @@ export const GameContainer = () => {
   const [totalWords, setTotalWords] = useState<number>(0);
   const [usedWords, setUsedWords] = useState<string[]>([]);
   const [sessionId, setSessionId] = useState<string>("");
+  const [isHighScoreDialogOpen, setIsHighScoreDialogOpen] = useState(false);
   const { toast } = useToast();
   const t = useTranslation();
   const { language } = useContext(LanguageContext);
@@ -37,13 +41,14 @@ export const GameContainer = () => {
 
   useEffect(() => {
     const handleKeyPress = (e: KeyboardEvent) => {
-      if (e.key === 'Enter') {
+      if (e.key === 'Enter' && !isHighScoreDialogOpen) {
         if (gameState === 'welcome') {
           handleStart();
         } else if (gameState === 'showing-guess') {
-          const correct = isGuessCorrect();
-          if (correct) {
+          if (isGuessCorrect()) {
             handleNextRound();
+          } else {
+            handlePlayAgain();
           }
         }
       }
@@ -51,7 +56,7 @@ export const GameContainer = () => {
 
     window.addEventListener('keydown', handleKeyPress as any);
     return () => window.removeEventListener('keydown', handleKeyPress as any);
-  }, [gameState, aiGuess, currentWord]);
+  }, [gameState, aiGuess, currentWord, isHighScoreDialogOpen]);
 
   const handleStart = () => {
     setGameState("theme-selection");
@@ -72,9 +77,20 @@ export const GameContainer = () => {
   const handleThemeSelect = async (theme: string) => {
     setCurrentTheme(theme);
     try {
-      const word = theme === "standard" ? 
-        getRandomWord(language) : 
-        await getThemedWord(theme, usedWords, language);
+      let word;
+      switch (theme) {
+        case "sports":
+          word = getRandomSportsWord(language);
+          break;
+        case "food":
+          word = getRandomFoodWord(language);
+          break;
+        case "standard":
+          word = getRandomWord(language);
+          break;
+        default:
+          word = await getThemedWord(theme, usedWords, language);
+      }
       setCurrentWord(word);
       setGameState("building-sentence");
       setSuccessfulRounds(0);
@@ -119,6 +135,28 @@ export const GameContainer = () => {
     }
   };
 
+  const saveGameResult = async (sentence: string[], aiGuess: string, isCorrect: boolean) => {
+    try {
+      const { error } = await supabase
+        .from('game_results')
+        .insert({
+          target_word: currentWord,
+          description: sentence.join(' '),
+          ai_guess: aiGuess,
+          is_correct: isCorrect,
+          session_id: sessionId
+        });
+
+      if (error) {
+        console.error('Error saving game result:', error);
+      } else {
+        console.log('Game result saved successfully');
+      }
+    } catch (error) {
+      console.error('Error saving game result:', error);
+    }
+  };
+
   const handleMakeGuess = async () => {
     setIsAiThinking(true);
     try {
@@ -135,6 +173,11 @@ export const GameContainer = () => {
       const sentenceString = finalSentence.join(' ');
       const guess = await guessWord(sentenceString, language);
       setAiGuess(guess);
+      
+      // Save game result in the background
+      saveGameResult(finalSentence, guess, guess.toLowerCase() === currentWord.toLowerCase())
+        .catch(error => console.error('Background save failed:', error));
+      
       setGameState("showing-guess");
     } catch (error) {
       console.error('Error getting AI guess:', error);
@@ -152,9 +195,20 @@ export const GameContainer = () => {
     if (handleGuessComplete()) {
       const getNewWord = async () => {
         try {
-          const word = currentTheme === "standard" ? 
-            getRandomWord(language) : 
-            await getThemedWord(currentTheme, usedWords, language);
+          let word;
+          switch (currentTheme) {
+            case "sports":
+              word = getRandomSportsWord(language);
+              break;
+            case "food":
+              word = getRandomFoodWord(language);
+              break;
+            case "standard":
+              word = getRandomWord(language);
+              break;
+            default:
+              word = await getThemedWord(currentTheme, usedWords, language);
+          }
           setCurrentWord(word);
           setGameState("building-sentence");
           setSentence([]);
@@ -232,13 +286,15 @@ export const GameContainer = () => {
             currentWord={currentWord}
             onNextRound={handleNextRound}
             onPlayAgain={handlePlayAgain}
+            onBack={handleBack}
             currentScore={successfulRounds}
             avgWordsPerRound={getAverageWordsPerRound()}
             sessionId={sessionId}
-            onBack={handleBack}
+            currentTheme={currentTheme}
+            onHighScoreDialogChange={setIsHighScoreDialogOpen}
           />
         )}
       </motion.div>
     </div>
   );
-};
+};

src/components/HighScoreBoard.tsx

@@ -1,26 +1,13 @@
-import { useEffect, useState } from "react";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
+import { useState } from "react";
 import { supabase } from "@/integrations/supabase/client";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import {
-  Table,
-  TableBody,
-  TableCell,
-  TableHead,
-  TableHeader,
-  TableRow,
-} from "@/components/ui/table";
 import { useToast } from "@/components/ui/use-toast";
-import {
-  Pagination,
-  PaginationContent,
-  PaginationItem,
-  PaginationLink,
-  PaginationNext,
-  PaginationPrevious,
-} from "@/components/ui/pagination";
 import { useTranslation } from "@/hooks/useTranslation";
+import { ThemeFilter } from "./game/leaderboard/ThemeFilter";
+import { ScoreSubmissionForm } from "./game/leaderboard/ScoreSubmissionForm";
+import { ScoresTable } from "./game/leaderboard/ScoresTable";
+import { LeaderboardHeader } from "./game/leaderboard/LeaderboardHeader";
+import { LeaderboardPagination } from "./game/leaderboard/LeaderboardPagination";
 
 interface HighScore {
   id: string;
@@ -29,55 +16,52 @@ interface HighScore {
   avg_words_per_round: number;
   created_at: string;
   session_id: string;
+  theme: string;
 }
 
 interface HighScoreBoardProps {
-  currentScore: number;
-  avgWordsPerRound: number;
-  onClose: () => void;
-  onPlayAgain: () => void;
-  sessionId: string;
+  currentScore?: number;
+  avgWordsPerRound?: number;
+  onClose?: () => void;
+  onPlayAgain?: () => void;
+  sessionId?: string;
   onScoreSubmitted?: () => void;
+  showThemeFilter?: boolean;
+  initialTheme?: string;
 }
 
 const ITEMS_PER_PAGE = 5;
-const MAX_PAGES = 5;
-
-const getRankMedal = (rank: number) => {
-  switch (rank) {
-    case 1:
-      return "🥇";
-    case 2:
-      return "🥈";
-    case 3:
-      return "🥉";
-    default:
-      return null;
-  }
-};
 
 export const HighScoreBoard = ({
-  currentScore,
-  avgWordsPerRound,
+  currentScore = 0,
+  avgWordsPerRound = 0,
   onClose,
-  sessionId,
+  sessionId = "",
   onScoreSubmitted,
+  showThemeFilter = true,
+  initialTheme = "standard",
 }: HighScoreBoardProps) => {
   const [playerName, setPlayerName] = useState("");
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [hasSubmitted, setHasSubmitted] = useState(false);
   const [currentPage, setCurrentPage] = useState(1);
+  const [selectedTheme, setSelectedTheme] = useState<'standard' | 'sports' | 'food' | 'custom'>(
+    initialTheme as 'standard' | 'sports' | 'food' | 'custom'
+  );
   const { toast } = useToast();
   const t = useTranslation();
   const queryClient = useQueryClient();
 
-  const { data: highScores, refetch } = useQuery({
-    queryKey: ["highScores"],
+  const showScoreInfo = sessionId !== "" && currentScore > 0;
+
+  const { data: highScores } = useQuery({
+    queryKey: ["highScores", selectedTheme],
     queryFn: async () => {
-      console.log("Fetching high scores...");
+      console.log("Fetching high scores for theme:", selectedTheme);
       const { data, error } = await supabase
         .from("high_scores")
         .select("*")
+        .eq('theme', selectedTheme)
         .order("score", { ascending: false })
         .order("avg_words_per_round", { ascending: true });
 
@@ -120,78 +104,35 @@ export const HighScoreBoard = ({
 
     setIsSubmitting(true);
     try {
-      console.log("Checking existing score for player:", playerName.trim());
-      const { data: existingScores, error: fetchError } = await supabase
-        .from("high_scores")
-        .select("*")
-        .eq("player_name", playerName.trim());
+      console.log("Submitting score via Edge Function...");
+      const { data, error } = await supabase.functions.invoke('submit-high-score', {
+        body: {
+          playerName: playerName.trim(),
+          score: currentScore,
+          avgWordsPerRound,
+          sessionId,
+          theme: selectedTheme
+        }
+      });
 
-      if (fetchError) {
-        console.error("Error fetching existing scores:", fetchError);
-        throw fetchError;
+      if (error) {
+        console.error("Error submitting score:", error);
+        throw error;
       }
 
-      const existingScore = existingScores?.[0];
-      console.log("Existing score found:", existingScore);
-
-      if (existingScore) {
-        if (currentScore > existingScore.score) {
-          console.log("Updating existing score...");
-          const { error: updateError } = await supabase
-            .from("high_scores")
-            .update({
-              score: currentScore,
-              avg_words_per_round: avgWordsPerRound,
-              session_id: sessionId
-            })
-            .eq("id", existingScore.id);
-
-          if (updateError) {
-            console.error("Error updating score:", updateError);
-            throw updateError;
-          }
-
-          toast({
-            title: t.leaderboard.error.newHighScore,
-            description: t.leaderboard.error.beatRecord.replace(
-              "{score}",
-              String(existingScore.score)
-            ),
-          });
-          
-          console.log("Score updated successfully");
-          await queryClient.invalidateQueries({ queryKey: ["highScores"] });
-        } else {
-          toast({
-            title: t.leaderboard.error.notHigher
-              .replace("{current}", String(currentScore))
-              .replace("{best}", String(existingScore.score)),
-            variant: "destructive",
-          });
-          setIsSubmitting(false);
-          return;
-        }
-      } else {
-        console.log("Inserting new score...");
-        const { error: insertError } = await supabase.from("high_scores").insert({
-          player_name: playerName.trim(),
-          score: currentScore,
-          avg_words_per_round: avgWordsPerRound,
-          session_id: sessionId
+      console.log("Score submitted successfully:", data);
+      
+      if (data.success) {
+        toast({
+          title: t.leaderboard.success,
+          description: t.leaderboard.success,
         });
-
-        if (insertError) {
-          console.error("Error inserting score:", insertError);
-          throw insertError;
-        }
         
-        console.log("New score inserted successfully");
+        setHasSubmitted(true);
+        onScoreSubmitted?.();
+        setPlayerName("");
         await queryClient.invalidateQueries({ queryKey: ["highScores"] });
       }
-
-      setHasSubmitted(true);
-      onScoreSubmitted?.();
-      setPlayerName("");
     } catch (error) {
       console.error("Error submitting score:", error);
       toast({
@@ -211,141 +152,47 @@ export const HighScoreBoard = ({
     }
   };
 
-  const totalPages = highScores ? Math.min(Math.ceil(highScores.length / ITEMS_PER_PAGE), MAX_PAGES) : 0;
+  const totalPages = highScores ? Math.ceil(highScores.length / ITEMS_PER_PAGE) : 0;
   const startIndex = (currentPage - 1) * ITEMS_PER_PAGE;
   const paginatedScores = highScores?.slice(startIndex, startIndex + ITEMS_PER_PAGE);
 
-  const handlePreviousPage = () => {
-    if (currentPage > 1) {
-      setCurrentPage(p => p - 1);
-    }
-  };
-
-  const handleNextPage = () => {
-    if (currentPage < totalPages) {
-      setCurrentPage(p => p + 1);
-    }
-  };
-
-  useEffect(() => {
-    const handleKeyDown = (e: KeyboardEvent) => {
-      if (e.key === 'ArrowLeft') {
-        handlePreviousPage();
-      } else if (e.key === 'ArrowRight') {
-        handleNextPage();
-      }
-    };
-
-    window.addEventListener('keydown', handleKeyDown);
-    return () => window.removeEventListener('keydown', handleKeyDown);
-  }, [currentPage, totalPages]);
-
   return (
     <div className="space-y-6">
-      <div className="text-center">
-        <h2 className="text-2xl font-bold mb-2">{t.leaderboard.title}</h2>
-        <p className="text-gray-600">
-          {t.leaderboard.yourScore}: {currentScore} {t.leaderboard.roundCount}
-          {currentScore > 0 &&
-            ` (${avgWordsPerRound.toFixed(1)} ${t.leaderboard.wordsPerRound})`}
-        </p>
-      </div>
+      <LeaderboardHeader
+        currentScore={currentScore}
+        avgWordsPerRound={avgWordsPerRound}
+        showScoreInfo={showScoreInfo}
+      />
+
+      {showThemeFilter && (
+        <ThemeFilter
+          selectedTheme={selectedTheme}
+          onThemeChange={setSelectedTheme}
+        />
+      )}
 
       {!hasSubmitted && currentScore > 0 && (
-        <div className="flex gap-4 mb-6">
-          <Input
-            placeholder={t.leaderboard.enterName}
-            value={playerName}
-            onChange={(e) => {
-              const value = e.target.value.replace(/[^a-zA-ZÀ-ÿ0-9]/g, "");
-              setPlayerName(value);
-            }}
-            onKeyDown={handleKeyDown}
-            className="flex-1"
-            maxLength={20}
-          />
-          <Button
-            onClick={handleSubmitScore}
-            disabled={isSubmitting || !playerName.trim() || hasSubmitted}
-          >
-            {isSubmitting ? t.leaderboard.submitting : t.leaderboard.submit}
-          </Button>
-        </div>
+        <ScoreSubmissionForm
+          playerName={playerName}
+          setPlayerName={setPlayerName}
+          isSubmitting={isSubmitting}
+          hasSubmitted={hasSubmitted}
+          onSubmit={handleSubmitScore}
+          onKeyDown={handleKeyDown}
+        />
       )}
 
-      <div className="rounded-md border">
-        <Table>
-          <TableHeader>
-            <TableRow>
-              <TableHead>{t.leaderboard.rank}</TableHead>
-              <TableHead>{t.leaderboard.player}</TableHead>
-              <TableHead>{t.leaderboard.roundsColumn}</TableHead>
-              <TableHead>{t.leaderboard.avgWords}</TableHead>
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {paginatedScores?.map((score, index) => {
-              const absoluteRank = startIndex + index + 1;
-              const medal = getRankMedal(absoluteRank);
-              return (
-                <TableRow key={score.id}>
-                  <TableCell>
-                    {absoluteRank}
-                    {medal && <span className="ml-2">{medal}</span>}
-                  </TableCell>
-                  <TableCell>{score.player_name}</TableCell>
-                  <TableCell>{score.score}</TableCell>
-                  <TableCell>{score.avg_words_per_round.toFixed(1)}</TableCell>
-                </TableRow>
-              );
-            })}
-            {!paginatedScores?.length && (
-              <TableRow>
-                <TableCell colSpan={4} className="text-center">
-                  {t.leaderboard.noScores}
-                </TableCell>
-              </TableRow>
-            )}
-          </TableBody>
-        </Table>
-      </div>
-
-      {totalPages > 1 && (
-        <Pagination>
-          <PaginationContent>
-            <PaginationItem>
-              <PaginationPrevious
-                onClick={handlePreviousPage}
-                className={currentPage === 1 ? "pointer-events-none opacity-50" : ""}
-              >
-                <span className="hidden sm:inline">{t.leaderboard.previous}</span>
-                <span className="text-xs text-muted-foreground ml-1">←</span>
-              </PaginationPrevious>
-            </PaginationItem>
-            {Array.from({ length: totalPages }, (_, i) => i + 1).map((page) => (
-              <PaginationItem key={page}>
-                <PaginationLink
-                  onClick={() => setCurrentPage(page)}
-                  isActive={currentPage === page}
-                >
-                  {page}
-                </PaginationLink>
-              </PaginationItem>
-            ))}
-            <PaginationItem>
-              <PaginationNext
-                onClick={handleNextPage}
-                className={
-                  currentPage === totalPages ? "pointer-events-none opacity-50" : ""
-                }
-              >
-                <span className="hidden sm:inline">{t.leaderboard.next}</span>
-                <span className="text-xs text-muted-foreground ml-1">→</span>
-              </PaginationNext>
-            </PaginationItem>
-          </PaginationContent>
-        </Pagination>
-      )}
+      <ScoresTable
+        scores={paginatedScores || []}
+        startIndex={startIndex}
+      />
+
+      <LeaderboardPagination
+        currentPage={currentPage}
+        totalPages={totalPages}
+        onPreviousPage={() => setCurrentPage(p => Math.max(1, p - 1))}
+        onNextPage={() => setCurrentPage(p => Math.min(totalPages, p + 1))}
+      />
     </div>
   );
-};
+};

src/components/game/GuessDisplay.tsx

@@ -24,6 +24,8 @@ interface GuessDisplayProps {
   currentScore: number;
   avgWordsPerRound: number;
   sessionId: string;
+  currentTheme: string;
+  onHighScoreDialogChange?: (isOpen: boolean) => void;
 }
 
 export const GuessDisplay = ({
@@ -36,26 +38,25 @@ export const GuessDisplay = ({
   currentScore,
   avgWordsPerRound,
   sessionId,
+  currentTheme,
+  onHighScoreDialogChange,
 }: GuessDisplayProps) => {
   const [showConfirmDialog, setShowConfirmDialog] = useState(false);
   const [hasSubmittedScore, setHasSubmittedScore] = useState(false);
+  const [showHighScores, setShowHighScores] = useState(false);
   const t = useTranslation();
 
-  console.log("GuessDisplay - Rendering with showConfirmDialog:", showConfirmDialog);
+  useEffect(() => {
+    onHighScoreDialogChange?.(showHighScores);
+  }, [showHighScores, onHighScoreDialogChange]);
 
   const handleSetShowConfirmDialog = (show: boolean) => {
-    console.log("GuessDisplay - Setting showConfirmDialog to:", show);
     setShowConfirmDialog(show);
   };
 
-  useEffect(() => {
-    console.log("GuessDisplay - showConfirmDialog changed to:", showConfirmDialog);
-  }, [showConfirmDialog]);
-
   const isGuessCorrect = () => aiGuess.toLowerCase() === currentWord.toLowerCase();
 
   const handleScoreSubmitted = () => {
-    console.log('Score submitted, updating state');
     setHasSubmittedScore(true);
   };
 
@@ -85,8 +86,25 @@ export const GuessDisplay = ({
         currentScore={currentScore}
         avgWordsPerRound={avgWordsPerRound}
         sessionId={sessionId}
+        currentTheme={currentTheme}
         onScoreSubmitted={handleScoreSubmitted}
+        onHighScoreDialogChange={setShowHighScores}
       />
+
+      <Dialog open={showHighScores} onOpenChange={setShowHighScores}>
+        <DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-[600px]">
+          <HighScoreBoard
+            currentScore={currentScore}
+            avgWordsPerRound={avgWordsPerRound}
+            onClose={() => setShowHighScores(false)}
+            onPlayAgain={onPlayAgain}
+            sessionId={sessionId}
+            showThemeFilter={false}
+            initialTheme={currentTheme}
+            onScoreSubmitted={handleScoreSubmitted}
+          />
+        </DialogContent>
+      </Dialog>
     </motion.div>
   );
 };

src/components/game/WelcomeScreen.tsx

@@ -1,13 +1,13 @@
-import { Button } from "@/components/ui/button";
 import { motion } from "framer-motion";
 import { useState } from "react";
 import { HighScoreBoard } from "../HighScoreBoard";
-import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Dialog, DialogContent } from "@/components/ui/dialog";
 import { LanguageSelector } from "./LanguageSelector";
 import { useTranslation } from "@/hooks/useTranslation";
-import { useContext } from "react";
-import { LanguageContext } from "@/contexts/LanguageContext";
-import { Heart } from "lucide-react";
+import { ContestSection } from "./welcome/ContestSection";
+import { HuggingFaceLink } from "./welcome/HuggingFaceLink";
+import { MainActions } from "./welcome/MainActions";
+import { HowToPlayDialog } from "./welcome/HowToPlayDialog";
 
 interface WelcomeScreenProps {
   onStart: () => void;
@@ -17,7 +17,6 @@ export const WelcomeScreen = ({ onStart }: WelcomeScreenProps) => {
   const [showHighScores, setShowHighScores] = useState(false);
   const [showHowToPlay, setShowHowToPlay] = useState(false);
   const t = useTranslation();
-  const { language } = useContext(LanguageContext);
 
   return (
     <>
@@ -35,103 +34,45 @@ export const WelcomeScreen = ({ onStart }: WelcomeScreenProps) => {
           </p>
         </div>
 
-        <div className="space-y-4">
-          <Button
-            onClick={onStart}
-            className="w-full bg-primary text-lg hover:bg-primary/90"
-          >
-            {t.welcome.startButton} ⏎
-          </Button>
-          <div className="grid grid-cols-2 gap-4">
-            <Button
-              onClick={() => setShowHowToPlay(true)}
-              variant="outline"
-              className="text-lg"
-            >
-              {t.welcome.howToPlay} 📖
-            </Button>
-            <Button
-              onClick={() => setShowHighScores(true)}
-              variant="outline"
-              className="text-lg"
-            >
-              {t.welcome.leaderboard} 🏆
-            </Button>
-          </div>
-        </div>
+        <MainActions 
+          onStart={onStart}
+          onShowHowToPlay={() => setShowHowToPlay(true)}
+          onShowHighScores={() => setShowHighScores(true)}
+        />
+      </motion.div>
+
+      <motion.div
+        initial={{ opacity: 0 }}
+        animate={{ opacity: 1 }}
+        transition={{ delay: 0.1 }}
+        className="max-w-2xl mx-auto text-center mt-8"
+      >
+        <ContestSection />
       </motion.div>
 
       <motion.div
         initial={{ opacity: 0 }}
         animate={{ opacity: 1 }}
         transition={{ delay: 0.2 }}
-        className="max-w-2xl mx-auto text-center mt-12 space-y-4"
+        className="max-w-2xl mx-auto text-center mt-8"
       >
-        <p className="text-sm text-gray-500">
-          {t.welcome.credits}{" "}
-          <a 
-            href="https://blog.felixzieger.de/gaming-hackathon-paris/" 
-            target="_blank" 
-            rel="noopener noreferrer"
-            className="text-primary hover:underline"
-          >
-            AI Gaming Hackathon
-          </a>.
-        </p>
-        <div className="flex flex-col items-center gap-2">
-          <p className="text-sm text-gray-600">{t.welcome.helpWin}</p>
-          <a 
-            href="https://huggingface.co/spaces/Mistral-AI-Game-Jam/description-improv/tree/main" 
-            target="_blank" 
-            rel="noopener noreferrer"
-            className="inline-flex flex-col items-center gap-2 px-4 py-2 text-sm font-bold text-primary hover:text-primary/90 transition-colors border border-primary/20 rounded-md hover:border-primary/40"
-          >
-            <span className="inline-flex items-center gap-2">
-              <Heart className="w-4 h-4" /> {t.welcome.onHuggingface}
-            </span>
-          </a>
-        </div>
+        <HuggingFaceLink />
       </motion.div>
 
       <Dialog open={showHighScores} onOpenChange={setShowHighScores}>
         <DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-[600px]">
           <HighScoreBoard
-            currentScore={0}
-            avgWordsPerRound={0}
+            showThemeFilter={true}
             onClose={() => setShowHighScores(false)}
             onPlayAgain={onStart}
-            sessionId=""
           />
         </DialogContent>
       </Dialog>
 
-      <Dialog open={showHowToPlay} onOpenChange={setShowHowToPlay}>
-        <DialogContent className="sm:max-w-[600px]">
-          <DialogHeader>
-            <DialogTitle className="text-xl font-semibold text-primary">{t.welcome.howToPlay}</DialogTitle>
-          </DialogHeader>
-          <div className="space-y-6">
-            <div className="grid gap-4 text-gray-600">
-              <div>
-                <h3 className="font-medium text-gray-800">{t.howToPlay.setup.title}</h3>
-                <p>{t.howToPlay.setup.description}</p>
-              </div>
-              <div>
-                <h3 className="font-medium text-gray-800">{t.howToPlay.goal.title}</h3>
-                <p>{t.howToPlay.goal.description}</p>
-              </div>
-              <div>
-                <h3 className="font-medium text-gray-800">{t.howToPlay.rules.title}</h3>
-                <ul className="list-disc list-inside space-y-1">
-                  {t.howToPlay.rules.items.map((rule, index) => (
-                    <li key={index}>{rule}</li>
-                  ))}
-                </ul>
-              </div>
-            </div>
-          </div>
-        </DialogContent>
-      </Dialog>
+      <HowToPlayDialog 
+        open={showHowToPlay} 
+        onOpenChange={setShowHowToPlay}
+      />
     </>
   );
-};
+};

src/components/game/guess-display/ActionButtons.tsx

@@ -1,8 +1,8 @@
 import { Button } from "@/components/ui/button";
-import { Dialog, DialogContent, DialogTrigger } from "@/components/ui/dialog";
-import { HighScoreBoard } from "@/components/HighScoreBoard";
+import { Dialog, DialogContent } from "@/components/ui/dialog";
 import { useState } from "react";
 import { useTranslation } from "@/hooks/useTranslation";
+import { HighScoreBoard } from "../../HighScoreBoard";
 
 interface ActionButtonsProps {
   isCorrect: boolean;
@@ -11,7 +11,9 @@ interface ActionButtonsProps {
   currentScore: number;
   avgWordsPerRound: number;
   sessionId: string;
-  onScoreSubmitted: () => void;
+  currentTheme: string;
+  onScoreSubmitted?: () => void;
+  onHighScoreDialogChange?: (isOpen: boolean) => void;
 }
 
 export const ActionButtons = ({
@@ -21,52 +23,54 @@ export const ActionButtons = ({
   currentScore,
   avgWordsPerRound,
   sessionId,
+  currentTheme,
   onScoreSubmitted,
+  onHighScoreDialogChange,
 }: ActionButtonsProps) => {
-  const [isDialogOpen, setIsDialogOpen] = useState(false);
+  const [showHighScores, setShowHighScores] = useState(false);
   const t = useTranslation();
 
+  const handleShowHighScores = () => {
+    setShowHighScores(true);
+    onHighScoreDialogChange?.(true);
+  };
+
+  const handleCloseHighScores = () => {
+    setShowHighScores(false);
+    onHighScoreDialogChange?.(false);
+  };
+
   return (
-    <div className="flex flex-col gap-4">
-      {isCorrect ? (
-        <Button
-          onClick={onNextRound}
-          className="w-full bg-primary text-lg hover:bg-primary/90"
-        >
-          {t.guess.nextRound} ⏎
-        </Button>
-      ) : (
-        <>
-          <Dialog open={isDialogOpen} onOpenChange={setIsDialogOpen}>
-            <DialogTrigger asChild>
-              <Button
-                className="w-full bg-secondary text-lg hover:bg-secondary/90"
-              >
-                {t.guess.viewLeaderboard} 🏆
-              </Button>
-            </DialogTrigger>
-            <DialogContent className="max-w-md bg-white">
-              <HighScoreBoard
-                currentScore={currentScore}
-                avgWordsPerRound={avgWordsPerRound}
-                onClose={() => setIsDialogOpen(false)}
-                onPlayAgain={() => {
-                  setIsDialogOpen(false);
-                  onPlayAgain();
-                }}
-                sessionId={sessionId}
-                onScoreSubmitted={onScoreSubmitted}
-              />
-            </DialogContent>
-          </Dialog>
-          <Button
-            onClick={onPlayAgain}
-            className="w-full bg-primary text-lg hover:bg-primary/90"
-          >
-            {t.guess.playAgain} ⏎
-          </Button>
-        </>
-      )}
-    </div>
+    <>
+      <div className="flex justify-center gap-4">
+        {isCorrect ? (
+          <Button onClick={onNextRound} className="text-white">{t.game.nextRound} ⏎</Button>
+        ) : (
+          <>
+            <Button onClick={onPlayAgain} className="text-white">
+              {t.game.playAgain} ⏎
+            </Button>
+            <Button onClick={handleShowHighScores} variant="secondary" className="text-white">
+              {t.game.saveScore}
+            </Button>
+          </>
+        )}
+      </div>
+
+      <Dialog open={showHighScores} onOpenChange={handleCloseHighScores}>
+        <DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-[600px]">
+          <HighScoreBoard
+            currentScore={currentScore}
+            avgWordsPerRound={avgWordsPerRound}
+            onClose={handleCloseHighScores}
+            onPlayAgain={onPlayAgain}
+            sessionId={sessionId}
+            showThemeFilter={false}
+            initialTheme={currentTheme}
+            onScoreSubmitted={onScoreSubmitted}
+          />
+        </DialogContent>
+      </Dialog>
+    </>
   );
 };

src/components/game/leaderboard/LeaderboardHeader.tsx

@@ -0,0 +1,25 @@
+import { useTranslation } from "@/hooks/useTranslation";
+
+interface LeaderboardHeaderProps {
+  currentScore?: number;
+  avgWordsPerRound?: number;
+  showScoreInfo: boolean;
+}
+
+export const LeaderboardHeader = ({ currentScore, avgWordsPerRound, showScoreInfo }: LeaderboardHeaderProps) => {
+  const t = useTranslation();
+
+  return (
+    <div className="text-center">
+      <h2 className="text-2xl font-bold mb-2">{t.leaderboard.title}</h2>
+      {showScoreInfo && currentScore !== undefined && (
+        <p className="text-gray-600">
+          {t.leaderboard.yourScore}: {currentScore} {t.leaderboard.roundCount}
+          {currentScore > 0 &&
+            avgWordsPerRound !== undefined &&
+            ` (${avgWordsPerRound.toFixed(1)} ${t.leaderboard.wordsPerRound})`}
+        </p>
+      )}
+    </div>
+  );
+};

src/components/game/leaderboard/LeaderboardPagination.tsx

@@ -0,0 +1,58 @@
+import {
+  Pagination,
+  PaginationContent,
+  PaginationItem,
+  PaginationLink,
+  PaginationNext,
+  PaginationPrevious,
+} from "@/components/ui/pagination";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { useTranslation } from "@/hooks/useTranslation";
+
+interface LeaderboardPaginationProps {
+  currentPage: number;
+  totalPages: number;
+  onPreviousPage: () => void;
+  onNextPage: () => void;
+}
+
+export const LeaderboardPagination = ({
+  currentPage,
+  totalPages,
+  onPreviousPage,
+  onNextPage,
+}: LeaderboardPaginationProps) => {
+  const t = useTranslation();
+
+  if (totalPages <= 1) return null;
+
+  return (
+    <Pagination>
+      <PaginationContent>
+        <PaginationItem>
+          <PaginationPrevious
+            onClick={onPreviousPage}
+            className={currentPage === 1 ? "pointer-events-none opacity-50" : ""}
+          >
+            <ChevronLeft className="h-4 w-4" />
+            <span className="sr-only">{t.leaderboard.previous}</span>
+          </PaginationPrevious>
+        </PaginationItem>
+        <PaginationItem>
+          <PaginationLink isActive={true}>
+            {currentPage}
+          </PaginationLink>
+        </PaginationItem>
+        <PaginationItem>
+          <PaginationNext
+            onClick={onNextPage}
+            className={currentPage === totalPages ? "pointer-events-none opacity-50" : ""}
+          >
+            <span className="sr-only">{t.leaderboard.next}</span>
+            <ChevronRight className="h-4 w-4" />
+          </PaginationNext>
+        </PaginationItem>
+      </PaginationContent>
+    </Pagination>
+  );
+};

src/components/game/leaderboard/ScoreSubmissionForm.tsx

@@ -0,0 +1,46 @@
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useTranslation } from "@/hooks/useTranslation";
+
+interface ScoreSubmissionFormProps {
+  playerName: string;
+  setPlayerName: (name: string) => void;
+  isSubmitting: boolean;
+  hasSubmitted: boolean;
+  onSubmit: () => Promise<void>;
+  onKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+}
+
+export const ScoreSubmissionForm = ({
+  playerName,
+  setPlayerName,
+  isSubmitting,
+  hasSubmitted,
+  onSubmit,
+  onKeyDown,
+}: ScoreSubmissionFormProps) => {
+  const t = useTranslation();
+
+  return (
+    <div className="flex gap-4 mb-6">
+      <Input
+        placeholder={t.leaderboard.enterName}
+        value={playerName}
+        onChange={(e) => {
+          const value = e.target.value.replace(/[^a-zA-ZÀ-ÿ0-9]/g, "");
+          setPlayerName(value);
+        }}
+        onKeyDown={onKeyDown}
+        className="flex-1"
+        maxLength={20}
+        autoComplete="words"
+      />
+      <Button
+        onClick={onSubmit}
+        disabled={isSubmitting || !playerName.trim() || hasSubmitted}
+      >
+        {isSubmitting ? t.leaderboard.submitting : t.leaderboard.submit}
+      </Button>
+    </div>
+  );
+};

src/components/game/leaderboard/ScoresTable.tsx

@@ -0,0 +1,77 @@
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import { useTranslation } from "@/hooks/useTranslation";
+
+interface HighScore {
+  id: string;
+  player_name: string;
+  score: number;
+  avg_words_per_round: number;
+  created_at: string;
+  session_id: string;
+  theme: string;
+}
+
+interface ScoresTableProps {
+  scores: HighScore[];
+  startIndex: number;
+}
+
+const getRankMedal = (rank: number) => {
+  switch (rank) {
+    case 1:
+      return "🥇";
+    case 2:
+      return "🥈";
+    case 3:
+      return "🥉";
+    default:
+      return rank;
+  }
+};
+
+export const ScoresTable = ({ scores, startIndex }: ScoresTableProps) => {
+  const t = useTranslation();
+
+  return (
+    <div className="rounded-md border">
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>{t.leaderboard.rank}</TableHead>
+            <TableHead>{t.leaderboard.player}</TableHead>
+            <TableHead>{t.leaderboard.roundsColumn}</TableHead>
+            <TableHead>{t.leaderboard.avgWords}</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {scores?.map((score, index) => {
+            const absoluteRank = startIndex + index + 1;
+            const medal = getRankMedal(absoluteRank);
+            return (
+              <TableRow key={score.id}>
+                <TableCell>{medal}</TableCell>
+                <TableCell>{score.player_name}</TableCell>
+                <TableCell>{score.score}</TableCell>
+                <TableCell>{score.avg_words_per_round.toFixed(1)}</TableCell>
+              </TableRow>
+            );
+          })}
+          {!scores?.length && (
+            <TableRow>
+              <TableCell colSpan={4} className="text-center">
+                {t.leaderboard.noScores}
+              </TableCell>
+            </TableRow>
+          )}
+        </TableBody>
+      </Table>
+    </div>
+  );
+};

src/components/game/leaderboard/ThemeFilter.tsx

@@ -0,0 +1,32 @@
+import { Button } from "@/components/ui/button";
+import { useTranslation } from "@/hooks/useTranslation";
+import { Filter } from "lucide-react";
+
+type Theme = 'standard' | 'sports' | 'food' | 'custom';
+
+interface ThemeFilterProps {
+  selectedTheme: Theme;
+  onThemeChange: (theme: Theme) => void;
+}
+
+export const ThemeFilter = ({ selectedTheme, onThemeChange }: ThemeFilterProps) => {
+  const t = useTranslation();
+
+  const themes: Theme[] = ['standard', 'sports', 'food', 'custom'];
+
+  return (
+    <div className="flex flex-wrap gap-2 mb-4 items-center">
+      <Filter className="h-4 w-4 text-gray-500" />
+      {themes.map((theme) => (
+        <Button
+          key={theme}
+          variant={selectedTheme === theme ? "default" : "outline"}
+          size="sm"
+          onClick={() => onThemeChange(theme)}
+        >
+          {t.themes[theme]}
+        </Button>
+      ))}
+    </div>
+  );
+};

src/components/game/sentence-builder/InputForm.tsx

@@ -29,7 +29,6 @@ export const InputForm = ({
   const inputRef = useRef<HTMLInputElement>(null);
   const t = useTranslation();
 
-  // Focus input on mount and after AI response
   useEffect(() => {
     if (!isAiThinking) {
       setTimeout(() => {
@@ -56,7 +55,6 @@ export const InputForm = ({
 
   const error = getInputError();
 
-  // Check if there's either something in the sentence or in the input box
   const canMakeGuess = (sentence.length > 0 || playerInput.trim().length > 0) && 
     !hasMultipleWords && !containsTargetWord && isValidInput && !isAiThinking;
 
@@ -72,6 +70,7 @@ export const InputForm = ({
           placeholder={t.game.inputPlaceholder}
           className={`w-full ${error ? 'border-red-500 focus-visible:ring-red-500' : ''}`}
           disabled={isAiThinking}
+          autoComplete="words"
         />
         {error && (
           <p className="text-sm text-red-500 mt-1">

src/components/game/welcome/ContestSection.tsx

@@ -0,0 +1,45 @@
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from "@/components/ui/dialog";
+import { Info } from "lucide-react";
+import { useTranslation } from "@/hooks/useTranslation";
+
+export const ContestSection = () => {
+  const t = useTranslation();
+  
+  return (
+    <div className="flex flex-col items-center gap-2">
+      <p className="text-lg font-semibold text-primary">🕹️ {t.welcome.contest.prize} 🤑</p>
+      <Dialog>
+        <DialogTrigger asChild>
+          <button className="inline-flex items-center text-sm text-primary/80 hover:text-primary">
+            {t.welcome.contest.terms} <Info className="h-4 w-4 ml-1" />
+          </button>
+        </DialogTrigger>
+        <DialogContent className="sm:max-w-[425px]">
+          <DialogHeader>
+            <DialogTitle>{t.welcome.contest.terms}</DialogTitle>
+          </DialogHeader>
+          <div className="space-y-4">
+            <p className="text-sm text-gray-600">{t.welcome.contest.howTo}</p>
+            <ul className="text-sm text-gray-600 list-disc list-inside">
+              {t.welcome.contest.conditions.map((condition, index) => (
+                <li key={index}>{condition}</li>
+              ))}
+            </ul>
+            <div className="space-y-2">
+              <p className="text-sm text-gray-600">{t.welcome.contest.deadline}</p>
+              <div className="space-y-1">
+                <p className="text-sm font-medium text-gray-800">{t.welcome.contest.prizes.title}</p>
+                <ul className="text-sm text-gray-600 list-none space-y-1">
+                  {t.welcome.contest.prizes.list.map((prize, index) => (
+                    <li key={index}>{prize}</li>
+                  ))}
+                </ul>
+              </div>
+              <p className="text-sm font-medium text-red-600">{t.welcome.contest.fairPlay}</p>
+            </div>
+          </div>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+};

src/components/game/welcome/HowToPlayDialog.tsx

@@ -0,0 +1,41 @@
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { useTranslation } from "@/hooks/useTranslation";
+
+interface HowToPlayDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+
+export const HowToPlayDialog = ({ open, onOpenChange }: HowToPlayDialogProps) => {
+  const t = useTranslation();
+  
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-[600px]">
+        <DialogHeader>
+          <DialogTitle className="text-xl font-semibold text-primary">{t.welcome.howToPlay}</DialogTitle>
+        </DialogHeader>
+        <div className="space-y-6">
+          <div className="grid gap-4 text-gray-600">
+            <div>
+              <h3 className="font-medium text-gray-800">{t.howToPlay.setup.title}</h3>
+              <p>{t.howToPlay.setup.description}</p>
+            </div>
+            <div>
+              <h3 className="font-medium text-gray-800">{t.howToPlay.goal.title}</h3>
+              <p>{t.howToPlay.goal.description}</p>
+            </div>
+            <div>
+              <h3 className="font-medium text-gray-800">{t.howToPlay.rules.title}</h3>
+              <ul className="list-disc list-inside space-y-1">
+                {t.howToPlay.rules.items.map((rule, index) => (
+                  <li key={index}>{rule}</li>
+                ))}
+              </ul>
+            </div>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+};

src/components/game/welcome/HuggingFaceLink.tsx

@@ -0,0 +1,19 @@
+import { Heart } from "lucide-react";
+import { useTranslation } from "@/hooks/useTranslation";
+
+export const HuggingFaceLink = () => {
+  const t = useTranslation();
+  
+  return (
+    <div className="flex flex-col items-center gap-2">
+      <a 
+        href="https://huggingface.co/spaces/Mistral-AI-Game-Jam/description-improv/tree/main" 
+        target="_blank" 
+        rel="noopener noreferrer"
+        className="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium text-primary hover:text-primary/90 transition-colors border border-primary/20 rounded-md hover:border-primary/40"
+      >
+        <Heart className="w-4 h-4" /> {t.welcome.likeOnHuggingface}
+      </a>
+    </div>
+  );
+};

src/components/game/welcome/MainActions.tsx

@@ -0,0 +1,39 @@
+import { Button } from "@/components/ui/button";
+import { useTranslation } from "@/hooks/useTranslation";
+
+interface MainActionsProps {
+  onStart: () => void;
+  onShowHowToPlay: () => void;
+  onShowHighScores: () => void;
+}
+
+export const MainActions = ({ onStart, onShowHowToPlay, onShowHighScores }: MainActionsProps) => {
+  const t = useTranslation();
+  
+  return (
+    <div className="space-y-4">
+      <Button
+        onClick={onStart}
+        className="w-full bg-primary text-lg hover:bg-primary/90"
+      >
+        {t.welcome.startButton} ⏎
+      </Button>
+      <div className="grid grid-cols-2 gap-4">
+        <Button
+          onClick={onShowHowToPlay}
+          variant="outline"
+          className="text-lg"
+        >
+          {t.welcome.howToPlay} 📖
+        </Button>
+        <Button
+          onClick={onShowHighScores}
+          variant="outline"
+          className="text-lg"
+        >
+          {t.welcome.leaderboard} 🏆
+        </Button>
+      </div>
+    </div>
+  );
+};

src/i18n/translations/de.ts

@@ -18,85 +18,110 @@ export const de = {
       leaveGameDescription: "Dein aktueller Fortschritt geht verloren. Bist du sicher, dass du das Spiel verlassen möchtest?",
       cancel: "Abbrechen",
       confirm: "Bestätigen",
-      describeWord: "Dein Ziel ist es folgendes Wort zu beschreiben"
+      describeWord: "Dein Ziel ist es folgendes Wort zu beschreiben",
+      nextRound: "Nächste Runde",
+      playAgain: "Erneut spielen",
+      saveScore: "Punktzahl speichern"
     },
-  leaderboard: {
-    title: "Bestenliste",
-    yourScore: "Deine Punktzahl",
-    roundCount: "Runden",
-    wordsPerRound: "Wörter pro Runde",
-    enterName: "Gib deinen Namen ein",
-    submitting: "Wird übermittelt...",
-    submit: "Punktzahl einreichen",
-    rank: "Rang",
-    player: "Spieler",
-    roundsColumn: "Runden",
-    avgWords: "Ø Wörter",
-    noScores: "Noch keine Punktzahlen",
-    previous: "Vorherige",
-    next: "Nächste",
-    error: {
-      invalidName: "Bitte gib einen gültigen Namen ein",
-      noRounds: "Du musst mindestens eine Runde abschließen",
-      alreadySubmitted: "Punktzahl bereits eingereicht",
-      newHighScore: "Neuer Highscore!",
-      beatRecord: "Du hast deinen bisherigen Rekord von {score} geschlagen!",
-      notHigher: "Punktzahl von {current} nicht höher als dein Bester von {best}",
-      submitError: "Fehler beim Einreichen der Punktzahl"
-    }
-  },
-  guess: {
-    title: "KI-Vermutung",
-    goalDescription: "Dein Ziel war es folgendes Wort zu beschreiben",
-    providedDescription: "Du hast folgende Beschreibung gegeben",
-    aiGuessedDescription: "Basierend auf deiner Beschreibung hat die KI geraten",
-    correct: "Das ist richtig!",
-    incorrect: "Das ist falsch.",
-    nextRound: "Nächste Runde",
-    playAgain: "Erneut spielen",
-    viewLeaderboard: "In Bestenliste eintragen",
-    cheatingDetected: "Betrugsversuch erkannt!"
-  },
-  themes: {
-    title: "Wähle ein Thema",
-    subtitle: "Wähle ein Thema für das Wort, das die KI erraten soll",
-    standard: "Standard",
-    technology: "Technologie",
-    sports: "Sport",
-    food: "Essen",
-    custom: "Benutzerdefiniertes Thema",
-    customPlaceholder: "Gib dein eigenes Thema ein...",
-    continue: "Weiter",
-    generating: "Wird generiert...",
-    pressKey: "Drücke"
-  },
-  welcome: {
-    title: "Think in Sync",
-    subtitle: "Arbeite mit einer KI zusammen, um einen Hinweis zu erstellen, und lass eine andere KI dein geheimes Wort erraten!",
-    startButton: "Spiel starten",
-    howToPlay: "Spielanleitung",
-    leaderboard: "Bestenliste",
-    credits: "Erstellt während des",
-    helpWin: "Hilf uns zu gewinnen",
-    onHuggingface: "mit einem Like auf Huggingface"
-  },
-  howToPlay: {
-    setup: {
-      title: "Vorbereitung",
-      description: "Wähle ein Thema und erhalte ein geheimes Wort, das die KI erraten soll."
+    leaderboard: {
+      title: "Bestenliste",
+      yourScore: "Deine Punktzahl",
+      roundCount: "Runden",
+      wordsPerRound: "Wörter pro Runde",
+      enterName: "Gib deinen Namen ein",
+      submitting: "Wird übermittelt...",
+      submit: "Punktzahl einreichen",
+      rank: "Rang",
+      player: "Spieler",
+      roundsColumn: "Runden",
+      avgWords: "Durchschn. Wörter",
+      noScores: "Noch keine Punktzahlen",
+      previous: "Vorherige",
+      next: "Nächste",
+      success: "Punktzahl erfolgreich übermittelt!",
+      error: {
+        invalidName: "Bitte gib einen gültigen Namen ein",
+        noRounds: "Du musst mindestens eine Runde abschließen",
+        alreadySubmitted: "Punktzahl bereits eingereicht",
+        newHighScore: "Neuer Highscore!",
+        beatRecord: "Du hast deinen bisherigen Rekord von {score} geschlagen!",
+        notHigher: "Punktzahl von {current} nicht höher als dein Bester von {best}",
+        submitError: "Fehler beim Einreichen der Punktzahl"
+      }
+    },
+    guess: {
+      title: "KI-Vermutung",
+      goalDescription: "Dein Ziel war es folgendes Wort zu beschreiben",
+      providedDescription: "Du hast folgende Beschreibung gegeben",
+      aiGuessedDescription: "Basierend auf deiner Beschreibung hat die KI geraten",
+      correct: "Das ist richtig!",
+      incorrect: "Das ist falsch.",
+      nextRound: "Nächste Runde",
+      playAgain: "Erneut spielen",
+      viewLeaderboard: "In Bestenliste eintragen",
+      cheatingDetected: "Betrugsversuch erkannt!"
     },
-    goal: {
-      title: "Ziel",
-      description: "Baue gemeinsam mit der KI Sätze, die dein Wort beschreiben, ohne es direkt zu verwenden."
+    themes: {
+      title: "Wähle ein Thema",
+      subtitle: "Wähle ein Thema für das Wort, das die KI erraten soll",
+      standard: "Standard",
+      technology: "Technologie",
+      sports: "Sport",
+      food: "Essen",
+      custom: "Eigenes Thema",
+      customPlaceholder: "Gib dein eigenes Thema ein...",
+      continue: "Weiter",
+      generating: "Wird generiert...",
+      pressKey: "Drücke",
+      playing: "Thema"
+    },
+    welcome: {
+      title: "Think in Sync",
+      subtitle: "Arbeite mit KI zusammen, um einen Hinweis zu erstellen und lass eine andere KI dein geheimes Wort erraten!",
+      startButton: "Spiel starten",
+      howToPlay: "Spielanleitung",
+      leaderboard: "Bestenliste",
+      credits: "Erstellt während des",
+      contest: {
+        prize: "Spiele und gewinne bis zu 50€!",
+        terms: "Bedingungen ansehen",
+        howTo: "So nimmst du teil:",
+        conditions: [
+          "Spiele Think in Sync mit der Standard-Wortliste",
+          "Setze deinen Bestenlisten-Namen gleich deinem Hugging Face Benutzernamen",
+          "Like unser Projekt auf Hugging Face"
+        ],
+        deadline: "Ende: 5. Februar, 10:00 Uhr",
+        prizes: {
+          title: "Kämpfe um die Top 5 Plätze und gewinne:",
+          list: [
+            "🥇 1. Platz: 50€",
+            "🥈 2. Platz: 20€",
+            "🥉 3. Platz: 10€",
+            "🎖️ 4. & 5. Platz: je 10€"
+          ]
+        },
+        fairPlay: "🚨 Faires Spielen wird überwacht. Betrug führt zur Disqualifikation!"
+      },
+      likeOnHuggingface: "Auf Hugging Face liken"
     },
-    rules: {
-      title: "Regeln",
-      items: [
-        "Füge abwechselnd Wörter hinzu, um beschreibende Sätze zu bilden",
-        "Verwende nicht das geheime Wort oder seine Variationen",
-        "Sei kreativ und beschreibend",
-        "Die KI wird nach jedem Satz versuchen, dein Wort zu erraten"
-      ]
+    howToPlay: {
+      setup: {
+        title: "Vorbereitung",
+        description: "Wähle ein Thema und erhalte ein geheimes Wort, das die KI erraten soll."
+      },
+      goal: {
+        title: "Ziel",
+        description: "Baue gemeinsam mit der KI Sätze, die dein Wort beschreiben, ohne es direkt zu verwenden."
+      },
+      rules: {
+        title: "Regeln",
+        items: [
+          "Füge abwechselnd Wörter hinzu, um beschreibende Sätze zu bilden",
+          "Verwende nicht das geheime Wort oder seine Variationen",
+          "Sei kreativ und beschreibend",
+          "Die KI wird nach jedem Satz versuchen, dein Wort zu erraten"
+        ]
+      }
     }
-  }
-};
+};

src/i18n/translations/en.ts

@@ -18,7 +18,10 @@ export const en = {
       leaveGameDescription: "Your current progress will be lost. Are you sure you want to leave?",
       cancel: "Cancel",
       confirm: "Confirm",
-      describeWord: "Your goal is to describe the word"
+      describeWord: "Your goal is to describe the word",
+      nextRound: "Next Round",
+      playAgain: "Play Again",
+      saveScore: "Save Score"
     },
     leaderboard: {
       title: "High Scores",
@@ -31,10 +34,11 @@ export const en = {
       rank: "Rank",
       player: "Player",
       roundsColumn: "Rounds",
-      avgWords: "Ø Words",
+      avgWords: "Avg. Words",
       noScores: "No scores yet",
       previous: "Previous",
       next: "Next",
+      success: "Score submitted successfully!",
       error: {
         invalidName: "Please enter a valid name",
         noRounds: "You need to complete at least one round",
@@ -59,7 +63,7 @@ export const en = {
     },
     themes: {
       title: "Choose a Theme",
-      subtitle: "Select a theme for the word the AI will try to guess",
+      subtitle: "Select a theme for the word that the AI will try to guess",
       standard: "Standard",
       technology: "Technology",
       sports: "Sports",
@@ -68,7 +72,8 @@ export const en = {
       customPlaceholder: "Enter your custom theme...",
       continue: "Continue",
       generating: "Generating...",
-      pressKey: "Press"
+      pressKey: "Press",
+      playing: "Theme"
     },
     welcome: {
       title: "Think in Sync",
@@ -77,8 +82,28 @@ export const en = {
       howToPlay: "How to Play",
       leaderboard: "Leaderboard",
       credits: "Created during the",
-      helpWin: "Help us win by",
-      onHuggingface: "Liking on Huggingface"
+      contest: {
+        prize: "Play to win up to 50€!",
+        terms: "See Terms",
+        howTo: "How to participate:",
+        conditions: [
+          "Play Think in Sync using the Standard wordlist",
+          "Set your leaderboard name to match your Hugging Face username",
+          "Like our project on Hugging Face"
+        ],
+        deadline: "Ends: February 5, 10:00 AM",
+        prizes: {
+          title: "Compete for the top 5 spots and win:",
+          list: [
+            "🥇 1st: 50€",
+            "🥈 2nd: 20€",
+            "🥉 3rd: 10€",
+            "🎖️ 4th & 5th: 10€ each"
+          ]
+        },
+        fairPlay: "🚨 Fair play is monitored. Any cheating will result in disqualification!"
+      },
+      likeOnHuggingface: "Like on Hugging Face"
     },
     howToPlay: {
       setup: {
@@ -99,4 +124,4 @@ export const en = {
         ]
       }
     }
-};
+};

src/i18n/translations/es.ts

@@ -18,7 +18,10 @@ export const es = {
       leaveGameDescription: "Tu progreso actual se perderá. ¿Estás seguro de que quieres salir?",
       cancel: "Cancelar",
       confirm: "Confirmar",
-      describeWord: "Tu objetivo es describir la palabra"
+      describeWord: "Tu objetivo es describir la palabra",
+      nextRound: "Siguiente Ronda",
+      playAgain: "Jugar de Nuevo",
+      saveScore: "Guardar Puntuación"
     },
     leaderboard: {
       title: "Puntuaciones Más Altas",
@@ -31,10 +34,11 @@ export const es = {
       rank: "Posición",
       player: "Jugador",
       roundsColumn: "Rondas",
-      avgWords: "Ø Palabras",
+      avgWords: "Prom. Palabras",
       noScores: "Aún no hay puntuaciones",
       previous: "Anterior",
       next: "Siguiente",
+      success: "¡Puntuación enviada con éxito!",
       error: {
         invalidName: "Por favor, ingresa un nombre válido",
         noRounds: "Debes completar al menos una ronda",
@@ -68,17 +72,38 @@ export const es = {
       customPlaceholder: "Ingresa tu tema personalizado...",
       continue: "Continuar",
       generating: "Generando...",
-      pressKey: "Presiona"
+      pressKey: "Presiona",
+      playing: "Tema"
     },
     welcome: {
       title: "Think in Sync",
-      subtitle: "¡Haz equipo con una IA para crear una pista y deja que otra IA adivine tu palabra secreta!",
-      startButton: "Comenzar Juego",
-      howToPlay: "Cómo Jugar",
-      leaderboard: "Clasificación",
+      subtitle: "¡Forma equipo con la IA para crear una pista y deja que otra IA adivine tu palabra secreta!",
+      startButton: "Comenzar juego",
+      howToPlay: "Cómo jugar",
+      leaderboard: "Tabla de clasificación",
       credits: "Creado durante el",
-      helpWin: "Ayúdanos a ganar",
-      onHuggingface: "Dando me gusta en Huggingface"
+      contest: {
+        prize: "¡Juega para ganar hasta 50€!",
+        terms: "Ver términos",
+        howTo: "Cómo participar:",
+        conditions: [
+          "Juega Think in Sync usando la lista de palabras estándar",
+          "Establece tu nombre en la tabla de clasificación igual a tu nombre de usuario de Hugging Face",
+          "Dale me gusta a nuestro proyecto en Hugging Face"
+        ],
+        deadline: "Finaliza: 5 de febrero, 10:00 AM",
+        prizes: {
+          title: "Compite por los 5 primeros puestos y gana:",
+          list: [
+            "🥇 1º: 50€",
+            "🥈 2º: 20€",
+            "🥉 3º: 10€",
+            "🎖️ 4º y 5º: 10€ cada uno"
+          ]
+        },
+        fairPlay: "🚨 El juego limpio está monitoreado. ¡Cualquier trampa resultará en descalificación!"
+      },
+      likeOnHuggingface: "Me gusta en Hugging Face"
     },
     howToPlay: {
       setup: {
@@ -99,4 +124,4 @@ export const es = {
         ]
       }
     }
-};
+};

src/i18n/translations/fr.ts

@@ -17,85 +17,110 @@ export const fr = {
       leaveGameDescription: "Votre progression actuelle sera perdue. Êtes-vous sûr de vouloir quitter ?",
       cancel: "Annuler",
       confirm: "Confirmer",
-      describeWord: "Votre objectif est de décrire le mot"
+      describeWord: "Votre objectif est de décrire le mot",
+      nextRound: "Tour Suivant",
+      playAgain: "Rejouer",
+      saveScore: "Sauvegarder le Score"
     },
-  leaderboard: {
-    title: "Meilleurs Scores",
-    yourScore: "Votre Score",
-    roundCount: "tours",
-    wordsPerRound: "mots par tour",
-    enterName: "Entrez votre nom",
-    submitting: "Envoi en cours...",
-    submit: "Soumettre le Score",
-    rank: "Rang",
-    player: "Joueur",
-    roundsColumn: "Tours",
-    avgWords: "Ø Mots",
-    noScores: "Pas encore de scores",
-    previous: "Précédent",
-    next: "Suivant",
-    error: {
-      invalidName: "Veuillez entrer un nom valide",
-      noRounds: "Vous devez compléter au moins un tour",
-      alreadySubmitted: "Score déjà soumis",
-      newHighScore: "Nouveau Record !",
-      beatRecord: "Vous avez battu votre record précédent de {score} !",
-      notHigher: "Score de {current} pas plus élevé que votre meilleur de {best}",
-      submitError: "Erreur lors de la soumission du score"
-    }
-  },
-  guess: {
-    title: "Devinette de l'IA",
-    goalDescription: "Votre objectif était de décrire le mot",
-    providedDescription: "Vous avez fourni la description",
-    aiGuessedDescription: "Basé sur votre description, l'IA a deviné",
-    correct: "C'est correct !",
-    incorrect: "C'est incorrect.",
-    nextRound: "Tour Suivant",
-    playAgain: "Rejouer",
-    viewLeaderboard: "Voir les Scores",
-    cheatingDetected: "Tentative de triche détectée !"
-  },
-  themes: {
-    title: "Choisissez un Thème",
-    subtitle: "Sélectionnez un thème pour le mot que l'IA essaiera de deviner",
-    standard: "Standard",
-    technology: "Technologie",
-    sports: "Sports",
-    food: "Nourriture",
-    custom: "Thème Personnalisé",
-    customPlaceholder: "Entrez votre thème personnalisé...",
-    continue: "Continuer",
-    generating: "Génération...",
-    pressKey: "Appuyez sur"
-  },
-  welcome: {
-    title: "Think in Sync",
-    subtitle: "Faites équipe avec une IA pour créer un indice et laissez une autre IA deviner votre mot secret",
-    startButton: "Commencer",
-    howToPlay: "Comment Jouer",
-    leaderboard: "Classement",
-    credits: "Créé pendant le",
-    helpWin: "Aidez-nous à gagner en",
-    onHuggingface: "Nous aimant sur Huggingface"
-  },
-  howToPlay: {
-    setup: {
-      title: "Mise en place",
-      description: "Choisissez un thème et obtenez un mot secret que l'IA essaiera de deviner."
+    leaderboard: {
+      title: "Meilleurs Scores",
+      yourScore: "Votre Score",
+      roundCount: "tours",
+      wordsPerRound: "mots par tour",
+      enterName: "Entrez votre nom",
+      submitting: "Envoi en cours...",
+      submit: "Soumettre le Score",
+      rank: "Rang",
+      player: "Joueur",
+      roundsColumn: "Tours",
+      avgWords: "Moy. Mots",
+      noScores: "Pas encore de scores",
+      previous: "Précédent",
+      next: "Suivant",
+      success: "Score soumis avec succès !",
+      error: {
+        invalidName: "Veuillez entrer un nom valide",
+        noRounds: "Vous devez compléter au moins un tour",
+        alreadySubmitted: "Score déjà soumis",
+        newHighScore: "Nouveau Record !",
+        beatRecord: "Vous avez battu votre record précédent de {score} !",
+        notHigher: "Score de {current} pas plus élevé que votre meilleur de {best}",
+        submitError: "Erreur lors de la soumission du score"
+      }
+    },
+    guess: {
+      title: "Devinette de l'IA",
+      goalDescription: "Votre objectif était de décrire le mot",
+      providedDescription: "Vous avez fourni la description",
+      aiGuessedDescription: "Basé sur votre description, l'IA a deviné",
+      correct: "C'est correct !",
+      incorrect: "C'est incorrect.",
+      nextRound: "Tour Suivant",
+      playAgain: "Rejouer",
+      viewLeaderboard: "Voir les Scores",
+      cheatingDetected: "Tentative de triche détectée !"
     },
-    goal: {
-      title: "Objectif",
-      description: "Construisez des phrases avec l'IA qui décrivent votre mot sans l'utiliser directement."
+    themes: {
+      title: "Choisissez un Thème",
+      subtitle: "Sélectionnez un thème pour le mot que l'IA essaiera de deviner",
+      standard: "Standard",
+      technology: "Technologie",
+      sports: "Sports",
+      food: "Nourriture",
+      custom: "Thème Personnalisé",
+      customPlaceholder: "Entrez votre thème personnalisé...",
+      continue: "Continuer",
+      generating: "Génération...",
+      pressKey: "Appuyez sur",
+      playing: "Thème"
+    },
+    welcome: {
+      title: "Think in Sync",
+      subtitle: "Faites équipe avec une IA pour créer un indice et laissez une autre IA deviner votre mot secret !",
+      startButton: "Commencer",
+      howToPlay: "Comment Jouer",
+      leaderboard: "Classement",
+      credits: "Créé pendant le",
+      contest: {
+        prize: "Jouez pour gagner jusqu'à 50€ !",
+        terms: "Voir conditions",
+        howTo: "Comment participer :",
+        conditions: [
+          "Jouez à Think in Sync avec la liste de mots standard",
+          "Utilisez votre nom d'utilisateur Hugging Face dans le classement",
+          "Aimez notre projet sur Hugging Face"
+        ],
+        deadline: "Fin : 5 février, 10h00",
+        prizes: {
+          title: "Participez pour les 5 premières places et gagnez :",
+          list: [
+            "🥇 1er : 50€",
+            "🥈 2ème : 20€",
+            "🥉 3ème : 10€",
+            "🎖️ 4ème & 5ème : 10€ chacun"
+          ]
+        },
+        fairPlay: "🚨 Le fair-play est surveillé. Toute triche entraînera une disqualification !"
+      },
+      likeOnHuggingface: "Aimer sur Hugging Face"
     },
-    rules: {
-      title: "Règles",
-      items: [
-        "Ajoutez des mots à tour de rôle pour construire des phrases descriptives",
-        "N'utilisez pas le mot secret ou ses variations",
-        "Soyez créatif et descriptif",
-        "L'IA essaiera de deviner votre mot après chaque phrase"
-      ]
+    howToPlay: {
+      setup: {
+        title: "Mise en place",
+        description: "Choisissez un thème et obtenez un mot secret que l'IA essaiera de deviner."
+      },
+      goal: {
+        title: "Objectif",
+        description: "Construisez des phrases avec l'IA qui décrivent votre mot sans l'utiliser directement."
+      },
+      rules: {
+        title: "Règles",
+        items: [
+          "Ajoutez des mots à tour de rôle pour construire des phrases descriptives",
+          "N'utilisez pas le mot secret ou ses variations",
+          "Soyez créatif et descriptif",
+          "L'IA essaiera de deviner votre mot après chaque phrase"
+        ]
+      }
     }
-  }
-};
+};

src/i18n/translations/it.ts

@@ -18,87 +18,112 @@ export const it = {
       leaveGameDescription: "I tuoi progressi attuali andranno persi. Sei sicuro di voler uscire?",
       cancel: "Annulla",
       confirm: "Conferma",
-      describeWord: "Il tuo obiettivo è descrivere la parola"
+      describeWord: "Il tuo obiettivo è descrivere la parola",
+      nextRound: "Prossimo Turno",
+      playAgain: "Gioca Ancora",
+      saveScore: "Salva Punteggio"
     },
-  leaderboard: {
-    title: "Punteggi Migliori",
-    yourScore: "Il Tuo Punteggio",
-    roundCount: "turni",
-    wordsPerRound: "parole per turno",
-    enterName: "Inserisci il tuo nome",
-    submitting: "Invio in corso...",
-    submit: "Invia Punteggio",
-    rank: "Posizione",
-    player: "Giocatore",
-    roundsColumn: "Turni",
-    avgWords: "Ø Parole",
-    noScores: "Ancora nessun punteggio",
-    previous: "Precedente",
-    next: "Successivo",
-    error: {
-      invalidName: "Inserisci un nome valido",
-      noRounds: "Devi completare almeno un turno",
-      alreadySubmitted: "Punteggio già inviato",
-      newHighScore: "Nuovo Record!",
-      beatRecord: "Hai battuto il tuo record precedente di {score}!",
-      notHigher: "Punteggio di {current} non superiore al tuo migliore di {best}",
-      submitError: "Errore nell'invio del punteggio"
-    }
-  },
-  guess: {
-    title: "Ipotesi dell'IA",
-    sentence: "La tua frase",
-    aiGuessed: "L'IA ha indovinato",
-    goalDescription: "Il tuo obiettivo era descrivere la parola",
-    providedDescription: "Hai fornito la descrizione",
-    aiGuessedDescription: "Basandosi sulla tua descrizione, l'IA ha indovinato",
-    correct: "Corretto! L'IA ha indovinato la parola!",
-    incorrect: "Sbagliato. Riprova!",
-    nextRound: "Prossimo Turno",
-    playAgain: "Gioca Ancora",
-    viewLeaderboard: "Vedi Classifica",
-    cheatingDetected: "Tentativo di imbroglio rilevato!"
-  },
-  themes: {
-    title: "Scegli un Tema",
-    subtitle: "Seleziona un tema per la parola che l'IA cercherà di indovinare",
-    standard: "Standard",
-    technology: "Tecnologia",
-    sports: "Sport",
-    food: "Cibo",
-    custom: "Tema Personalizzato",
-    customPlaceholder: "Inserisci il tuo tema personalizzato...",
-    continue: "Continua",
-    generating: "Generazione...",
-    pressKey: "Premi"
-  },
-  welcome: {
-    title: "Think in Sync",
-    subtitle: "Collabora con un'IA per creare un indizio e lascia che un'altra IA indovini la tua parola segreta!",
-    startButton: "Inizia Gioco",
-    howToPlay: "Come Giocare",
-    leaderboard: "Classifica",
-    credits: "Creato durante il",
-    helpWin: "Aiutaci a vincere",
-    onHuggingface: "Mettendo mi piace su Huggingface"
-  },
-  howToPlay: {
-    setup: {
-      title: "Preparazione",
-      description: "Scegli un tema e ottieni una parola segreta che l'IA cercherà di indovinare."
+    leaderboard: {
+      title: "Punteggi Migliori",
+      yourScore: "Il Tuo Punteggio",
+      roundCount: "turni",
+      wordsPerRound: "parole per turno",
+      enterName: "Inserisci il tuo nome",
+      submitting: "Invio in corso...",
+      submit: "Invia Punteggio",
+      rank: "Posizione",
+      player: "Giocatore",
+      roundsColumn: "Turni",
+      avgWords: "Media Parole",
+      noScores: "Ancora nessun punteggio",
+      previous: "Precedente",
+      next: "Successivo",
+      success: "Punteggio inviato con successo!",
+      error: {
+        invalidName: "Inserisci un nome valido",
+        noRounds: "Devi completare almeno un turno",
+        alreadySubmitted: "Punteggio già inviato",
+        newHighScore: "Nuovo Record!",
+        beatRecord: "Hai battuto il tuo record precedente di {score}!",
+        notHigher: "Punteggio di {current} non superiore al tuo migliore di {best}",
+        submitError: "Errore nell'invio del punteggio"
+      }
+    },
+    guess: {
+      title: "Ipotesi dell'IA",
+      sentence: "La tua frase",
+      aiGuessed: "L'IA ha indovinato",
+      goalDescription: "Il tuo obiettivo era descrivere la parola",
+      providedDescription: "Hai fornito la descrizione",
+      aiGuessedDescription: "Basandosi sulla tua descrizione, l'IA ha indovinato",
+      correct: "Corretto! L'IA ha indovinato la parola!",
+      incorrect: "Sbagliato. Riprova!",
+      nextRound: "Prossimo Turno",
+      playAgain: "Gioca Ancora",
+      viewLeaderboard: "Vedi Classifica",
+      cheatingDetected: "Tentativo di imbroglio rilevato!"
     },
-    goal: {
-      title: "Obiettivo",
-      description: "Costruisci frasi insieme all'IA che descrivono la tua parola senza usarla direttamente."
+    themes: {
+      title: "Scegli un Tema",
+      subtitle: "Seleziona un tema per la parola che l'IA cercherà di indovinare",
+      standard: "Standard",
+      technology: "Tecnologia",
+      sports: "Sport",
+      food: "Cibo",
+      custom: "Tema Personalizzato",
+      customPlaceholder: "Inserisci il tuo tema personalizzato...",
+      continue: "Continua",
+      generating: "Generazione...",
+      pressKey: "Premi",
+      playing: "Tema"
+    },
+    welcome: {
+      title: "Think in Sync",
+      subtitle: "Fai squadra con l'IA per creare un indizio e lascia che un'altra IA indovini la tua parola segreta!",
+      startButton: "Inizia gioco",
+      howToPlay: "Come giocare",
+      leaderboard: "Classifica",
+      credits: "Creato durante il",
+      contest: {
+        prize: "Gioca per vincere fino a 50€!",
+        terms: "Vedi termini",
+        howTo: "Come partecipare:",
+        conditions: [
+          "Gioca a Think in Sync usando la lista di parole standard",
+          "Imposta il tuo nome in classifica uguale al tuo nome utente Hugging Face",
+          "Metti mi piace al nostro progetto su Hugging Face"
+        ],
+        deadline: "Termina: 5 febbraio, 10:00",
+        prizes: {
+          title: "Competi per i primi 5 posti e vinci:",
+          list: [
+            "🥇 1°: 50€",
+            "🥈 2°: 20€",
+            "🥉 3°: 10€",
+            "🎖️ 4° e 5°: 10€ ciascuno"
+          ]
+        },
+        fairPlay: "🚨 Il fair play è monitorato. Qualsiasi imbroglio porterà alla squalifica!"
+      },
+      likeOnHuggingface: "Mi piace su Hugging Face"
     },
-    rules: {
-      title: "Regole",
-      items: [
-        "Aggiungi parole a turno per costruire frasi descrittive",
-        "Non usare la parola segreta o le sue variazioni",
-        "Sii creativo e descrittivo",
-        "L'IA cercherà di indovinare la tua parola dopo ogni frase"
-      ]
+    howToPlay: {
+      setup: {
+        title: "Preparazione",
+        description: "Scegli un tema e ottieni una parola segreta che l'IA cercherà di indovinare."
+      },
+      goal: {
+        title: "Obiettivo",
+        description: "Costruisci frasi insieme all'IA che descrivono la tua parola senza usarla direttamente."
+      },
+      rules: {
+        title: "Regole",
+        items: [
+          "Aggiungi parole a turno per costruire frasi descrittive",
+          "Non usare la parola segreta o le sue variazioni",
+          "Sii creativo e descrittivo",
+          "L'IA cercherà di indovinare la tua parola dopo ogni frase"
+        ]
+      }
     }
-  }
-};
+};

src/integrations/supabase/types.ts

@@ -47,6 +47,7 @@ export type Database = {
           player_name: string
           score: number
           session_id: string
+          theme: string
         }
         Insert: {
           avg_words_per_round: number
@@ -55,6 +56,7 @@ export type Database = {
           player_name: string
           score: number
           session_id: string
+          theme?: string
         }
         Update: {
           avg_words_per_round?: number
@@ -63,6 +65,7 @@ export type Database = {
           player_name?: string
           score?: number
           session_id?: string
+          theme?: string
         }
         Relationships: []
       }
@@ -71,7 +74,16 @@ export type Database = {
       [_ in never]: never
     }
     Functions: {
-      [_ in never]: never
+      check_and_update_high_score: {
+        Args: {
+          p_player_name: string
+          p_score: number
+          p_avg_words_per_round: number
+          p_session_id: string
+          p_theme?: string
+        }
+        Returns: boolean
+      }
     }
     Enums: {
       [_ in never]: never

src/lib/words-food.ts

@@ -0,0 +1,230 @@
+export const englishFoodWords = [
+  "PIZZA",
+  "PASTA",
+  "BREAD",
+  "CHEESE",
+  "APPLE",
+  "BANANA",
+  "ORANGE",
+  "CARROT",
+  "POTATO",
+  "TOMATO",
+  "CHICKEN",
+  "BEEF",
+  "FISH",
+  "RICE",
+  "SOUP",
+  "SALAD",
+  "CAKE",
+  "COOKIE",
+  "CHOCOLATE",
+  "HONEY",
+  "GRAPES",
+  "LEMON",
+  "PEPPER",
+  "ONION",
+  "GARLIC",
+  "CABBAGE",
+  "BROCCOLI",
+  "SPINACH",
+  "MUSHROOM",
+  "PUMPKIN",
+  "ZUCCHINI",
+  "BELL PEPPER",
+  "CORN",
+  "AVOCADO",
+  "YOGURT",
+  "NUTS",
+  "CEREAL",
+  "PUDDING",
+  "JAM"
+];
+
+export const germanFoodWords = [
+  "PIZZA",
+  "NUDELN",
+  "BROT",
+  "KÄSE",
+  "APFEL",
+  "BANANE",
+  "ORANGE",
+  "KAROTTE",
+  "KARTOFFEL",
+  "TOMATE",
+  "HUHN",
+  "RINDFLEISCH",
+  "FISCH",
+  "REIS",
+  "SUPPE",
+  "SALAT",
+  "KUCHEN",
+  "KEKS",
+  "SCHOKOLADE",
+  "HONIG",
+  "TRAUBE",
+  "ZITRONE",
+  "PFEFFER",
+  "ZWIEBEL",
+  "KNOBLAUCH",
+  "KOHLSALAT",
+  "BROKKOLI",
+  "SPINAT",
+  "PILZ",
+  "KÜRBIS",
+  "ZUCCHINI",
+  "BELL-PAPRIKA",
+  "MAIS",
+  "AVOCADO",
+  "JOGHURT",
+  "NÜSSE",
+  "MÜSLI",
+  "PUDDING",
+  "MARMELADE"
+];
+
+export const frenchFoodWords = [
+  "PIZZA",
+  "PÂTES",
+  "PAIN",
+  "FROMAGE",
+  "POMME",
+  "BANANE",
+  "ORANGE",
+  "CAROTTE",
+  "POMMETERRE",
+  "TOMATE",
+  "POULET",
+  "BOEUF",
+  "POISSON",
+  "RIZ",
+  "SOUPE",
+  "SALADE",
+  "GÂTEAU",
+  "BISCUIT",
+  "CHOCOLAT",
+  "MIEL",
+  "RAISIN",
+  "CITRON",
+  "POIVRON",
+  "OIGNON",
+  "AIL",
+  "CHOU",
+  "BROCOLI",
+  "ÉPINARD",
+  "CHAMPIGNON",
+  "COURGE",
+  "COURGETTE",
+  "POIVRON DOUX",
+  "MAÏS",
+  "AVOCAT",
+  "YAOURT",
+  "NOIX",
+  "CÉRÉALES",
+  "CRÈME",
+  "CONFITURE"
+];
+
+export const italianFoodWords = [
+  "PIZZA",
+  "PASTA",
+  "PANE",
+  "FORMAGGIO",
+  "MELA",
+  "BANANA",
+  "ARANCIA",
+  "CAROTA",
+  "PATATA",
+  "POMODORO",
+  "POLLO",
+  "MANZO",
+  "PESCE",
+  "RISO",
+  "ZUPPA",
+  "INSALATA",
+  "TORTA",
+  "BISCOTTO",
+  "CIOCCOLATO",
+  "MIELE",
+  "UVA",
+  "LIMONE",
+  "PEPERONE",
+  "CIPOLLA",
+  "AGLIO",
+  "CAVOLO",
+  "BROCCOLI",
+  "SPINACI",
+  "FUNGHI",
+  "ZUCCA",
+  "ZUCCHINI",
+  "PEPERONE DOLCE",
+  "MAIS",
+  "AVOCADO",
+  "YOGURT",
+  "NOCI",
+  "CEREALI",
+  "CREMA",
+  "MARMELLATA"
+];
+
+export const spanishFoodWords = [
+  "PIZZA",
+  "PASTA",
+  "PAN",
+  "QUESO",
+  "MANZANA",
+  "PLÁTANO",
+  "NARANJA",
+  "ZANAHORIA",
+  "PATATA",
+  "TOMATE",
+  "POLLO",
+  "TERNERA",
+  "PESCADO",
+  "ARROZ",
+  "SOPA",
+  "ENSALADA",
+  "PASTEL",
+  "GALLETA",
+  "CHOCOLATE",
+  "MIEL",
+  "UVAS",
+  "LIMÓN",
+  "PIMIENTA",
+  "CEBOLLA",
+  "AJO",
+  "COL",
+  "BRÓCOLI",
+  "ESPINACA",
+  "CHAMPIÑÓN",
+  "CALABAZA",
+  "CALABACÍN",
+  "PIMIENTO",
+  "MAÍZ",
+  "AGUACATE",
+  "YOGUR",
+  "NUECES",
+  "CEREALES",
+  "CREMA",
+  "MERMELADA"
+];
+
+export const getRandomFoodWord = (language: string = 'en') => {
+  let wordList;
+  switch (language) {
+    case 'de':
+      wordList = germanFoodWords;
+      break;
+    case 'fr':
+      wordList = frenchFoodWords;
+      break;
+    case 'it':
+      wordList = italianFoodWords;
+      break;
+    case 'es':
+      wordList = spanishFoodWords;
+      break;
+    default:
+      wordList = englishFoodWords;
+  }
+  return wordList[Math.floor(Math.random() * wordList.length)];
+};

src/lib/words-sports.ts

@@ -0,0 +1,250 @@
+export const englishSportsWords = [
+  "SOCCER",
+  "TENNIS",
+  "GOLF",
+  "BASEBALL",
+  "BASKETBALL",
+  "VOLLEYBALL",
+  "HOCKEY",
+  "RUGBY",
+  "CRICKET",
+  "SWIMMING",
+  "RUNNING",
+  "CYCLING",
+  "SKIING",
+  "BOXING",
+  "SKATING",
+  "SURFING",
+  "CLIMBING",
+  "DIVING",
+  "SAILING",
+  "WRESTLING",
+  "LACROSSE",
+  "BADMINTON",
+  "FENCING",
+  "ARCHERY",
+  "MMA",
+  "KARATE",
+  "JUDO",
+  "PADDLEBOARDING",
+  "SNOWBOARDING",
+  "BILLIARDS",
+  "DARTS",
+  "GYMNASTICS",
+  "PILATES",
+  "YOGA",
+  "CROSSFIT",
+  "TRIATHLON",
+  "MARATHON",
+  "ULTRAMARATHON",
+  "POLO",
+  "SQUASH",
+  "BOWLING",
+  "CURLING",
+  "SKATEBOARDING",
+  "FLOORBALL",
+  "KITESURFING",
+  "BMX",
+  "TRAMPOLINE",
+  "SOFTBALL",
+  "RINGETTE",
+  "BANDY",
+  "SNOWSHOEING",
+  "PARAGLIDING",
+  "CANYONING",
+  "CAVING"
+];
+
+export const germanSportsWords = [
+  "FUSSBALL",
+  "TENNIS",
+  "GOLF",
+  "BASEBALL",
+  "BASKETBALL",
+  "VOLLEYBALL",
+  "HOCKEY",
+  "RUGBY",
+  "CRICKET",
+  "SCHWIMMEN",
+  "LAUFEN",
+  "RADFAHREN",
+  "SKIFAHREN",
+  "BOXEN",
+  "EISLAUFEN",
+  "SURFEN",
+  "KLETTERN",
+  "TAUCHEN",
+  "SEGELN",
+  "RINGEN",
+  "TURNEN",
+  "BOGENSCHIESSEN",
+  "FECHTEN",
+  "MOTORSPORT",
+  "SCHIESSEN",
+  "REITEN",
+  "HANDBALL",
+  "SNOWBOARDEN",
+  "WASSERBALL",
+  "TRIATHLON",
+  "GEWICHTHEBEN",
+  "JUDO",
+  "TAEKWONDO",
+  "SKATEBOARDEN",
+  "WINDSURFEN",
+  "BADMINTON",
+  "TISCHTENNIS",
+  "SYNCHRONSCHWIMMEN",
+  "RUDERN",
+  "LACROSSE"
+];
+
+export const frenchSportsWords = [
+  "FOOTBALL",
+  "TENNIS",
+  "GOLF",
+  "BASEBALL",
+  "BASKETBALL",
+  "VOLLEYBALL",
+  "HOCKEY",
+  "RUGBY",
+  "CRICKET",
+  "NATATION",
+  "COURSE",
+  "CYCLISME",
+  "SKI",
+  "BOXE",
+  "PATINAGE",
+  "SURF",
+  "ESCALADE",
+  "PLONGÉE",
+  "VOILE",
+  "LUTTE",
+  "GYMNASTIQUE",
+  "TIR À L'ARC",
+  "ESCRIME",
+  "MOTOCYCLISME",
+  "TIR",
+  "ÉQUITATION",
+  "HANDBALL",
+  "SNOWBOARD",
+  "WATER-POLO",
+  "TRIATHLON",
+  "HALTÉROPHILIE",
+  "JUDO",
+  "TAEKWONDO",
+  "SKATEBOARD",
+  "WINDSURF",
+  "BADMINTON",
+  "TENNIS DE TABLE",
+  "NATATION SYNCHRONISÉE",
+  "AVIRON",
+  "LACROSSE"
+];
+
+export const italianSportsWords = [
+  "CALCIO",
+  "TENNIS",
+  "GOLF",
+  "BASEBALL",
+  "PALLACANESTRO",
+  "PALLAVOLO",
+  "HOCKEY",
+  "RUGBY",
+  "CRICKET",
+  "NUOTO",
+  "CORSA",
+  "CICLISMO",
+  "SCI",
+  "PUGILATO",
+  "PATTINAGGIO",
+  "SURF",
+  "ARRAMPICATA",
+  "IMMERSIONE",
+  "VELA",
+  "LOTTA",
+  "GINNASTICA",
+  "TIRO CON L'ARCO",
+  "SCHERMA",
+  "MOTOCICLISMO",
+  "TIRO A SEGNO",
+  "EQUITAZIONE",
+  "PALLAMANO",
+  "SNOWBOARD",
+  "PALLANUOTO",
+  "TRIATHLON",
+  "SOLLEVAMENTO PESI",
+  "JUDO",
+  "TAEKWONDO",
+  "SKATEBOARD",
+  "WINDSURF",
+  "BADMINTON",
+  "PING-PONG",
+  "NUOTO SINCRONIZZATO",
+  "CANOTTAGGIO",
+  "LACROSSE"
+];
+
+export const spanishSportsWords = [
+  "FÚTBOL",
+  "TENIS",
+  "GOLF",
+  "BÉISBOL",
+  "BALONCESTO",
+  "VOLEIBOL",
+  "HOCKEY",
+  "RUGBY",
+  "CRÍQUET",
+  "NATACIÓN",
+  "CARRERA",
+  "CICLISMO",
+  "ESQUÍ",
+  "BOXEO",
+  "PATINAJE",
+  "SURF",
+  "ESCALADA",
+  "BUCEO",
+  "VELA",
+  "LUCHA",
+  "GIMNASIA",
+  "TIRO CON ARCO",
+  "ESGRIMA",
+  "MOTOCICLISMO",
+  "TIRO",
+  "EQUITACIÓN",
+  "BALONMANO",
+  "SNOWBOARD",
+  "WATERPOLO",
+  "TRIATLÓN",
+  "HALTEROFILIA",
+  "JUDO",
+  "TAEKWONDO",
+  "SKATEBOARD",
+  "WINDSURF",
+  "BÁDMINTON",
+  "TENIS DE MESA",
+  "NATACIÓN SINCRONIZADA",
+  "REMO",
+  "LACROSSE"
+];
+
+
+export const getRandomSportsWord = (language: string = 'en') => {
+  let wordList;
+  switch (language) {
+    case 'de':
+      wordList = germanSportsWords;
+      break;
+    case 'fr':
+      wordList = frenchSportsWords;
+      break;
+    case 'it':
+      wordList = italianSportsWords;
+      break;
+    case 'es':
+      wordList = spanishSportsWords;
+      break;
+    default:
+      wordList = englishSportsWords;
+  }
+  return wordList[Math.floor(Math.random() * wordList.length)];
+};

src/lib/words-standard.ts

@@ -0,0 +1,1160 @@
+export const englishWords = [
+  "DOG",
+  "CAT",
+  "SUN",
+  "RAIN",
+  "TREE",
+  "STAR",
+  "MOON",
+  "FISH",
+  "BIRD",
+  "CLOUD",
+  "SKY",
+  "WIND",
+  "SNOW",
+  "FLOWER",
+  "BUTTERFLY",
+  "WATER",
+  "OCEAN",
+  "RIVER",
+  "MOUNTAIN",
+  "FOREST",
+  "HOUSE",
+  "CANDLE",
+  "GARDEN",
+  "BRIDGE",
+  "ISLAND",
+  "BREEZE",
+  "LIGHT",
+  "THUNDER",
+  "RAINBOW",
+  "SMILE",
+  "FRIEND",
+  "FAMILY",
+  "APPLE",
+  "BANANA",
+  "CAR",
+  "BOAT",
+  "BALL",
+  "CAKE",
+  "FROG",
+  "HORSE",
+  "LION",
+  "MONKEY",
+  "PANDA",
+  "PLANE",
+  "TRAIN",
+  "CANDY",
+  "KITE",
+  "BALLOON",
+  "PARK",
+  "BEACH",
+  "TOY",
+  "BOOK",
+  "BUBBLE",
+  "SHELL",
+  "PEN",
+  "ICE",
+  "HAT",
+  "SHOE",
+  "CLOCK",
+  "BED",
+  "CUP",
+  "KEY",
+  "DOOR",
+  "CHICKEN",
+  "DUCK",
+  "SHEEP",
+  "COW",
+  "PIG",
+  "GOAT",
+  "FOX",
+  "BEAR",
+  "DEER",
+  "OWL",
+  "EGG",
+  "NEST",
+  "ROCK",
+  "LEAF",
+  "BRUSH",
+  "TOOTH",
+  "HAND",
+  "FEET",
+  "EYE",
+  "NOSE",
+  "EAR",
+  "MOUTH",
+  "CHILD",
+  "RAINCOAT",
+  "LADDER",
+  "WINDOW",
+  "DOCTOR",
+  "NURSE",
+  "TEACHER",
+  "STUDENT",
+  "PENCIL",
+  "TABLE",
+  "CHAIR",
+  "LAMP",
+  "MIRROR",
+  "BOWL",
+  "PLATE",
+  "SPOON",
+  "FORK",
+  "KNIFE",
+  "GLASS",
+  "STRAW",
+  "RULER",
+  "PAPER",
+  "BASKET",
+  "CARPET",
+  "SOFA",
+  "TELEVISION",
+  "RADIO",
+  "BATTERY",
+  "CANDLE",
+  "FENCE",
+  "MAILBOX",
+  "BRICK",
+  "LANTERN",
+  "WHEEL",
+  "BELL",
+  "UMBRELLA",
+  "TRUCK",
+  "MOTORCYCLE",
+  "BICYCLE",
+  "STOVE",
+  "REFRIGERATOR",
+  "MICROWAVE",
+  "WASHER",
+  "DRYER",
+  "FURNACE",
+  "FAN",
+  "PAINTBRUSH",
+  "BUCKET",
+  "SPONGE",
+  "SOAP",
+  "TOWEL",
+  "CLOTH",
+  "SCISSORS",
+  "TAPE",
+  "RIBBON",
+  "THREAD",
+  "NEEDLE",
+  "BUTTON",
+  "ZIPPER",
+  "SLIPPER",
+  "COAT",
+  "MITTEN",
+  "SCARF",
+  "GLOVE",
+  "PANTS",
+  "SHIRT",
+  "JACKET",
+  "DRESS",
+  "SKIRT",
+  "SOCK",
+  "BOOT",
+  "SANDAL",
+  "HAT",
+  "CAP",
+  "MASK",
+  "SUNGALASSES",
+  "WATCH",
+  "NECKLACE",
+  "BRACELET",
+  "RING",
+  "EARRING",
+  "BACKPACK",
+  "SUITCASE",
+  "TICKET",
+  "PASSPORT",
+  "MAP",
+  "COMPASS",
+  "TORCH",
+  "FLASHLIGHT",
+  "CAMPFIRE",
+  "TENT",
+  "SLEEPINGBAG",
+  "PICNIC",
+  "BENCH",
+  "FENCE",
+  "GATE",
+  "SIGN",
+  "CROSSWALK",
+  "TRAFFICLIGHT",
+  "SIDEWALK",
+  "LANTERN",
+  "BALLOON",
+  "POSTCARD",
+  "STAMP",
+  "LETTER",
+  "ENVELOPE",
+  "PARKING",
+  "STREET",
+  "HIGHWAY",
+  "BRIDGE",
+  "TUNNEL",
+  "STATUE",
+  "FOUNTAIN",
+  "TOWER",
+  "CASTLE",
+  "PYRAMID",
+  "PLANET",
+  "GALAXY",
+  "SATELLITE",
+  "ASTRONAUT",
+  "TELESCOPE",
+  "MICROSCOPE",
+  "MAGNET",
+  "BATTERY",
+  "BULB",
+  "SOCKET",
+  "PLUG",
+  "WIRE",
+  "SWITCH",
+  "CIRCUIT",
+  "ROBOT",
+  "COMPUTER",
+  "MOUSE",
+  "KEYBOARD",
+  "SCREEN",
+  "PRINTER",
+  "SPEAKER",
+  "HEADPHONE",
+  "PHONE",
+  "CAMERA"
+];
+
+export const germanWords = [
+  "HUND",
+  "KATZE",
+  "SONNE",
+  "REGEN",
+  "BAUM",
+  "STERN",
+  "MOND",
+  "FISCH",
+  "VOGEL",
+  "WOLKE",
+  "HIMMEL",
+  "WIND",
+  "SCHNEE",
+  "BLUME",
+  "SCHMETTERLING",
+  "WASSER",
+  "OZEAN",
+  "FLUSS",
+  "BERG",
+  "WALD",
+  "HAUS",
+  "KERZE",
+  "GARTEN",
+  "BRÜCKE",
+  "INSEL",
+  "BRISE",
+  "LICHT",
+  "DONNER",
+  "REGENBOGEN",
+  "LÄCHELN",
+  "FREUND",
+  "FAMILIE",
+  "APFEL",
+  "BANANE",
+  "AUTO",
+  "BOOT",
+  "BALL",
+  "KUCHEN",
+  "FROSCH",
+  "PFERD",
+  "LÖWE",
+  "AFFE",
+  "PANDA",
+  "FLUGZEUG",
+  "ZUG",
+  "SÜSSIGKEIT",
+  "DRACHEN",
+  "BALLON",
+  "PARK",
+  "STRAND",
+  "SPIELZEUG",
+  "BUCH",
+  "BLASE",
+  "MUSCHEL",
+  "STIFT",
+  "EIS",
+  "HUT",
+  "SCHUH",
+  "UHR",
+  "BETT",
+  "TASSE",
+  "SCHLÜSSEL",
+  "TÜR",
+  "HÜHNCHEN",
+  "ENTE",
+  "SCHAF",
+  "KUH",
+  "SCHWEIN",
+  "ZIEGE",
+  "FUCHS",
+  "BÄR",
+  "REH",
+  "EULE",
+  "EI",
+  "NEST",
+  "STEIN",
+  "BLATT",
+  "PINSEL",
+  "ZAHN",
+  "HAND",
+  "FÜSSE",
+  "AUGE",
+  "NASE",
+  "OHR",
+  "MUND",
+  "KIND",
+  "REGENMANTEL",
+  "LEITER",
+  "FENSTER",
+  "ARZT",
+  "KRANKENSCHWESTER",
+  "LEHRER",
+  "STUDENT",
+  "BLEISTIFT",
+  "TISCH",
+  "STUHL",
+  "LAMPE",
+  "SPIEGEL",
+  "SCHÜSSEL",
+  "TELLER",
+  "LÖFFEL",
+  "GABEL",
+  "MESSER",
+  "GLAS",
+  "STROHHALM",
+  "LINEAL",
+  "PAPIER",
+  "KORB",
+  "TEPPICH",
+  "SOFA",
+  "FERNSEHER",
+  "RADIO",
+  "BATTERIE",
+  "KERZE",  // duplicate
+  "ZAUN",
+  "BRIEFKASTEN",
+  "BACKSTEIN",
+  "LATERNE",
+  "RAD",
+  "GLOCKE",
+  "REGENSCHIRM",
+  "LASTWAGEN",
+  "MOTORRAD",
+  "FAHRRAD",
+  "HERD",
+  "KÜHLSCHRANK",
+  "MIKROWELLE",
+  "WASCHMASCHINE",
+  "TROCKNER",
+  "OFEN",
+  "VENTILATOR",
+  "PINSEL",   // paintbrush (same as index 78 but used for “brush” too)
+  "EIMER",
+  "SCHWAMM",
+  "SEIFE",
+  "HANDTUCH",
+  "STOFF",
+  "SCHERE",
+  "KLEBEBAND",
+  "BAND",
+  "FADEN",
+  "NADEL",
+  "KNOPF",
+  "REISSVERSCHLUSS",
+  "HAUSSCHUH",
+  "MANTEL",
+  "FAUSTHANDSCHUH",
+  "SCHAL",
+  "HANDSCHUH",
+  "HOSE",
+  "HEMD",
+  "JACKE",
+  "KLEID",
+  "ROCK",
+  "SOCKE",
+  "STIEFEL",
+  "SANDALE",
+  "HUT",  // duplicate
+  "MÜTZE",
+  "MASKE",
+  "SONNENBRILLE",
+  "UHR",
+  "HALSKETTE",
+  "ARMBAND",
+  "RING",
+  "OHRRING",
+  "RUCKSACK",
+  "KOFFER",
+  "TICKET",
+  "REISEPASS",
+  "KARTE",
+  "KOMPASS",
+  "FACKEL",
+  "TASCHENLAMPE",
+  "LAGERFEUER",
+  "ZELT",
+  "SCHLAFSACK",
+  "PICKNICK",
+  "BANK",
+  "ZAUN",     // duplicate
+  "TOR",
+  "SCHILD",
+  "ZEBRASTREIFEN",
+  "VERKEHRSAMPEL",
+  "BÜRGERSTEIG",
+  "LATERNE",  // duplicate
+  "BALLON",   // duplicate
+  "POSTKARTE",
+  "BRIEFMARKE",
+  "BRIEF",
+  "UMSCHLAG",
+  "PARKPLATZ",
+  "STRAßE",
+  "AUTOBAHN",
+  "BRÜCKE",  // duplicate
+  "TUNNEL",
+  "STATUE",
+  "BRUNNEN",
+  "TURM",
+  "SCHLOSS",
+  "PYRAMIDE",
+  "PLANET",
+  "GALAXIE",
+  "SATELLIT",
+  "ASTRONAUT",
+  "TELESKOP",
+  "MIKROSKOP",
+  "MAGNET",
+  "BATTERIE", // duplicate
+  "GLÜHBIRNE",
+  "STECKDOSE",
+  "STECKER",
+  "DRAHT",
+  "SCHALTER",
+  "SCHALTUNG",
+  "ROBOTER",
+  "COMPUTER",
+  "MAUS",
+  "TASTATUR",
+  "BILDSCHIRM",
+  "DRUCKER",
+  "LAUTSPRECHER",
+  "KOPFHÖRER",
+  "TELEFON",
+  "KAMERA"
+];
+
+export const frenchWords = [
+  "CHIEN",
+  "CHAT",
+  "SOLEIL",
+  "PLUIE",
+  "ARBRE",
+  "ÉTOILE",
+  "LUNE",
+  "POISSON",
+  "OISEAU",
+  "NUAGE",
+  "CIEL",
+  "VENT",
+  "NEIGE",
+  "FLEUR",
+  "PAPILLON",
+  "EAU",
+  "OCÉAN",
+  "FLEUVE",
+  "MONTAGNE",
+  "FORÊT",
+  "MAISON",
+  "BOUGIE",
+  "JARDIN",
+  "PONT",
+  "ÎLE",
+  "BRISE",
+  "LUMIÈRE",
+  "TONNERRE",
+  "ARC-EN-CIEL",
+  "SOURIRE",
+  "AMI",
+  "FAMILLE",
+  "POMME",
+  "BANANE",
+  "VOITURE",
+  "BATEAU",
+  "BALLE",
+  "GÂTEAU",
+  "GRENOUILLE",
+  "CHEVAL",
+  "LION",
+  "SINGE",
+  "PANDA",
+  "AVION",
+  "TRAIN",
+  "BONBON",
+  "CERF-VOLANT",
+  "BALLON",
+  "PARC",
+  "PLAGE",
+  "JOUET",
+  "LIVRE",
+  "BULLE",
+  "COQUILLAGE",
+  "STYLO",
+  "GLACE",
+  "CHAPEAU",
+  "CHAUSSURE",
+  "HORLOGE",
+  "LIT",
+  "TASSE",
+  "CLÉ",
+  "PORTE",
+  "POULET",
+  "CANARD",
+  "MOUTON",
+  "VACHE",
+  "COCHON",
+  "CHÈVRE",
+  "RENARD",
+  "OURS",
+  "CERF",
+  "HIBOU",
+  "ŒUF",
+  "NID",
+  "ROCHE",
+  "FEUILLE",
+  "PINCEAU",
+  "DENT",
+  "MAIN",
+  "PIEDS",
+  "ŒIL",
+  "NEZ",
+  "OREILLE",
+  "BOUCHE",
+  "ENFANT",
+  "IMPERMÉABLE",
+  "ÉCHELLE",
+  "FENÊTRE",
+  "MÉDECIN",
+  "INFIRMIÈRE",
+  "ENSEIGNANT",
+  "ÉTUDIANT",
+  "CRAYON",
+  "TABLE",
+  "CHAISE",
+  "LAMPE",
+  "MIROIR",
+  "BOL",
+  "ASSIETTE",
+  "CUILLÈRE",
+  "FOURCHETTE",
+  "COUTEAU",
+  "VERRE",
+  "PAILLE",
+  "RÈGLE",
+  "PAPIER",
+  "PANIER",
+  "TAPIS",
+  "CANAPÉ",
+  "TÉLÉVISION",
+  "RADIO",
+  "PILE",
+  "BOUGIE", // duplicate
+  "CLÔTURE",
+  "BOÎTE AUX LETTRES",
+  "BRIQUE",
+  "LANTERNE",
+  "ROUE",
+  "CLOCHE",
+  "PARAPLUIE",
+  "CAMION",
+  "MOTO",
+  "VÉLO",
+  "CUISINIÈRE",
+  "RÉFRIGÉRATEUR",
+  "MICRO-ONDES",
+  "LAVE-LINGE",
+  "SÈCHE-LINGE",
+  "FOURNAISE",
+  "VENTILATEUR",
+  "PINCEAU", // paintbrush
+  "SEAU",
+  "ÉPONGE",
+  "SAVON",
+  "SERVIETTE",
+  "TISSU",
+  "CISEAUX",
+  "SCOTCH",
+  "RUBAN",
+  "FIL",
+  "AIGUILLE",
+  "BOUTON",
+  "FERMETURE ÉCLAIR",
+  "PANTOUFLE",
+  "MANTEAU",
+  "MOUFLE",
+  "ÉCHARPE",
+  "GANT",
+  "PANTALON",
+  "CHEMISE",
+  "VESTE",
+  "ROBE",
+  "JUPE",
+  "CHAUSSETTE",
+  "BOTTE",
+  "SANDALE",
+  "CHAPEAU", // duplicate
+  "CASQUETTE",
+  "MASQUE",
+  "LUNETTES DE SOLEIL",
+  "MONTRE",
+  "COLLIER",
+  "BRACELET",
+  "BAGUE",
+  "BOUCLE D'OREILLE",
+  "SAC À DOS",
+  "VALISE",
+  "BILLET",
+  "PASSEPORT",
+  "CARTE",
+  "BOUSSOLE",
+  "TORCHE",
+  "LAMPE DE POCHE",
+  "FEU DE CAMP",
+  "TENTE",
+  "SAC DE COUCHAGE",
+  "PIQUE-NIQUE",
+  "BANC",
+  "CLÔTURE", // duplicate
+  "PORTAIL",
+  "PANNEAU",
+  "PASSAGE PIÉTON",
+  "FEU DE SIGNALISATION",
+  "TROTTOIR",
+  "LANTERNE", // duplicate
+  "BALLON",   // duplicate
+  "CARTE POSTALE",
+  "TIMBRE",
+  "LETTRE",
+  "ENVELOPPE",
+  "PARKING",
+  "RUE",
+  "AUTOROUTE",
+  "PONT",     // duplicate
+  "TUNNEL",
+  "STATUE",
+  "FONTAINE",
+  "TOUR",
+  "CHÂTEAU",
+  "PYRAMIDE",
+  "PLANÈTE",
+  "GALAXIE",
+  "SATELLITE",
+  "ASTRONAUTE",
+  "TÉLESCOPE",
+  "MICROSCOPE",
+  "AIMANT",
+  "PILE",    // duplicate
+  "AMPOULE",
+  "PRISE",
+  "FICHE",
+  "FIL",
+  "INTERRUPTEUR",
+  "CIRCUIT",
+  "ROBOT",
+  "ORDINATEUR",
+  "SOURIS",
+  "CLAVIER",
+  "ÉCRAN",
+  "IMPRIMANTE",
+  "HAUT-PARLEUR",
+  "CASQUE",
+  "TÉLÉPHONE",
+  "APPAREIL PHOTO"
+];
+
+export const italianWords = [
+  "CANE",
+  "GATTO",
+  "SOLE",
+  "PIOGGIA",
+  "ALBERO",
+  "STELLA",
+  "LUNA",
+  "PESCE",
+  "UCCELLO",
+  "NUVOLA",
+  "CIELO",
+  "VENTO",
+  "NEVE",
+  "FIORE",
+  "FARFALLA",
+  "ACQUA",
+  "OCEANO",
+  "FIUME",
+  "MONTAGNA",
+  "FORESTA",
+  "CASA",
+  "CANDELA",
+  "GIARDINO",
+  "PONTE",
+  "ISOLA",
+  "BREZZA",
+  "LUCE",
+  "TUONO",
+  "ARCOBALENO",
+  "SORRISO",
+  "AMICO",
+  "FAMIGLIA",
+  "MELA",
+  "BANANA",
+  "AUTO",
+  "BARCA",
+  "PALLA",
+  "TORTA",
+  "RANA",
+  "CAVALLO",
+  "LEONE",
+  "SCIMMIA",
+  "PANDA",
+  "AEREO",
+  "TRENO",
+  "CARAMELLA",
+  "AQUILONE",
+  "PALLONCINO",
+  "PARCO",
+  "SPIAGGIA",
+  "GIOCATTOLO",
+  "LIBRO",
+  "BOLLA",
+  "CONCHIGLIA",
+  "PENNA",
+  "GHIACCIO",
+  "CAPPELLO",
+  "SCARPA",
+  "OROLOGIO",
+  "LETTO",
+  "TAZZA",
+  "CHIAVE",
+  "PORTA",
+  "POLLO",
+  "ANATRA",
+  "PECORA",
+  "MUCCA",
+  "MAIALE",
+  "CAPRA",
+  "VOLPE",
+  "ORSO",
+  "CERVO",
+  "GUFO",
+  "UOVO",
+  "NIDO",
+  "ROCCIA",
+  "FOGLIA",
+  "PENNELLO",
+  "DENTE",
+  "MANO",
+  "PIEDI",
+  "OCCHIO",
+  "NASO",
+  "ORECCHIO",
+  "BOCCA",
+  "BAMBINO",
+  "IMPERMEABILE",
+  "SCALA",
+  "FINESTRA",
+  "MEDICO",
+  "INFERMIERA",
+  "INSEGNANTE",
+  "STUDENTE",
+  "MATITA",
+  "TAVOLO",
+  "SEDIA",
+  "LAMPADA",
+  "SPECCHIO",
+  "CIOTOLA",
+  "PIATTO",
+  "CUCCHIAIO",
+  "FORCHETTA",
+  "COLTELLO",
+  "BICCHIERE",
+  "CANNUCCIA",
+  "RIGHELLO",
+  "CARTA",
+  "CESTINO",
+  "TAPPETO",
+  "DIVANO",
+  "TELEVISIONE",
+  "RADIO",
+  "BATTERIA",
+  "CANDELA",  // duplicate
+  "RECINTO",
+  "CASSETTA DELLE LETTERE",
+  "MATTONE",
+  "LANTERNA",
+  "RUOTA",
+  "CAMPANA",
+  "OMBRELLO",
+  "CAMION",
+  "MOTOCICLETTA",
+  "BICICLETTA",
+  "FORNELLO",
+  "FRIGORIFERO",
+  "MICROONDE",
+  "LAVATRICE",
+  "ASCIUGATRICE",
+  "FORNO",
+  "VENTILATORE",
+  "PENNELLO", // paintbrush
+  "SECCHIO",
+  "SPUGNA",
+  "SAPONE",
+  "ASCIUGAMANO",
+  "PANNO",
+  "FORBICI",
+  "NASTRO ADESIVO",
+  "NASTRO",
+  "FILO",
+  "AGO",
+  "BOTTONE",
+  "CERNIERA",
+  "PANTOFOLA",
+  "CAPPOTTO",
+  "MOFFOLA",
+  "SCIARPA",
+  "GUANTO",
+  "PANTALONI",
+  "CAMICIA",
+  "GIACCA",
+  "VESTITO",
+  "GONNA",
+  "CALZINO",
+  "STIVALE",  // corrected translation for BOOT
+  "SANDALO",
+  "CAPPELLO", // duplicate
+  "BERRETTO", // instead of MÜTZE, let's keep it consistent in Italian
+  "MASCHERA",
+  "OCCHIALI DA SOLE",
+  "OROLOGIO",
+  "COLLANA",
+  "BRACCIALETTO",
+  "ANELLO",
+  "ORECCHINO",
+  "ZAINO",
+  "VALIGIA",
+  "BIGLIETTO",
+  "PASSAPORTO",
+  "CARTINA",
+  "BUSSOLA",
+  "TORCIA",
+  "TORCIA ELETTRICA",
+  "FALÒ",
+  "TENDA",
+  "SACCO A PELO",
+  "PICNIC",
+  "PANCHINA",
+  "RECINTO", // duplicate
+  "CANCELLO",
+  "SEGNALE",
+  "STRISCE PEDONALI",
+  "SEMAFORO",
+  "MARCIAPIEDE",
+  "LANTERNA", // duplicate
+  "PALLONCINO", // duplicate
+  "CARTOLINA",
+  "FRANCOBOLLO",
+  "LETTERA",
+  "BUSTA",
+  "PARCHEGGIO",
+  "STRADA",
+  "AUTOSTRADA",
+  "PONTE",     // duplicate
+  "TUNNEL",
+  "STATUA",
+  "FONTANA",
+  "TORRE",
+  "CASTELLO",
+  "PIRAMIDE",
+  "PIANETA",
+  "GALASSIA",
+  "SATELLITE",
+  "ASTRONAUTA",
+  "TELESCOPIO",
+  "MICROSCOPIO",
+  "MAGNETE",
+  "BATTERIA", // duplicate
+  "LAMPADINA",
+  "PRESA",
+  "SPINA",
+  "FILO",
+  "INTERRUTTORE",
+  "CIRCUITO",
+  "ROBOT",
+  "COMPUTER",
+  "MOUSE",
+  "TASTIERA",
+  "SCHERMO",
+  "STAMPANTE",
+  "ALTOPARLANTE",
+  "CUFFIE",
+  "TELEFONO",
+  "FOTOCAMERA"
+];
+
+export const spanishWords = [
+  "PERRO",
+  "GATO",
+  "SOL",
+  "LLUVIA",
+  "ÁRBOL",
+  "ESTRELLA",
+  "LUNA",
+  "PEZ",
+  "PÁJARO",
+  "NUBE",
+  "CIELO",
+  "VIENTO",
+  "NIEVE",
+  "FLOR",
+  "MARIPOSA",
+  "AGUA",
+  "OCÉANO",
+  "RÍO",
+  "MONTAÑA",
+  "BOSQUE",
+  "CASA",
+  "VELA",
+  "JARDÍN",
+  "PUENTE",
+  "ISLA",
+  "BRISA",
+  "LUZ",
+  "TRUENO",
+  "ARCOÍRIS",
+  "SONRISA",
+  "AMIGO",
+  "FAMILIA",
+  "MANZANA",
+  "BANANA",
+  "COCHE",
+  "BARCO",
+  "PELOTA",
+  "PASTEL",
+  "RANA",
+  "CABALLO",
+  "LEÓN",
+  "MONO",
+  "OSO PANDA",
+  "AVIÓN",
+  "TREN",
+  "CARAMELO",
+  "COMETA",
+  "GLOBO",
+  "PARQUE",
+  "PLAYA",
+  "JUGUETE",
+  "LIBRO",
+  "BURBUJA",
+  "CONCHA",
+  "BOLÍGRAFO",
+  "HIELO",
+  "SOMBRERO",
+  "ZAPATO",
+  "RELOJ",
+  "CAMA",
+  "TAZA",
+  "LLAVE",
+  "PUERTA",
+  "POLLO",
+  "PATO",
+  "OVEJA",
+  "VACA",
+  "CERDO",
+  "CABRA",
+  "ZORRO",
+  "OSO",
+  "CIERVO",
+  "BÚHO",
+  "HUEVO",
+  "NIDO",
+  "ROCA",
+  "HOJA",
+  "PINCEL",
+  "DIENTE",
+  "MANO",
+  "PIES",
+  "OJO",
+  "NARIZ",
+  "OREJA",
+  "BOCA",
+  "NIÑO",
+  "IMPERMEABLE",
+  "ESCALERA",
+  "VENTANA",
+  "MÉDICO",
+  "ENFERMERA",
+  "MAESTRO",
+  "ESTUDIANTE",
+  "LÁPIZ",
+  "MESA",
+  "SILLA",
+  "LÁMPARA",
+  "ESPEJO",
+  "CUENCO",
+  "PLATO",
+  "CUCHARA",
+  "TENEDOR",
+  "CUCHILLO",
+  "VASO",
+  "PAJITA",
+  "REGLA",
+  "PAPEL",
+  "CESTA",
+  "ALFOMBRA",
+  "SOFÁ",
+  "TELEVISIÓN",
+  "RADIO",
+  "BATERÍA",
+  "VELA",      // duplicate
+  "VALLA",
+  "BUZÓN",
+  "LADRILLO",
+  "FAROL",
+  "RUEDA",
+  "CAMPANA",
+  "PARAGUAS",
+  "CAMIÓN",
+  "MOTOCICLETA",
+  "BICICLETA",
+  "ESTUFA",
+  "REFRIGERADOR",
+  "MICROONDAS",
+  "LAVADORA",
+  "SECADORA",
+  "HORNO",
+  "VENTILADOR",
+  "PINCEL",    // paintbrush
+  "CUBO",
+  "ESPONJA",
+  "JABÓN",
+  "TOALLA",
+  "TELA",
+  "TIJERAS",
+  "CINTA",
+  "CINTA",     // RIBBON (could also say “LISTÓN”)
+  "HILO",
+  "AGUJA",
+  "BOTÓN",
+  "CREMALLERA",
+  "PANTUFLA",
+  "ABRIGO",
+  "MANOPLA",
+  "BUFANDA",
+  "GUANTE",
+  "PANTALONES",
+  "CAMISA",
+  "CHAQUETA",
+  "VESTIDO",
+  "FALDA",
+  "CALCETÍN",
+  "BOTA",
+  "SANDALIA",
+  "SOMBRERO",  // duplicate
+  "GORRA",
+  "MÁSCARA",
+  "GAFAS DE SOL",
+  "RELOJ",
+  "COLLAR",
+  "PULSERA",
+  "ANILLO",
+  "PENDIENTE",
+  "MOCHILA",
+  "MALETA",
+  "BILLETE",
+  "PASAPORTE",
+  "MAPA",
+  "BRÚJULA",
+  "ANTORCHA",
+  "LINTERNA",
+  "HOGUERA",
+  "TIENDA DE CAMPAÑA",
+  "SACO DE DORMIR",
+  "PICNIC",
+  "BANCO",
+  "VALLA",       // duplicate
+  "PUERTA",      // gate can be “PUERTA” or “PORTÓN”; used PUERTA earlier for “door,” so let's keep “PORTÓN” for gate below
+  "SEÑAL",
+  "PASO DE PEATONES",
+  "SEMÁFORO",
+  "ACERA",
+  "FAROL",       // duplicate
+  "GLOBO",       // duplicate
+  "POSTAL",
+  "SELLO",
+  "CARTA",
+  "SOBRE",
+  "ESTACIONAMIENTO",
+  "CALLE",
+  "AUTOPISTA",
+  "PUENTE",      // duplicate
+  "TÚNEL",
+  "ESTATUA",
+  "FUENTE",
+  "TORRE",
+  "CASTILLO",
+  "PIRÁMIDE",
+  "PLANETA",
+  "GALAXIA",
+  "SATÉLITE",
+  "ASTRONAUTA",
+  "TELESCOPIO",
+  "MICROSCOPIO",
+  "IMÁN",
+  "BATERÍA",     // duplicate
+  "BOMBILLA",
+  "ENCHUFE",
+  "ENCHUFE",     // PLUG (maybe “CLAVIJA,” but “ENCHUFE” is also used)
+  "CABLE",
+  "INTERRUPTOR",
+  "CIRCUITO",
+  "ROBOT",
+  "ORDENADOR",
+  "RATÓN",
+  "TECLADO",
+  "PANTALLA",
+  "IMPRESORA",
+  "ALTAVOZ",
+  "AURICULARES",
+  "TELÉFONO",
+  "CÁMARA"
+];
+
+export const getRandomWord = (language: string = 'en') => {
+  let wordList;
+  switch (language) {
+    case 'de':
+      wordList = germanWords;
+      break;
+    case 'fr':
+      wordList = frenchWords;
+      break;
+    case 'it':
+      wordList = italianWords;
+      break;
+    case 'es':
+      wordList = spanishWords;
+      break;
+    default:
+      wordList = englishWords;
+  }
+  return wordList[Math.floor(Math.random() * wordList.length)];
+};

src/lib/words.ts

@@ -1,337 +0,0 @@
-export const englishWords = [
-  "DOG",
-  "CAT",
-  "SUN",
-  "RAIN",
-  "TREE",
-  "STAR",
-  "MOON",
-  "FISH",
-  "BIRD",
-  "CLOUD",
-  "SKY",
-  "WIND",
-  "SNOW",
-  "FLOWER",
-  "BUTTERFLY",
-  "WATER",
-  "OCEAN",
-  "RIVER",
-  "MOUNTAIN",
-  "FOREST",
-  "HOUSE",
-  "CANDLE",
-  "GARDEN",
-  "BRIDGE",
-  "ISLAND",
-  "BREEZE",
-  "LIGHT",
-  "THUNDER",
-  "RAINBOW",
-  "SMILE",
-  "FRIEND",
-  "FAMILY",
-  "APPLE",
-  "BANANA",
-  "CAR",
-  "BOAT",
-  "BALL",
-  "CAKE",
-  "FROG",
-  "HORSE",
-  "LION",
-  "MONKEY",
-  "PANDA",
-  "PLANE",
-  "TRAIN",
-  "CANDY",
-  "JUMP",
-  "PLAY",
-  "SLEEP",
-  "LAUGH",
-  "DREAM",
-  "HAPPY",
-  "FUN",
-  "COLOR",
-  "BRIGHT",
-  "WISH",
-  "LOVE",
-  "PEACE",
-  "HUG",
-  "KISS",
-  "ZOO",
-  "PARK",
-  "BEACH",
-  "TOY",
-  "BOOK",
-  "BUBBLE",
-  "SHELL",
-  "PEN",
-  "ICE",
-  "CAKE",
-  "HAT",
-  "SHOE",
-  "CLOCK",
-  "BED",
-  "CUP",
-  "KEY",
-  "DOOR",
-  "CHICKEN",
-  "DUCK",
-  "SHEEP",
-  "COW",
-  "PIG",
-  "GOAT",
-  "FOX",
-  "BEAR",
-  "DEER",
-  "OWL",
-  "EGG",
-  "NEST",
-  "ROCK",
-  "LEAF",
-  "BRUSH",
-  "TOOTH",
-  "HAND",
-  "FEET",
-  "EYE",
-  "NOSE",
-  "EAR",
-  "MOUTH",
-  "CHILD",
-  "KITE",
-  "BALLON"
-];
-
-export const germanWords = [
-  "HUND",
-  "KATZE",
-  "SONNE",
-  "REGEN",
-  "BAUM",
-  "STERN",
-  "MOND",
-  "FISCH",
-  "VOGEL",
-  "WOLKE",
-  "HIMMEL",
-  "WIND",
-  "SCHNEE",
-  "BLUME",
-  "WASSER",
-  "OZEAN",
-  "FLUSS",
-  "BERG",
-  "WALD",
-  "HAUS",
-  "KERZE",
-  "GARTEN",
-  "BRÜCKE",
-  "INSEL",
-  "LICHT",
-  "DONNER",
-  "LÄCHELN",
-  "FREUND",
-  "FAMILIE",
-  "APFEL",
-  "BANANE",
-  "AUTO",
-  "BOOT",
-  "BALL",
-  "KUCHEN",
-  "FROSCH",
-  "PFERD",
-  "LÖWE",
-  "AFFE",
-  "PANDA",
-  "FLUGZEUG",
-  "ZUG",
-  "BONBON",
-  "SPRINGEN",
-  "SPIELEN",
-  "SCHLAFEN",
-  "LACHEN",
-  "TRAUM",
-  "GLÜCK",
-  "FARBE"
-];
-
-export const frenchWords = [
-  "CHIEN",
-  "CHAT",
-  "SOLEIL",
-  "PLUIE",
-  "ARBRE",
-  "ÉTOILE",
-  "LUNE",
-  "POISSON",
-  "OISEAU",
-  "NUAGE",
-  "CIEL",
-  "VENT",
-  "NEIGE",
-  "FLEUR",
-  "EAU",
-  "OCÉAN",
-  "RIVIÈRE",
-  "MONTAGNE",
-  "FORÊT",
-  "MAISON",
-  "BOUGIE",
-  "JARDIN",
-  "PONT",
-  "ÎLE",
-  "LUMIÈRE",
-  "TONNERRE",
-  "SOURIRE",
-  "AMI",
-  "FAMILLE",
-  "POMME",
-  "BANANE",
-  "VOITURE",
-  "BATEAU",
-  "BALLON",
-  "GÂTEAU",
-  "GRENOUILLE",
-  "CHEVAL",
-  "LION",
-  "SINGE",
-  "PANDA",
-  "AVION",
-  "TRAIN",
-  "BONBON",
-  "SAUTER",
-  "JOUER",
-  "DORMIR",
-  "RIRE",
-  "RÊVE",
-  "BONHEUR",
-  "COULEUR"
-];
-
-export const italianWords = [
-  "CANE",
-  "GATTO",
-  "SOLE",
-  "PIOGGIA",
-  "ALBERO",
-  "STELLA",
-  "LUNA",
-  "PESCE",
-  "UCCELLO",
-  "NUVOLA",
-  "CIELO",
-  "VENTO",
-  "NEVE",
-  "FIORE",
-  "ACQUA",
-  "OCEANO",
-  "FIUME",
-  "MONTAGNA",
-  "FORESTA",
-  "CASA",
-  "CANDELA",
-  "GIARDINO",
-  "PONTE",
-  "ISOLA",
-  "LUCE",
-  "TUONO",
-  "SORRISO",
-  "AMICO",
-  "FAMIGLIA",
-  "MELA",
-  "BANANA",
-  "AUTO",
-  "BARCA",
-  "PALLA",
-  "TORTA",
-  "RANA",
-  "CAVALLO",
-  "LEONE",
-  "SCIMMIA",
-  "PANDA",
-  "AEREO",
-  "TRENO",
-  "CARAMELLA",
-  "SALTARE",
-  "GIOCARE",
-  "DORMIRE",
-  "RIDERE",
-  "SOGNO",
-  "FELICITÀ",
-  "COLORE"
-];
-
-export const spanishWords = [
-  "PERRO",
-  "GATO",
-  "SOL",
-  "LLUVIA",
-  "ÁRBOL",
-  "ESTRELLA",
-  "LUNA",
-  "PEZ",
-  "PÁJARO",
-  "NUBE",
-  "CIELO",
-  "VIENTO",
-  "NIEVE",
-  "FLOR",
-  "AGUA",
-  "OCÉANO",
-  "RÍO",
-  "MONTAÑA",
-  "BOSQUE",
-  "CASA",
-  "VELA",
-  "JARDÍN",
-  "PUENTE",
-  "ISLA",
-  "LUZ",
-  "TRUENO",
-  "SONRISA",
-  "AMIGO",
-  "FAMILIA",
-  "MANZANA",
-  "PLÁTANO",
-  "COCHE",
-  "BARCO",
-  "PELOTA",
-  "PASTEL",
-  "RANA",
-  "CABALLO",
-  "LEÓN",
-  "MONO",
-  "PANDA",
-  "AVIÓN",
-  "TREN",
-  "CARAMELO",
-  "SALTAR",
-  "JUGAR",
-  "DORMIR",
-  "REÍR",
-  "SUEÑO",
-  "FELICIDAD",
-  "COLOR"
-];
-
-export const getRandomWord = (language: string = 'en') => {
-  let wordList;
-  switch (language) {
-    case 'de':
-      wordList = germanWords;
-      break;
-    case 'fr':
-      wordList = frenchWords;
-      break;
-    case 'it':
-      wordList = italianWords;
-      break;
-    case 'es':
-      wordList = spanishWords;
-      break;
-    default:
-      wordList = englishWords;
-  }
-  return wordList[Math.floor(Math.random() * wordList.length)];
-};

supabase/functions/submit-high-score/index.ts

@@ -0,0 +1,61 @@
+import { createClient } from 'https://esm.sh/@supabase/[email protected]'
+
+const corsHeaders = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
+}
+
+Deno.serve(async (req) => {
+  if (req.method === 'OPTIONS') {
+    return new Response(null, { headers: corsHeaders })
+  }
+
+  try {
+    const { playerName, score, avgWordsPerRound, sessionId, theme } = await req.json()
+
+    if (!playerName || !score || !avgWordsPerRound || !sessionId || !theme) {
+      throw new Error('Missing required fields')
+    }
+
+    const supabaseClient = createClient(
+      Deno.env.get('SUPABASE_URL') ?? '',
+      Deno.env.get('SUPABASE_ANON_KEY') ?? '',
+      {
+        auth: {
+          persistSession: false,
+        },
+      }
+    )
+
+    console.log('Submitting score:', { playerName, score, avgWordsPerRound, sessionId, theme })
+
+    const { data, error } = await supabaseClient.rpc('check_and_update_high_score', {
+      p_player_name: playerName,
+      p_score: score,
+      p_avg_words_per_round: avgWordsPerRound,
+      p_session_id: sessionId,
+      p_theme: theme
+    })
+
+    if (error) {
+      throw error
+    }
+
+    return new Response(
+      JSON.stringify({ success: true, data }),
+      {
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+        status: 200,
+      },
+    )
+  } catch (error) {
+    console.error('Error:', error.message)
+    return new Response(
+      JSON.stringify({ error: error.message }),
+      {
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    )
+  }
+})

supabase/functions/validate-sentence/index.ts

@@ -1,56 +0,0 @@
-import { serve } from "https://deno.land/[email protected]/http/server.ts";
-import { Mistral } from "npm:@mistralai/mistralai";
-
-const corsHeaders = {
-  'Access-Control-Allow-Origin': '*',
-  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
-};
-
-serve(async (req) => {
-  if (req.method === 'OPTIONS') {
-    return new Response(null, { headers: corsHeaders });
-  }
-
-  try {
-    const { sentence } = await req.json();
-    console.log('Validating sentence:', sentence);
-
-    const client = new Mistral({
-      apiKey: Deno.env.get('MISTRAL_API_KEY'),
-    });
-
-    const response = await client.chat.complete({
-      model: "mistral-large-latest",
-      messages: [
-        {
-          role: "system",
-          content: `You are an English language validator. Your task is to determine if the given sentence is grammatically correct and makes sense in English.
-                    Respond with ONLY "true" or "false".`
-        },
-        {
-          role: "user",
-          content: `Is this a valid, grammatically correct English sentence that makes sense: "${sentence}"?`
-        }
-      ],
-      maxTokens: 10,
-      temperature: 0.1
-    });
-
-    const isValid = response.choices[0].message.content.trim().toLowerCase() === 'true';
-    console.log('Sentence validation result:', isValid);
-
-    return new Response(
-      JSON.stringify({ isValid }),
-      { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
-    );
-  } catch (error) {
-    console.error('Error validating sentence:', error);
-    return new Response(
-      JSON.stringify({ error: error.message }),
-      { 
-        status: 500,
-        headers: { ...corsHeaders, 'Content-Type': 'application/json' }
-      }
-    );
-  }
-});