Dep upd

app/components/SpeechBubble.tsx

@@ -1,83 +1,118 @@
 import { useEffect, useState, useCallback, useRef } from 'react';
-import { frogMessages } from '../config/messages';
+import { useMessages } from 'next-intl';
+import { getRandomEmoji } from '../config/emojis';
 
-// Increase visibility duration for speech bubbles
-const VISIBILITY_MS = 3000; // 3 seconds for message visibility
-const COOLDOWN_MS = 2000;   // 2 seconds between new messages
+const VISIBILITY_MS = 3000;
+const COOLDOWN_MS = 2000;
 
 interface SpeechBubbleProps {
   isShaken: boolean;
   triggerCount: number;
 }
 
-export function SpeechBubble({ isShaken, triggerCount }: SpeechBubbleProps) {
+export function SpeechBubble({ triggerCount }: SpeechBubbleProps) {
   const [message, setMessage] = useState('');
   const [isVisible, setIsVisible] = useState(false);
+  const [messageQueue, setMessageQueue] = useState<string[]>([]);
+  const allMessages = useMessages();
+  const messagesRef = useRef<string[]>([]);
   const lastTriggerTime = useRef(0);
   const showTimeRef = useRef<number>(0);
+  const lastFadeTime = useRef(0);
+  
+  useEffect(() => {
+    if (messagesRef.current.length > 0) return;
+    
+    try {
+      const characterMessages = allMessages.character;
+      
+      if (characterMessages && typeof characterMessages === 'object') {
+        const messageArray = Object.values(characterMessages) as string[];
+        
+        if (messageArray.length === 0) {
+          console.error(`No character messages found! Expected messages in 'character' namespace but got none.`);
+          return;
+        }
+        
+        console.log(`Loaded ${messageArray.length} character messages`);
+        messagesRef.current = messageArray;
+      } else {
+        console.error(`Character messages not found or invalid format:`, characterMessages);
+      }
+    } catch (error) {
+      console.error(`Error loading character messages:`, error);
+    }
+  }, [allMessages]);
+
   const getRandomMessage = useCallback(() => {
-    const randomIndex = Math.floor(Math.random() * frogMessages.length);
-    return frogMessages[randomIndex];
+    const currentMessages = messagesRef.current;
+    if (currentMessages.length === 0) return '';
+    const randomIndex = Math.floor(Math.random() * currentMessages.length);
+    const messageValue = currentMessages[randomIndex];
+    return `${messageValue} ${getRandomEmoji()}`;
   }, []);
 
-  // Handle showing new messages
   useEffect(() => {
-    if (triggerCount === 0) return; // Skip initial mount
+    if (triggerCount === 0 || messagesRef.current.length === 0) return;
     
     const now = Date.now();
-    const timeSinceLastMessage = now - lastTriggerTime.current;
+    const timeSinceLastFade = now - lastFadeTime.current;
 
-    // Show new message if cooldown has expired
-    if (timeSinceLastMessage >= COOLDOWN_MS) {
-      lastTriggerTime.current = now;
-      showTimeRef.current = now;
+    if (timeSinceLastFade < COOLDOWN_MS || isVisible) {
       const newMessage = getRandomMessage();
+      if (newMessage) {
+        setMessageQueue(prev => [...prev, newMessage]);
+      }
+      return;
+    }
+
+    lastTriggerTime.current = now;
+    showTimeRef.current = now;
+    const newMessage = getRandomMessage();
+    if (newMessage) {
       setMessage(newMessage);
       setIsVisible(true);
     }
-  }, [triggerCount, getRandomMessage]);
+  }, [triggerCount, isVisible, getRandomMessage]);
+
+  useEffect(() => {
+    if (messageQueue.length === 0 || isVisible) return;
+
+    const now = Date.now();
+    const timeSinceLastFade = now - lastFadeTime.current;
+
+    if (timeSinceLastFade >= COOLDOWN_MS) {
+      const nextMessage = messageQueue[0];
+      setMessageQueue(prev => prev.slice(1));
+      lastTriggerTime.current = now;
+      showTimeRef.current = now;
+      setMessage(nextMessage);
+      setIsVisible(true);
+    }
+  }, [messageQueue, isVisible]);
 
-  // Handle visibility duration
   useEffect(() => {
     if (!isVisible) return;
 
-    const checkVisibility = setInterval(() => {
-      const now = Date.now();
-      const timeVisible = now - showTimeRef.current;
-      
-      if (timeVisible >= VISIBILITY_MS) {
-        setIsVisible(false);
-      }
-    }, 100); // Check every 100ms
+    const hideTimer = setTimeout(() => {
+      setIsVisible(false);
+      lastFadeTime.current = Date.now();
+    }, VISIBILITY_MS);
 
-    return () => {
-      clearInterval(checkVisibility);
-    };
+    return () => clearTimeout(hideTimer);
   }, [isVisible]);
-  
-  // Uncomment and modify the useEffect to control visibility based on isShaken prop
-  // This will make the speech bubble stay visible even after shaking stops
-  useEffect(() => {
-    if (!isShaken) {
-      // Don't hide the speech bubble when shaking stops
-      // The visibility duration timer will handle hiding it
-      return;
-    }
-  }, [isShaken]);
-
-  if (!isVisible) return null;
 
   return (
-    <div className="absolute -top-24 left-1/2 -translate-x-1/2 bg-white dark:bg-slate-800 px-4 py-2 rounded-xl shadow-lg animate-float z-20">
-      <div className="relative">
-        {message}
-        {/* Triangle pointer */}
-        <div className="absolute -bottom-6 left-1/2 -translate-x-1/2 w-0 h-0 
-                      border-l-[8px] border-l-transparent
-                      border-r-[8px] border-r-transparent
-                      border-t-[8px] border-t-white
-                      dark:border-t-slate-800" />
-      </div>
+    <div
+      className={`absolute -top-24 bg-white dark:bg-slate-800
+                  px-4 py-2 rounded-xl shadow-lg z-20 transition-opacity duration-300
+                  ${isVisible ? 'opacity-100 animate-float' : 'opacity-0 pointer-events-none'}`}
+      style={{
+        left: '50%',
+        transform: 'translateX(-50%)'
+      }}
+    >
+      {message}
     </div>
   );
 }