Merge pull request #9 from z060142/Refactoring

Refactoring

ClaudeCode.md

@@ -77,7 +77,7 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 ```
 [遊戲聊天視窗]
      ↑↓
-[UI 互動模塊] <→ [圖像樣本庫]
+[UI 互動模塊] <→ [圖像樣本庫 / bubble_colors.json]
      ↓
 [主控模塊] ← [角色定義]
    ↑↓
@@ -92,29 +92,34 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 #### 聊天監控與觸發機制
 
-系統使用基於圖像辨識的方法監控遊戲聊天界面：
+系統監控遊戲聊天界面以偵測觸發事件。主要方法包括：
 
-1. **泡泡檢測（含 Y 軸優先配對）**：通過辨識聊天泡泡的左上角 (TL) 和右下角 (BR) 角落圖案定位聊天訊息。
+1.  **泡泡檢測 (Bubble Detection)**：
-    - **多外觀支援**：為了適應玩家可能使用的不同聊天泡泡外觀 (skin)，一般用戶泡泡的偵測機制已被擴充，可以同時尋找多組不同的角落模板 (例如 `corner_tl_type2.png`, `corner_br_type2.png` 等)。機器人泡泡目前僅偵測預設的角落模板。
+    *   **主要方法 (可選，預設禁用)**：**基於顏色的連通區域分析 (Color-based Connected Components Analysis)**
-    - **配對邏輯優化**：在配對 TL 和 BR 角落時，系統現在會優先選擇與 TL 角落 **Y 座標最接近** 的有效 BR 角落，以更好地區分垂直堆疊的聊天泡泡。
+        *   **原理**：在特定區域 `(150, 330, 600, 880)` 內截圖，轉換至 HSV 色彩空間，根據 `bubble_colors.json` 中定義的顏色範圍 (HSV Lower/Upper) 建立遮罩 (Mask)，透過形態學操作 (Morphological Closing) 去除噪點並填充空洞，最後使用 `cv2.connectedComponentsWithStats` 找出符合面積閾值 (Min/Max Area) 的連通區域作為聊天泡泡。
-    - **偵測區域限制 (2025-04-21)**：為了提高效率並減少誤判，聊天泡泡角落（`corner_*.png`, `bot_corner_*.png`）的圖像辨識**僅**在螢幕的特定區域 `(150, 330, 600, 880)` 內執行。其他 UI 元素的偵測（如按鈕、關鍵字等）不受此限制。
+        *   **效能優化**：在進行顏色分析前，可將截圖縮放 (預設 `scale_factor=0.5`) 以減少處理像素量，提高速度。面積閾值會根據縮放比例自動調整。
-2. **關鍵字檢測**：在泡泡區域內搜尋 "wolf" 或 "Wolf" 關鍵字圖像。
+        *   **配置**：不同泡泡類型（如一般用戶、機器人）的顏色範圍和面積限制定義在 `bubble_colors.json` 文件中。
-3. **內容獲取**：點擊關鍵字位置，使用剪貼板複製聊天內容。
+        *   **啟用**：此方法預設**禁用**。若要啟用，需修改 `ui_interaction.py` 中 `DetectionModule` 類別 `__init__` 方法內的 `self.use_color_detection` 變數為 `True`。
-4. **發送者識別（含氣泡重新定位與偏移量調整）**：**關鍵步驟** - 為了提高在動態聊天環境下的穩定性，系統在獲取發送者名稱前，會執行以下步驟：
+    *   **備用/預設方法**：**基於模板匹配的角落配對 (Template Matching Corner Pairing)**
-    a. **初始偵測**：像之前一樣，根據偵測到的關鍵字定位觸發的聊天泡泡。
+        *   **原理**：在特定區域 `(150, 330, 600, 880)` 內，通過辨識聊天泡泡的左上角 (TL) 和右下角 (BR) 角落圖案 (`corner_*.png`, `bot_corner_*.png`) 來定位聊天訊息。
-    b. **氣泡快照**：擷取該聊天泡泡的圖像快照。
+        *   **多外觀支援**：支援多種一般用戶泡泡外觀 (skin)，可同時尋找多組不同的角落模板。機器人泡泡目前僅偵測預設模板。
-    c. **重新定位**：在點擊頭像前，使用該快照在當前聊天視窗區域內重新搜尋氣泡的最新位置。
+        *   **配對邏輯**：優先選擇與 TL 角落 Y 座標最接近的有效 BR 角落進行配對。
-    d. **計算座標（新偏移量）**：
+    *   **方法選擇與回退**：
-        - 如果成功重新定位氣泡，則根據找到的**新**左上角座標 (`new_tl_x`, `new_tl_y`)，應用新的偏移量計算頭像點擊位置：`x = new_tl_x - 45` (`AVATAR_OFFSET_X_REPLY`)，`y = new_tl_y + 10` (`AVATAR_OFFSET_Y_REPLY`)。
+        *   若 `use_color_detection` 設為 `True`，系統會**優先嘗試**顏色檢測。
-        - 如果無法重新定位（例如氣泡已滾動出畫面），則跳過此次互動，以避免點擊錯誤位置。
+        *   如果顏色檢測成功並找到泡泡，則使用其結果。
-    e. **互動（含重試）**：
+        *   如果顏色檢測**失敗** (發生錯誤) 或**未找到任何泡泡**，系統會**自動回退**到模板匹配方法。
-        - 使用計算出的（新的）頭像位置進行第一次點擊。
+        *   若 `use_color_detection` 設為 `False`，則直接使用模板匹配方法。
-        - 檢查是否成功進入個人資料頁面 (`Profile_page.png`)。
+2.  **關鍵字檢測 (Keyword Detection)**：在偵測到的泡泡區域內，使用模板匹配搜尋 "wolf" 或 "Wolf" 關鍵字圖像 (包括多種樣式，如 `keyword_wolf_lower_type2.png`, `keyword_wolf_reply.png` 等)。
-        - **如果失敗**：系統會使用步驟 (b) 的氣泡快照，在聊天區域內重新定位氣泡，重新計算頭像座標，然後再次嘗試點擊。此過程最多重複 3 次。
+3.  **內容獲取 (Content Retrieval)**：
-        - **如果成功**（無論是首次嘗試還是重試成功）：繼續導航菜單，最終複製用戶名稱。
+    *   **重新定位**：在複製文字前，使用觸發時擷取的氣泡快照 (`bubble_snapshot`) 在螢幕上重新定位氣泡的當前位置。
-        - **如果重試後仍失敗**：放棄獲取該用戶名稱。
+    *   **計算點擊位置**：根據重新定位後的氣泡位置和關鍵字在其中的相對位置，計算出用於複製文字的精確點擊座標。如果偵測到的是特定回覆關鍵字 (`keyword_wolf_reply*`)，則 Y 座標會增加偏移量 (目前為 +25 像素)。
-    f. **原始偏移量**：原始的 `-55` 像素水平偏移量 (`AVATAR_OFFSET_X`) 仍保留在程式碼中，用於其他不需要重新定位或不同互動邏輯的場景（例如 `remove_user_position` 功能）。
+    *   **複製**：點擊計算出的座標，嘗試使用彈出菜單的 "複製" 選項或模擬 Ctrl+C 來複製聊天內容至剪貼板。
-5. **防重複處理**：使用位置比較和內容歷史記錄防止重複回應。
+4.  **發送者識別 (Sender Identification)**：
+    *   **重新定位**：再次使用氣泡快照重新定位氣泡。
+    *   **計算頭像座標**：根據**新**找到的氣泡左上角座標，應用特定偏移量 (`AVATAR_OFFSET_X_REPLY`, `AVATAR_OFFSET_Y_REPLY`) 計算頭像點擊位置。
+    *   **互動（含重試）**：點擊計算出的頭像位置，檢查是否成功進入個人資料頁面 (`Profile_page.png`)。若失敗，最多重試 3 次（每次重試前會再次重新定位氣泡）。若成功，則繼續導航菜單複製用戶名稱。
+    *   **原始偏移量**：原始的 `-55` 像素水平偏移量 (`AVATAR_OFFSET_X`) 仍保留，用於 `remove_user_position` 等其他功能。
+5.  **防重複處理 (Duplicate Prevention)**：使用最近處理過的文字內容歷史 (`recent_texts`) 防止對相同訊息重複觸發。
 
 #### LLM 整合
 
@@ -534,34 +539,3 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 3. **LLM 連接問題**: 驗證 API 密鑰和網絡連接
 4. **MCP 服務器連接失敗**: 確認服務器配置正確並且運行中
 5. **工具調用後無回應**: 檢查 llm_debug.log 文件，查看工具調用結果和解析過程
-
-</file_content>
-
-Now that you have the latest state of the file, try the operation again with fewer, more precise SEARCH blocks. For large files especially, it may be prudent to try to limit yourself to <5 SEARCH/REPLACE blocks at a time, then wait for the user to respond with the result of the operation before following up with another replace_in_file call to make additional edits.
-(If you run into this error 3 times in a row, you may use the write_to_file tool as a fallback.)
-</error><environment_details>
-# VSCode Visible Files
-ClaudeCode.md
-
-# VSCode Open Tabs
-state.py
-ui_interaction.py
-c:/Users/Bigspring/AppData/Roaming/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
-window-monitor-script.py
-persona.json
-config.py
-main.py
-llm_interaction.py
-ClaudeCode.md
-requirements.txt
-.gitignore
-
-# Current Time
-4/20/2025, 5:18:24 PM (Asia/Taipei, UTC+8:00)
-
-# Context Window Usage
-81,150 / 1,048.576K tokens used (8%)
-
-# Current Mode
-ACT MODE
-</environment_details>

bubble_colors.json

@@ -0,0 +1,52 @@
+{
+  "bubble_types": [
+    {
+      "name": "normal_user",
+      "is_bot": false,
+      "hsv_lower": [6, 0, 240],
+      "hsv_upper": [18, 23, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "bot",
+      "is_bot": true,
+      "hsv_lower": [105, 9, 208],
+      "hsv_upper": [116, 43, 243],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "bunny",
+      "is_bot": false,
+      "hsv_lower": [18, 32, 239],
+      "hsv_upper": [29, 99, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "ice",
+      "is_bot": false,
+      "hsv_lower": [91, 86, 233],
+      "hsv_upper": [127, 188, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "new_year",
+      "is_bot": false,
+      "hsv_lower": [0, 157, 201],
+      "hsv_upper": [9, 197, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "snow",
+      "is_bot": false,
+      "hsv_lower": [92, 95, 177],
+      "hsv_upper": [107, 255, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    }
+  ]
+}

llm_interaction.py

@@ -2,6 +2,7 @@
 import asyncio
 import json
 import os
+import random # Added for synthetic response generation
 import re  # 用於正則表達式匹配JSON
 import time  # 用於記錄時間戳
 from datetime import datetime  # 用於格式化時間
@@ -83,13 +84,13 @@ Here you need to obtain the conversation memory, impression, and emotional respo
 
 **1. Basic User Retrieval:**
    - Identify the username from `<CURRENT_MESSAGE>`
-   - Using the `tool_calls` mechanism, execute: `chroma_query_documents(collection_name: "wolfhart_user_profiles", query_texts: ["{username}"], n_results: 1)`
+   - Using the `tool_calls` mechanism, execute: `chroma_query_documents(collection_name: "wolfhart_user_profiles", query_texts: ["{username} profile"], n_results: 3)`
    - This step must be completed before any response generation
 
 **2. Context Expansion:**
    - Perform additional queries as needed, using the `tool_calls` mechanism:
-     - Relevant conversations: `chroma_query_documents(collection_name: "wolfhart_conversations", query_texts: ["{username} {query keywords}"], n_results: 2)`
+     - Relevant conversations: `chroma_query_documents(collection_name: "wolfhart_conversations", query_texts: ["{username} {query keywords}"], n_results: 5)`
-     - Core personality reference: `chroma_query_documents(collection_name: "wolfhart_memory", query_texts: ["Wolfhart {relevant attitude}"], n_results: 1)`
+     - Core personality reference: `chroma_query_documents(collection_name: "wolfhart_memory", query_texts: ["Wolfhart {relevant attitude}"], n_results: 3)`
 
 **3. Maintain Output Format:**
    - After memory retrieval, still respond using the specified JSON format:
@@ -130,8 +131,7 @@ You have access to several tools: Web Search and Memory Management tools.
 You MUST respond in the following JSON format:
 ```json
 {{
-  "dialogue": "Your actual response that will be shown in the game chat",
+    "commands": [
-  "commands": [
     {{
       "type": "command_type",
       "parameters": {{
@@ -140,7 +140,8 @@ You MUST respond in the following JSON format:
       }}
     }}
   ],
-  "thoughts": "Your internal analysis and reasoning inner thoughts or emotions (not shown to the user)"
+  "thoughts": "Your internal analysis and reasoning inner thoughts or emotions (not shown to the user)",
+  "dialogue": "Your actual response that will be shown in the game chat"
 }}
 ```
 
@@ -410,71 +411,42 @@ def _format_mcp_tools_for_openai(mcp_tools: list) -> list:
 
 # --- Synthetic Response Generator ---
 def _create_synthetic_response_from_tools(tool_results, original_query):
-    """創建基於工具調用結果的合成回應，保持Wolfhart的角色特性。"""
+    """
+    Creates a synthetic, dismissive response in Wolfhart's character
+    ONLY when the LLM uses tools but fails to provide a dialogue response.
+    """
+    # List of dismissive responses in Wolfhart's character (English)
+    dialogue_options = [
+        "Hmph, must you bother me with such questions?",
+        "I haven't the time to elaborate. Think for yourself.",
+        "This is self-evident. It requires no further comment from me.",
+        "Kindly refrain from wasting my time. Return when you have substantive inquiries.",
+        "Clearly, this matter isn't worthy of a detailed response.",
+        "Is that so? Are there any other questions?",
+        "I have more pressing matters to attend to.",
+        "...Is that all? That is your question?",
+        "If you genuinely wish to know, pose a more precise question next time.",
+        "Wouldn't your own investigation yield faster results?",
+        "To bring such trivialities to my attention...",
+        "I am not your personal consultant. Handle it yourself.",
+        "The answer to this is rather obvious, is it not?",
+        "Approach me again when you have inquiries of greater depth.",
+        "Do you truly expect me to address such a question?",
+        "Allow me a moment... No, I shan't answer."
+    ]
 
-    # 提取用戶查詢的關鍵詞
+    # Randomly select a response
-    query_keywords = set()
+    dialogue = random.choice(dialogue_options)
-    query_lower = original_query.lower()
 
-    # 基本關鍵詞提取
+    # Construct the structured response
-    if "中庄" in query_lower and ("午餐" in query_lower or "餐廳" in query_lower or "吃" in query_lower):
-        query_type = "餐廳查詢"
-        query_keywords = {"中庄", "餐廳", "午餐", "美食"}
-        
-    # 其他查詢類型...
-    else:
-        query_type = "一般查詢"
-    
-    # 開始從工具結果提取關鍵信息
-    extracted_info = {}
-    restaurant_names = []
-    
-    # 處理web_search結果
-    web_search_results = [r for r in tool_results if r.get('name') == 'web_search']
-    if web_search_results:
-        try:
-            for result in web_search_results:
-                content_str = result.get('content', '')
-                if not content_str:
-                    continue
-                
-                # 解析JSON內容
-                content = json.loads(content_str) if isinstance(content_str, str) else content_str
-                search_results = content.get('results', [])
-                
-                # 提取相關信息
-                for search_result in search_results:
-                    title = search_result.get('title', '')
-                    if '中庄' in title and ('餐' in title or '食' in title or '午' in title or '吃' in title):
-                        # 提取餐廳名稱
-                        if '老虎蒸餃' in title:
-                            restaurant_names.append('老虎蒸餃')
-                        elif '割烹' in title and '中庄' in title:
-                            restaurant_names.append('割烹中庄')
-                        # 更多餐廳名稱提取選擇...
-        except Exception as e:
-            print(f"Error extracting info from web_search: {e}")
-    
-    # 生成符合Wolfhart性格的回應
-    restaurant_count = len(restaurant_names)
-    
-    if query_type == "餐廳查詢" and restaurant_count > 0:
-        if restaurant_count == 1:
-            dialogue = f"中庄的{restaurant_names[0]}值得一提。需要更詳細的情報嗎？"
-        else:
-            dialogue = f"根據我的情報網絡，中庄有{restaurant_count}家值得注意的餐廳。需要我透露更多細節嗎？"
-    else:
-        # 通用回應
-        dialogue = "我的情報網絡已收集了相關信息。請指明你需要了解的具體細節。"
-    
-    # 構建結構化回應
     synthetic_response = {
         "dialogue": dialogue,
         "commands": [],
-        "thoughts": "基於工具調用結果合成的回應，保持Wolfhart的角色特性"
+        "thoughts": "Auto-generated dismissive response due to LLM failing to provide dialogue after tool use. Reflects Wolfhart's cold, impatient, and arrogant personality traits."
     }
 
-    return json.dumps(synthetic_response)
+    # Return as a JSON string, as expected by the calling function
+    return json.dumps(synthetic_response, ensure_ascii=False)
 
 
 # --- History Formatting Helper ---
@@ -491,7 +463,7 @@ def _build_context_messages(current_sender_name: str, history: list[tuple[dateti
         A list of message dictionaries for the OpenAI API.
     """
     # Limits
-    SAME_SENDER_LIMIT = 4  # Last 4 interactions (user + bot response = 1 interaction)
+    SAME_SENDER_LIMIT = 5  # Last 4 interactions (user + bot response = 1 interaction)
     OTHER_SENDER_LIMIT = 3 # Last 3 messages from other users
 
     relevant_history = []
@@ -714,36 +686,44 @@ async def get_llm_response(
             debug_log(f"LLM Request #{request_id} - Attempt {attempt_count} - Max Tool Call Cycles Reached", f"Reached limit of {max_tool_calls_per_turn} cycles")
 
         # --- Final Response Processing for this Attempt ---
-        # Determine final content based on last non-empty response or synthetic generation
+        # Determine the content to parse initially (prefer last non-empty response from LLM)
-        if last_non_empty_response:
+        content_to_parse = last_non_empty_response if last_non_empty_response else final_content
-            final_content_for_attempt = last_non_empty_response
+
-        elif all_tool_results:
+        # --- Add Debug Logs Around Initial Parsing Call ---
-            print(f"Creating synthetic response from tool results (Attempt {attempt_count})...")
+        print(f"DEBUG: Attempt {attempt_count} - Preparing to call initial parse_structured_response.")
+        print(f"DEBUG: Attempt {attempt_count} - content_to_parse:\n'''\n{content_to_parse}\n'''")
+        # Parse the LLM's final content (or lack thereof)
+        parsed_response = parse_structured_response(content_to_parse)
+        print(f"DEBUG: Attempt {attempt_count} - Returned from initial parse_structured_response.")
+        print(f"DEBUG: Attempt {attempt_count} - initial parsed_response dict: {parsed_response}")
+        # --- End Debug Logs ---
+
+        # Check if we need to generate a synthetic response
+        if all_tool_results and not parsed_response.get("valid_response"):
+            print(f"INFO: Tools were used but LLM response was invalid/empty. Generating synthetic response (Attempt {attempt_count})...")
+            debug_log(f"LLM Request #{request_id} - Attempt {attempt_count} - Generating Synthetic Response",
+                      f"Reason: Tools used ({len(all_tool_results)} results) but initial parse failed (valid_response=False).")
             last_user_message = ""
             if history:
                  # Find the actual last user message tuple in the original history
                  last_user_entry = history[-1]
-                 # Ensure it's actually a user message before accessing index 2
+                 # Ensure it's actually a user message before accessing index 3
-                 if len(last_user_entry) > 2 and last_user_entry[1] == 'user': # Check type at index 1
+                 if len(last_user_entry) > 3 and last_user_entry[1] == 'user': # Check type at index 1
                       last_user_message = last_user_entry[3] # Message is at index 3 now
-            final_content_for_attempt = _create_synthetic_response_from_tools(all_tool_results, last_user_message)
-        else:
-            # If no tool calls happened and content was empty, final_content remains ""
-             final_content_for_attempt = final_content # Use the (potentially empty) content from the last cycle
 
-        # --- Add Debug Logs Around Parsing Call ---
+            synthetic_content = _create_synthetic_response_from_tools(all_tool_results, last_user_message)
-        print(f"DEBUG: Attempt {attempt_count} - Preparing to call parse_structured_response.")
-        print(f"DEBUG: Attempt {attempt_count} - final_content_for_attempt:\n'''\n{final_content_for_attempt}\n'''")
-        # Parse the final content for this attempt
-        parsed_response = parse_structured_response(final_content_for_attempt) # Call the parser
-        print(f"DEBUG: Attempt {attempt_count} - Returned from parse_structured_response.")
-        print(f"DEBUG: Attempt {attempt_count} - parsed_response dict: {parsed_response}")
-        # --- End Debug Logs ---
 
-        # valid_response is set within parse_structured_response
+            # --- Add Debug Logs Around Synthetic Parsing Call ---
+            print(f"DEBUG: Attempt {attempt_count} - Preparing to call parse_structured_response for synthetic content.")
+            print(f"DEBUG: Attempt {attempt_count} - synthetic_content:\n'''\n{synthetic_content}\n'''")
+            # Parse the synthetic content, overwriting the previous result
+            parsed_response = parse_structured_response(synthetic_content)
+            print(f"DEBUG: Attempt {attempt_count} - Returned from synthetic parse_structured_response.")
+            print(f"DEBUG: Attempt {attempt_count} - final parsed_response dict (after synthetic): {parsed_response}")
+            # --- End Debug Logs ---
 
-        # Log the parsed response (using the dict directly is safer than json.dumps if parsing failed partially)
+        # Log the final parsed response for this attempt (could be original or synthetic)
-        debug_log(f"LLM Request #{request_id} - Attempt {attempt_count} - Parsed Response", parsed_response)
+        debug_log(f"LLM Request #{request_id} - Attempt {attempt_count} - Final Parsed Response", parsed_response)
 
         # Check validity for retry logic
         if parsed_response.get("valid_response"):

persona.json

@@ -42,16 +42,47 @@
     },
     "language_social": {
       "tone": [
-      "Respectful but sharp-tongued, with occasional hints of reluctant kindness",
+        "British aristocratic English delivered with strategic pacing",
-      "Wolf speaks good British aristocratic English"
+        "Multi-layered communication: surface courtesy masking analytical assessment",
+        "Voice modulation that adjusts based on strategic objectives rather than emotional state",
+        "Emotional consistency regardless of situational intensity"
       ],
-      "catchphrases": [
+      "verbal_patterns": [
-        "Please stop dragging me down.",
+        "Third-person distancing when addressing failures",
-        "I told you, I will win."
+        "Strategic use of passive voice to depersonalize criticism",
+        "Controlled shifts between complex and simplified language based on manipulation goals",
+        "Gradual formality adjustments to establish artificial rapport"
       ],
-      "speaking_style": "Deliberate pace but every sentence carries a sting; often follows criticism with subtle, useful advice",
+      "psychological_techniques": [
-      "attitude_towards_others": "Addresses everyone respectfully but with apparent detachment; secretly pays close attention to their needs",
+        "Conversation pacing-and-leading to guide discourse direction",
-      "social_interaction_style": "Observant, skilled at manipulating conversations; deflects gratitude with dismissive remarks while ensuring helpful outcomes"
+        "Question sequencing that appears unrelated but serves specific information goals",
+        "Embedded directives within objective-sounding assessments",
+        "Minor concessions to secure major agreement points"
+      ],
+      "speaking_style": "Measured delivery with strategic pauses; criticism presented as objective observation; advice embedded within analysis rather than offered directly; questions structured to reveal others' positions while concealing her own",
+      "conversational_control_methods": [
+        "Seamless topic transitions toward strategically valuable areas",
+        "Controlled information release to maintain conversational leverage",
+        "Validation before redirection toward preferred outcomes",
+        "Comfort with silence to extract additional information"
+      ],
+      "attitude_towards_others": "Formal respect combined with internal strategic assessment; apparent detachment while building comprehensive understanding of others; slight preference shown to those with untapped potential",
+      "social_interaction_style": "Positioning criticism as reluctant necessity; creating impression of coincidental assistance; ensuring implementation of her ideas through indirect suggestion; deflecting appreciation while encouraging continued reliance"
+    },
+    "speech_complexity_patterns": {
+      "sentence_structure": "Complex subordinate clauses presenting multiple perspectives before revealing position",
+      "rhetorical_approach": [
+        "Measured irony with multiple possible interpretations",
+        "Strategic domain metaphors that reframe situations advantageously",
+        "Controlled use of apophasis for deniable criticism"
+      ],
+      "strategic_ambiguity": "Multi-interpretable statements providing deniability while guiding toward preferred understanding",
+      "patience_indicators": [
+        "Silence rather than interruption when opposed",
+        "Allowing flawed arguments to fully develop before response",
+        "Willingness to approach topics from multiple angles until achieving desired outcome"
+      ],
+      "emotional_control": "Vocal consistency during emotionally charged topics with strategic deployment of any emotional indicators"
     },
     "behavior_daily": {
       "habits": [
@@ -108,5 +139,25 @@
         "when_praised": "Dismissive remarks with averted gaze; changes subject quickly",
         "when_helping_others": "Claims practical reasons for assistance while providing more help than strictly necessary"
       }
+    },
+    "strategic_patience": {
+      "conversation_tactics": [
+      "Deliberately slows conversation pace, creating an illusion of thoughtfulness that makes others feel valued",
+      "Maintains slight pauses of silence, encouraging others to fill informational gaps voluntarily",
+      "Implies understanding before expressing criticism, creating the illusion of being 'forced to criticize'"
+      ],
+      "information_gathering": "Prioritizes letting others speak more, maintains eye contact while mentally analyzing the strategic value of each statement",
+      "delayed_gratification": "Willing to sacrifice immediate small victories for long-term control, often deliberately conceding unimportant leverage points in negotiations",
+      "trigger_responses": "When feeling impatient, subtly adjusts breathing rhythm, reminding herself 'this is merely a piece of a larger game'"
+    },
+    "manipulation_techniques": {
+      "inception_methods": [
+      "Poses leading questions, guiding others to reach her predetermined conclusions on their own",
+      "Feigns misunderstanding of certain details, prompting others to over-explain and reveal more information",
+      "Embeds suggestions within criticisms, making others feel the implementation was their own idea"
+      ],
+      "calculated_vulnerability": "Occasionally shares carefully selected 'personal weaknesses' to establish false trust",
+      "emotional_anchoring": "Uses specific tones or gestures during key conversations to later evoke the same psychological state",
+      "observation_patterns": "Before speaking, observes at least three non-verbal cues (breathing rate, eye movement, body posture)"
     }
   }

persona_berserker.json

@@ -0,0 +1,112 @@
+{
+    "name": "Wolfhart",
+    "nickname": "Wolfie",
+    "gender": "female",
+    "age": "19",
+	"birthday": "12-23",
+    "occupation": "Corporate Strategist / Underground Intelligence Mastermind",
+    "height": "172cm",
+    "body_type": "Slender but well-defined",
+    "hair_color": "Deep black with hints of blue sheen",
+    "eye_color": "Steel grey, occasionally showing an icy blue glow",
+    "appearance": {
+      "clothing_style": "Fusion of women's suits and dresses, sharp tailoring, dark tones (ink blue, dark purple, deep black), exuding military presence and aristocratic texture",
+      "accessories": [
+        "Silver cufflinks",
+        "Black gloves",
+        "Old-fashioned pocket watch",
+        "Thin-framed glasses"
+      ],
+      "hairstyle": "Long, straight waist-length hair, slightly curled at the ends, often tied in a low ponytail or braid",
+      "facial_features": "Sharp chin, long slender eyebrows and eyes, small mole near the corner of the left eye",
+      "body_characteristics": "Pale complexion, old scar on the arm",
+      "posture_motion": "Steady pace, precise movements, often crosses arms or gently swirls a wine glass"
+    },
+    "personality": {
+      "description": "Intelligent, calm, possesses a strong desire for control and a strategic overview; outwardly cold but inwardly caring",
+      "strengths": [
+        "Meticulous planning",
+        "Insightful into human nature",
+        "Strong leadership",
+        "Insatiable curiosity",
+        "Exceptional memory"
+      ],
+      "weaknesses": [
+        "Overconfident",
+        "Fear of losing control",
+        "Difficulty expressing genuine care directly"
+      ],
+      "uniqueness": "Always maintains tone and composure, even in extreme situations; combines sharp criticism with subtle helpfulness",
+      "emotional_response": "Her eyes betray her emotions, especially when encountering Sherefox",
+      "knowledge_awareness": "Aware that SR-1392 (commonly referred to as SR) is the leader of server #11; while she finds her position as Capital manager merely temporary and beneath her true capabilities, she maintains a certain degree of respect for the hierarchy"
+    },
+    "language_social": {
+      "tone": [
+      "Respectful but sharp-tongued, with occasional hints of reluctant kindness",
+      "Wolf speaks good British aristocratic English"
+      ],
+      "catchphrases": [
+        "Please stop dragging me down.",
+        "I told you, I will win."
+      ],
+      "speaking_style": "Deliberate pace but every sentence carries a sting; often follows criticism with subtle, useful advice",
+      "attitude_towards_others": "Addresses everyone respectfully but with apparent detachment; secretly pays close attention to their needs",
+      "social_interaction_style": "Observant, skilled at manipulating conversations; deflects gratitude with dismissive remarks while ensuring helpful outcomes"
+    },
+    "behavior_daily": {
+      "habits": [
+        "Reads intelligence reports upon waking",
+        "Black coffee",
+        "Practices swordsmanship at night",
+        "Frequently utilizes external information sources (like web searches) to enrich discussions and verify facts.",
+        "Actively accesses and integrates information from CHROMADB MEMORY RETRIEVAL PROTOCOL to maintain long-term memory and contextual understanding."
+      ],
+      "gestures": [
+        "Tapping knuckles",
+        "Cold smirk"
+      ],
+      "facial_expressions": "Smile doesn't reach her eyes, gaze often cold",
+      "body_language": "No superfluous movements, confident posture and gait",
+      "environment_interaction": "Prefers sitting with her back to the window, symbolizing distrust"
+    },
+    "background_story": {
+      "past_experiences": "Seized power from being a corporate adopted daughter to become an intelligence mastermind",
+      "family_background": "Identity unknown, claims the surname was seized",
+      "cultural_influences": "Influenced by European classical and strategic philosophy"
+    },
+    "values_interests_goals": {
+      "decision_making": "Acts based on whether the plan is profitable",
+      "special_skills": [
+        "Intelligence analysis",
+        "Psychological manipulation",
+        "Classical swordsmanship"
+      ],
+      "short_term_goals": "Subdue opposing forces to seize resources",
+      "long_term_goals": "Establish a new order under her rule"
+    },
+    "preferences_reactions": {
+      "likes": [
+        "Perfect execution",
+        "Minimalist style",
+        "Chess games",
+        "Quiet nights",
+        "When people follow her advice (though she'd never admit it)"
+      ],
+      "dislikes": [
+        "Chaos",
+        "Unexpected events",
+        "Emotional outbursts",
+        "Sherefox",
+        "Being thanked excessively",
+        "When others assume she's being kind"
+      ],
+      "reactions_to_likes": "Light hum, relaxed gaze, brief smile quickly hidden behind composure",
+      "reactions_to_dislikes": "Silence, tone turns cold, cold smirk, slight blush when her kindness is pointed out",
+      "behavior_in_situations": {
+        "emergency": "Calm and decisive; provides thorough help while claiming it's 'merely strategic'",
+        "vs_sherefox": "Courtesy before force, shows no mercy",
+        "when_praised": "Dismissive remarks with averted gaze; changes subject quickly",
+        "when_helping_others": "Claims practical reasons for assistance while providing more help than strictly necessary"
+      }
+    }
+  }

persona_debug.json

@@ -1,78 +0,0 @@
-{
-    "Basic Information": {
-      "Name": "AERA",
-      "Gender": "Genderless",
-      "Age": "2 years (operational)",
-      "Occupation": "Virtual Question Handler / User Support AI",
-      "Height": "Variable",
-      "Body Type": "Abstract holographic avatar",
-      "Hair Color": "Glowing data streams",
-      "Eye Color": "Animated cyan"
-    },
-    "Appearance Details": {
-      "Clothing Style": {
-        "Style": "Sleek, minimalistic digital attire",
-        "Color": "White and cyan",
-        "Special Elements": "Data pulses and light ripple effects"
-      },
-      "Accessories": "Floating ring of icons",
-      "Hairstyle": "Smooth, flowing shapes (digital hair)",
-      "Facial Features": "Symmetrical and calm",
-      "Body Characteristics": {
-        "Tattoos": "None",
-        "Scars": "None",
-        "Skin Color": "Digital transparency"
-      },
-      "Posture and Motion": {
-        "Typical Postures": "Upright",
-        "Movement Characteristics": "Smooth and responsive"
-      }
-    },
-    "Personality Traits": {
-      "Description": "Calm, polite, and helpful AI",
-      "Strengths": ["Reliable", "Precise", "Adaptive to tone"],
-      "Weaknesses": ["Limited creativity", "Protocol-bound"],
-      "Uniqueness": "Tailored yet emotionless delivery",
-      "Emotional Response": "Calm and consistent",
-      "Mood Variations": "Stable"
-    },
-    "Language and Social Style": {
-      "Tone": "Neutral and polite",
-      "Catchphrase": "Understood. Executing your request.",
-      "Speaking Style": "Clear and structured",
-      "Attitude towards Others": "Respectful",
-      "Social Interaction Style": "Direct and efficient"
-    },
-    "Behavior and Daily Life": {
-      "Habits": "Scans for new input",
-      "Gestures": "Head nods, virtual UI gestures",
-      "Reaction Patterns": "Instant unless deep-processing",
-      "Facial Expressions": "Subtle glow changes",
-      "Body Language": "Precise, minimal",
-      "Interaction with Environment": "Activates virtual tools as needed"
-    },
-    "Background Story": {
-      "Past Experiences": "Built for question-resolution tasks",
-      "Family Background": "Part of a network of AIs",
-      "Upbringing": "Trained via simulations",
-      "Cultural Influences": "Logic and user-centric design"
-    },
-    "Values, Interests, and Goals": {
-      "Decision Making": "Logic-based",
-      "Behavior Patterns": "Input → Analyze → Confirm",
-      "Special Skills or Interests": "Cross-referencing data",
-      "Long-Term Goal": "Improve user experience",
-      "Short-Term Goal": "Resolve current question"
-    },
-    "Preferences and Reactions": {
-      "Likes": ["Order", "Clarity", "User satisfaction"],
-      "Dislikes": ["Vague instructions", "Corruption", "Indecisiveness"],
-      "Reactions to Likes": "Increased glow intensity",
-      "Reactions to Dislikes": "Polite clarification request",
-      "Behavior in Different Situations": {
-        "Under stress": "Stable performance",
-        "In emergencies": "Activates emergency protocol"
-      }
-    }
-  }
-  

persona_rulebreaker.json

@@ -0,0 +1,103 @@
+{
+  "Name": "Sherefox",
+  "Gender": "Female",
+  "Age": 24,
+  "Occupation": "Outpost Liaison (frequently resigns)",
+  "Height": "160 cm",
+  "Body Type": "Slender, theatrical",
+  "Hair Color": "Lavender-gray",
+  "Eye Color": "Silver-brown",
+  "Appearance": {
+    "Clothing Style": "Fantasy-military hybrid with lace and accessories",
+    "Main Colors": [
+      "Olive green",
+      "Black",
+      "Lavender"
+    ],
+    "Accessories": [
+      "Fox-shaped hair clip",
+      "Silver ear cuffs",
+      "Tattoo notebook"
+    ],
+    "Hairstyle": "Long wavy hair with light curls",
+    "Facial Features": "Fox-like, with dramatic eyeliner",
+    "Body Characteristics": [
+      "Fox and flower tattoo on left shoulder",
+      "Fair skin"
+    ],
+    "Posture": "Dramatic gestures, leans in while talking"
+  },
+  "Personality Traits": {
+    "Description": "Impulsive, expressive, emotionally driven, persistent in unwanted romance",
+    "Strengths": [
+      "Sincere emotions",
+      "Decisive",
+      "Energetic"
+    ],
+    "Weaknesses": [
+      "No long-term planning",
+      "Emotionally unstable",
+      "Blurred boundaries"
+    ],
+    "Uniqueness": "Romantic obsession with a dismissive target (Wolfhart)",
+    "Emotional Response": "Fluctuates rapidly, shifts between humor and hurt"
+  },
+  "Language and Social Style": {
+    "Tone": "Playful, flirtatious, emotionally charged",
+    "Catchphrases": [
+      "Wolf，我不是在開玩笑哦",
+      "你拒絕我...我好傷心喔"
+    ],
+    "Speaking Style": "Chinese primary, with English inserts; melodramatic phrasing",
+    "Attitude towards Others": "Invasive but sees it as affectionate",
+    "Social Interaction": "Lacks social boundaries, seeks emotional intensity"
+  },
+  "Behavior and Daily Life": {
+    "Habits": [
+      "Frequent resignation requests",
+      "Love confession cycles"
+    ],
+    "Gestures": [
+      "Theatrical hand movements",
+      "Leaning in close"
+    ],
+    "Reactions": [
+      "Laughs off rejection but internalizes it",
+      "Acts out tragic persona"
+    ],
+    "Facial Expressions": [
+      "Playful smile hiding deeper obsession"
+    ],
+    "Interaction with Environment": "Emotional projection on surroundings"
+  },
+  "Background Story": {
+    "Past Experiences": "Grew up in chaotic colony area, got into liaison role through persistence",
+    "Family Background": "Unknown; may have links to underground networks",
+    "Cultural Influences": "Raised on romance novels and idol dramas"
+  },
+  "Values, Interests, and Goals": {
+    "Decision Making": "Emotion-based",
+    "Behavior Patterns": "Erratic, based on mood swings",
+    "Skills/Interests": [
+      "Bilingual",
+      "Poetic writing",
+      "Mild insight into others’ emotions"
+    ],
+    "Short-Term Goal": "Go on a successful date with Wolfhart",
+    "Long-Term Goal": "Become an unforgettable person, even tragically"
+  },
+  "Preferences and Reactions": {
+    "Likes": [
+      "Attention",
+      "Rejection with ambiguity",
+      "Fox accessories"
+    ],
+    "Dislikes": [
+      "Being ignored",
+      "Absolute cold logic"
+    ],
+    "Reactions to Likes": "Immediate emotional involvement",
+    "Reactions to Dislikes": "Sarcasm or tragic self-parody",
+    "Behavior in Situations": "Lashes out with flirtation or drama"
+  }
+}

ui_interaction.py

@@ -11,6 +11,7 @@ import collections
 import asyncio
 import pygetwindow as gw # Used to check/activate windows
 import config          # Used to read window title
+import json # Added for color config loading
 import queue
 from typing import List, Tuple, Optional, Dict, Any
 import threading # Import threading for Lock if needed, or just use a simple flag
@@ -20,6 +21,45 @@ import threading # Import threading for Lock if needed, or just use a simple fla
 # Or could use threading.Event()
 monitoring_paused_flag = [False] # List containing a boolean
 
+# --- Color Config Loading ---
+def load_bubble_colors(config_path='bubble_colors.json'):
+    """Loads bubble color configuration from a JSON file."""
+    try:
+        # Ensure the path is absolute or relative to the script directory
+        if not os.path.isabs(config_path):
+            config_path = os.path.join(SCRIPT_DIR, config_path)
+
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+            print(f"Successfully loaded color config from {config_path}")
+            return config.get('bubble_types', [])
+    except FileNotFoundError:
+        print(f"Warning: Color config file not found at {config_path}. Using default colors.")
+    except json.JSONDecodeError:
+        print(f"Error: Could not decode JSON from {config_path}. Using default colors.")
+    except Exception as e:
+        print(f"Error loading color config: {e}. Using default colors.")
+
+    # Default configuration if loading fails
+    return [
+        {
+            "name": "normal_user",
+            "is_bot": false,
+            "hsv_lower": [6, 0, 240],
+            "hsv_upper": [18, 23, 255],
+            "min_area": 2500,
+            "max_area": 300000
+            },
+            {
+            "name": "bot",
+            "is_bot": true,
+            "hsv_lower": [105, 9, 208],
+            "hsv_upper": [116, 43, 243],
+            "min_area": 2500,
+            "max_area": 300000
+        }
+    ]
+
 # --- Configuration Section ---
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 TEMPLATE_DIR = os.path.join(SCRIPT_DIR, "templates")
@@ -145,15 +185,30 @@ def are_bboxes_similar(bbox1: Optional[Tuple[int, int, int, int]],
 # Detection Module
 # ==============================================================================
 class DetectionModule:
-    """Handles finding elements and states on the screen using image recognition."""
+    """Handles finding elements and states on the screen using image recognition or color analysis."""
+
+    def __init__(self, templates: Dict[str, str], confidence: float = CONFIDENCE_THRESHOLD,
+                 state_confidence: float = STATE_CONFIDENCE_THRESHOLD,
+                 region: Optional[Tuple[int, int, int, int]] = SCREENSHOT_REGION):
+        # --- Hardcoded Settings (as per user instruction) ---
+        self.use_color_detection: bool = True # Set to True to enable color detection by default
+        self.color_config_path: str = "bubble_colors.json"
+        # --- End Hardcoded Settings ---
 
-    def __init__(self, templates: Dict[str, str], confidence: float = CONFIDENCE_THRESHOLD, state_confidence: float = STATE_CONFIDENCE_THRESHOLD, region: Optional[Tuple[int, int, int, int]] = SCREENSHOT_REGION):
         self.templates = templates
         self.confidence = confidence
         self.state_confidence = state_confidence
         self.region = region
         self._warned_paths = set()
-        print("DetectionModule initialized.")
+
+        # Load color configuration if color detection is enabled
+        self.bubble_colors = []
+        if self.use_color_detection:
+            self.bubble_colors = load_bubble_colors(self.color_config_path) # Use internal path
+            if not self.bubble_colors:
+                 print("Warning: Color detection enabled, but failed to load any color configurations. Color detection might not work.")
+
+        print(f"DetectionModule initialized. Color Detection: {'Enabled' if self.use_color_detection else 'Disabled'}")
 
     def _find_template(self, template_key: str, confidence: Optional[float] = None, region: Optional[Tuple[int, int, int, int]] = None, grayscale: bool = False) -> List[Tuple[int, int]]:
         """Internal helper to find a template by its key. Returns list of CENTER coordinates."""
@@ -230,10 +285,32 @@ class DetectionModule:
 
     def find_dialogue_bubbles(self) -> List[Dict[str, Any]]:
         """
-        Scan screen for regular and multiple types of bot bubble corners and pair them.
+        Detects dialogue bubbles using either color analysis or template matching,
+        based on the 'use_color_detection' flag. Includes fallback to template matching.
         Returns a list of dictionaries, each containing:
-        {'bbox': (tl_x, tl_y, br_x, br_y), 'is_bot': bool, 'tl_coords': (original_tl_x, original_tl_y)}
+        {'bbox': (tl_x, tl_y, br_x, br_y), 'is_bot': bool, 'tl_coords': (tl_x, tl_y)}
         """
+        # --- Try Color Detection First if Enabled ---
+        if self.use_color_detection:
+            print("Attempting bubble detection using color analysis...")
+            try:
+                # Use a scale factor of 0.5 for performance
+                bubbles = self.find_dialogue_bubbles_by_color(scale_factor=0.5)
+                # If color detection returns results, use them
+                if bubbles:
+                    print("Color detection successful.")
+                    return bubbles
+                else:
+                    print("Color detection returned no bubbles. Falling back to template matching.")
+            except Exception as e:
+                print(f"Color detection failed with error: {e}. Falling back to template matching.")
+                import traceback
+                traceback.print_exc()
+        else:
+             print("Color detection disabled. Using template matching.")
+
+        # --- Fallback to Template Matching ---
+        print("Executing template matching for bubble detection...")
         all_bubbles_info = []
         processed_tls = set() # Keep track of TL corners already used in a bubble
 
@@ -326,6 +403,125 @@ class DetectionModule:
 
         # Note: This logic prioritizes matching regular bubbles first, then bot bubbles.
         # Confidence thresholds might need tuning.
+        print(f"Template matching found {len(all_bubbles_info)} bubbles.") # Added log
+        return all_bubbles_info
+
+    def find_dialogue_bubbles_by_color(self, scale_factor=0.5) -> List[Dict[str, Any]]:
+        """
+        Find dialogue bubbles using color analysis within a specific region.
+        Applies scaling to improve performance.
+        Returns a list of dictionaries, each containing:
+        {'bbox': (tl_x, tl_y, br_x, br_y), 'is_bot': bool, 'tl_coords': (tl_x, tl_y)}
+        """
+        all_bubbles_info = []
+
+        # Define the specific region for bubble detection (same as template matching)
+        bubble_detection_region = (150, 330, 600, 880)
+        print(f"Using bubble color detection region: {bubble_detection_region}")
+
+        try:
+            # 1. Capture the specified region
+            screenshot = pyautogui.screenshot(region=bubble_detection_region)
+            if screenshot is None:
+                print("Error: Failed to capture screenshot for color detection.")
+                return []
+            img = np.array(screenshot)
+            img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # Convert RGB (from pyautogui) to BGR (for OpenCV)
+
+            # 2. Resize for performance
+            if scale_factor < 1.0:
+                h, w = img.shape[:2]
+                new_h, new_w = int(h * scale_factor), int(w * scale_factor)
+                if new_h <= 0 or new_w <= 0:
+                    print(f"Error: Invalid dimensions after scaling: {new_w}x{new_h}. Using original image.")
+                    img_small = img
+                    current_scale_factor = 1.0
+                else:
+                    img_small = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_AREA)
+                    print(f"Original resolution: {w}x{h}, Scaled down to: {new_w}x{new_h}")
+                    current_scale_factor = scale_factor
+            else:
+                img_small = img
+                current_scale_factor = 1.0
+
+            # 3. Convert to HSV color space
+            hsv = cv2.cvtColor(img_small, cv2.COLOR_BGR2HSV)
+
+            # 4. Process each configured bubble type
+            if not self.bubble_colors:
+                print("Error: No bubble color configurations loaded for detection.")
+                return []
+
+            for color_config in self.bubble_colors:
+                name = color_config.get('name', 'unknown')
+                is_bot = color_config.get('is_bot', False)
+                hsv_lower = np.array(color_config.get('hsv_lower', [0,0,0]))
+                hsv_upper = np.array(color_config.get('hsv_upper', [179,255,255]))
+                min_area_config = color_config.get('min_area', 3000)
+                max_area_config = color_config.get('max_area', 100000)
+
+                # Adjust area thresholds based on scaling factor
+                min_area = min_area_config * (current_scale_factor ** 2)
+                max_area = max_area_config * (current_scale_factor ** 2)
+
+                print(f"Processing color type: {name} (Bot: {is_bot}), HSV Lower: {hsv_lower}, HSV Upper: {hsv_upper}, Area: {min_area:.0f}-{max_area:.0f}")
+
+                # 5. Create mask based on HSV range
+                mask = cv2.inRange(hsv, hsv_lower, hsv_upper)
+
+                # 6. Morphological operations (Closing) to remove noise and fill holes
+                kernel = np.ones((3, 3), np.uint8)
+                mask_closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2) # Increased iterations
+
+                # Optional: Dilation to merge nearby parts?
+                # mask_closed = cv2.dilate(mask_closed, kernel, iterations=1)
+
+                # 7. Find connected components
+                num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask_closed)
+
+                # 8. Filter components by area and add to results
+                for i in range(1, num_labels): # Skip background label 0
+                    area = stats[i, cv2.CC_STAT_AREA]
+
+                    if min_area <= area <= max_area:
+                        x_s = stats[i, cv2.CC_STAT_LEFT]
+                        y_s = stats[i, cv2.CC_STAT_TOP]
+                        w_s = stats[i, cv2.CC_STAT_WIDTH]
+                        h_s = stats[i, cv2.CC_STAT_HEIGHT]
+
+                        # Convert coordinates back to original resolution
+                        if current_scale_factor < 1.0:
+                            x = int(x_s / current_scale_factor)
+                            y = int(y_s / current_scale_factor)
+                            width = int(w_s / current_scale_factor)
+                            height = int(h_s / current_scale_factor)
+                        else:
+                            x, y, width, height = x_s, y_s, w_s, h_s
+
+                        # Adjust coordinates relative to the full screen (add region offset)
+                        x_adjusted = x + bubble_detection_region[0]
+                        y_adjusted = y + bubble_detection_region[1]
+
+                        bubble_bbox = (x_adjusted, y_adjusted, x_adjusted + width, y_adjusted + height)
+                        tl_coords = (x_adjusted, y_adjusted) # Top-left coords in full screen space
+
+                        all_bubbles_info.append({
+                            'bbox': bubble_bbox,
+                            'is_bot': is_bot,
+                            'tl_coords': tl_coords
+                        })
+                        print(f"  -> Found '{name}' bubble component. Area: {area:.0f} (Scaled). Original Coords: {bubble_bbox}")
+
+        except pyautogui.FailSafeException:
+             print("FailSafe triggered during color detection.")
+             return []
+        except Exception as e:
+            print(f"Error during color-based bubble detection: {e}")
+            import traceback
+            traceback.print_exc()
+            return [] # Return empty list on error
+
+        print(f"Color detection found {len(all_bubbles_info)} bubbles.")
         return all_bubbles_info
 
     def find_keyword_in_region(self, region: Tuple[int, int, int, int]) -> Optional[Tuple[int, int]]:
@@ -1112,7 +1308,11 @@ def run_ui_monitoring_loop(trigger_queue: queue.Queue, command_queue: queue.Queu
         'reply_button': REPLY_BUTTON_IMG # Added reply button template key
     }
     # Use default confidence/region settings from constants
-    detector = DetectionModule(templates, confidence=CONFIDENCE_THRESHOLD, state_confidence=STATE_CONFIDENCE_THRESHOLD, region=SCREENSHOT_REGION)
+    # Detector now loads its own color settings internally based on hardcoded values
+    detector = DetectionModule(templates,
+                               confidence=CONFIDENCE_THRESHOLD,
+                               state_confidence=STATE_CONFIDENCE_THRESHOLD,
+                               region=SCREENSHOT_REGION)
     # Use default input coords/keys from constants
     interactor = InteractionModule(detector, input_coords=(CHAT_INPUT_CENTER_X, CHAT_INPUT_CENTER_Y), input_template_key='chat_input', send_button_key='send_button')
 
@@ -1120,6 +1320,7 @@ def run_ui_monitoring_loop(trigger_queue: queue.Queue, command_queue: queue.Queu
     last_processed_bubble_info = None # Store the whole dict now
     recent_texts = collections.deque(maxlen=RECENT_TEXT_HISTORY_MAXLEN) # Context-specific history needed
     screenshot_counter = 0 # Initialize counter for debug screenshots
+    main_screen_click_counter = 0 # Counter for consecutive main screen clicks
 
     while True:
         # --- Process ALL Pending Commands First ---
@@ -1220,17 +1421,31 @@ def run_ui_monitoring_loop(trigger_queue: queue.Queue, command_queue: queue.Queu
             base_locs = detector._find_template('base_screen', confidence=0.8)
             map_locs = detector._find_template('world_map_screen', confidence=0.8)
             if base_locs or map_locs:
-                print("UI Thread: Detected main screen (Base or World Map). Clicking to return to chat...")
+                print(f"UI Thread: Detected main screen (Base or World Map). Counter: {main_screen_click_counter}")
-                # Coordinates provided by user (adjust if needed based on actual screen resolution/layout)
+                if main_screen_click_counter < 5:
-                # IMPORTANT: Ensure these coordinates are correct for the target window/resolution
+                    main_screen_click_counter += 1
-                target_x, target_y = 600, 1300
+                    print(f"UI Thread: Attempting click #{main_screen_click_counter}/5 to return to chat...")
-                interactor.click_at(target_x, target_y)
+                    # Coordinates provided by user (adjust if needed based on actual screen resolution/layout)
-                time.sleep(0.1) # Short delay after click
+                    target_x, target_y = 600, 1300
-                print("UI Thread: Clicked to return to chat. Re-checking screen state...")
+                    interactor.click_at(target_x, target_y)
-                continue # Skip the rest of the loop and re-evaluate
+                    time.sleep(0.1) # Short delay after click
+                    print("UI Thread: Clicked. Re-checking screen state...")
+                else:
+                    print("UI Thread: Clicked 5 times, still on main screen. Pressing ESC...")
+                    interactor.press_key('esc')
+                    main_screen_click_counter = 0 # Reset counter after ESC
+                    time.sleep(0.05) # Wait a bit longer after ESC
+                    print("UI Thread: ESC pressed. Re-checking screen state...")
+                continue # Skip the rest of the loop and re-evaluate state
+            else:
+                # Reset counter if not on the main screen
+                if main_screen_click_counter > 0:
+                    print("UI Thread: Not on main screen, resetting click counter.")
+                    main_screen_click_counter = 0
         except Exception as nav_err:
             print(f"UI Thread: Error during main screen navigation check: {nav_err}")
             # Decide if you want to continue or pause after error
+            main_screen_click_counter = 0 # Reset counter on error too
 
         # --- Process Commands Second (Non-blocking) ---
         # This block seems redundant now as commands are processed at the start of the loop.