Upload 20 files

%E5%B9%BA%E9%B8%A1%E8%A1%80%E6%88%98_mGDL.txt

@@ -0,0 +1,120 @@
+(game "YaoJi_XueZhan" (version "1.0.0")
+  ;; ===== Rule-Core: 玩法本体 =====
+  (players 4)
+  (tileset
+    (suits { "wan" "tong" "tiao" })
+    (ranks 1..9)
+    (copies 4)
+    (honors 0)                  ; 无字牌
+    (hongzhong 0)               ; 无红中
+    (total 108)
+  )
+  (seats { "A1" "A2" "A3" "A4" })
+  (turn_order cyclic A1 A2 A3 A4)
+  (actions
+    (allow_chi false)
+    (allow_peng true)
+    (allow_gang { "concealed" "melded" "added" })
+    (one_tile_multi_claim true)   ; 文档若未指明“同张可同时被胡/碰杠”，此处保持关闭
+  )
+  (phases [ "choose_que" "exchange_three" "play" "settle" ])
+
+  (setup
+    (dealer "random")
+    (initial_hand 13)
+    (choose_que
+      (enabled true)
+      (must_keep_under_two_suits_to_win true)  ; “胡牌时手牌中不能超过2门花色”
+      (lock_que true)
+    )
+    (exchange_three
+      (enabled true)
+      (mode "random_one_player")
+      (require_same_suit true)
+      (good_hand_protection
+        (enabled true)
+        (trigger "other_two_suits_count_each_lt_3")) ; “其余2门花色张数均<3触发好牌不换”
+      (exclude_wildcards true)                        ; “幺鸡不参与换三张”
+    )
+  )
+
+  (win_rules
+    (allow_discard_win true)      ; 点炮胡
+    (allow_rob_kong true)         ; 抢杠胡
+    (allow_multi_win true)        ; 一炮多响
+    (post_win_continuation
+      (mode "xuezhan")
+      (end_when_third_player_wins true) ; 有玩家胡后继续，至第3家胡或牌尽结束
+    )
+  )
+
+  (scoring
+    (base_point 1)
+    (self_draw_multiplier 2)         ; 自摸×2
+    (discard_win_multiplier 1)
+    (start_multiplier 8)             ; 起胡：8倍
+    (cap_multiplier 128)             ; 封顶：128倍
+    (count_gang_point false)         ; 不计杠分
+  )
+
+  ;; 倍数番型（“基础番型倍数” + 其余倍数），均为“乘法倍数”，非番制
+  (fan_table
+    ; ---- 基础倍数组 ----
+    (yaku pinghu             (mult 1))
+    (yaku pengpenghu         (mult 2))
+    (yaku gangshangkaihua    (mult 2))
+    (yaku gangshangpao       (mult 2))
+    (yaku qiangganghu        (mult 2))
+    (yaku haidilao           (mult 2))
+    (yaku haidipao           (mult 2))
+    (yaku qidui              (mult 4))
+    (yaku qingyise           (mult 4))
+    (yaku jingoudiao         (mult 4))
+    (yaku longqidui          (mult 8))
+    (yaku qingpeng           (mult 8))
+    (yaku shuanglongqidui    (mult 16))
+    (yaku qingqidui          (mult 16))
+    (yaku qingjingoudiao     (mult 16))
+    (yaku sanlongqidui       (mult 32))
+    (yaku qinglongqidui      (mult 32))
+    (yaku shibaluohan        (mult 64))
+    (yaku qingshuanglongqidui (mult 64))
+    (yaku qingsanlongqidui   (mult 128))
+    (yaku qingshibaluohan    (mult 256))
+    (yaku tianhu             (force_cap true))  ; 天胡：封顶
+    (yaku dihu               (force_cap true))  ; 地胡：封顶
+
+    ; ---- 其他倍数（文档明确列出）----
+    (yaku wujichi            (mult 2) (desc "无鸡胡"))
+    (yaku sanji              (mult 4) (desc "三幺鸡"))
+    (yaku siji               (mult 8) (desc "四幺鸡"))
+    (yaku gen                (mult 2) (desc "四张相同即可，不一定为杠"))
+  )
+
+  (settlement
+    (order [ "flower_pig" "big_call" ])   ; 查花猪 → 查大叫
+    (flower_pig (penalty "to_each_non_pig" (amount "cap_multiplier")))
+    (big_call   (penalty "max_potential_without_selfdraw")) ; “不含自摸倍数”
+  )
+
+  ;; ===== Rule-Addons: 玩法插件（不改变合法性的一致性规则细化） =====
+  (wildcard
+    (type "yaoji")                    ; 幺鸡为赖子
+    (as_any_tile true)
+    (allow_meld_with_real_tile_only true) ; “不得空碰/空杠，须与真牌配合”
+    (added_kong_replace_wildcard_back true) ; “摸到相同牌可把幺鸡换回手中”
+  )
+  (kong_rules
+    (after_added_kong_if_win_count_as "gangshangkaihua") ; “补杠若可胡计杠上开花”
+  )
+
+  ;; ===== Policy Packs: 对局策略（外置，不改变玩法本体） =====
+  (policy_ref
+    (source "/mnt/data/xuezhan_yj.xlsm")
+    (maps
+      (deal.opening_patterns     "开牌/发牌策略表")   ; 起手暖手权重等
+      (draw.draw_strategies      "摸牌规则/权重曲线") ; 随剩余牌量分段的偏置
+    )
+    (rng (algo "PCG32") (seed "room|server|fixed"))
+  )
+)

%E9%BA%BB%E5%B0%86%E6%B8%B8%E6%88%8FmGDL%E9%80%9A%E7%94%A8%E8%AF%AD%E6%B3%95.txt

@@ -0,0 +1,160 @@
+(game "<Variant_Name>" (version "1.0.0")
+  ;; ===== 玩法类型：血战类或血流类 =====
+  (game_variant "blood_war" | "blood_flow" | "<custom_variant>")  ; 游戏类型：血战、血流或自定义玩法
+
+  ;; ===== Rule-Core: 玩法本体 =====
+  (players 4)                                  ; 玩家数量
+  (tileset
+    (suits { "wan" "tong" "tiao" })             ; 花色：万、条、筒
+    (ranks 1..9)                                ; 牌面 1 至 9
+    (copies 4)                                  ; 每张牌有 4 张
+    (honors 0)                                  ; 字牌是否启用（可以通过 `special_mechanics` 启用）
+    (hongzhong 0)                               ; 红中是否启用（可以通过 `special_mechanics` 启用）
+    (total 108)                                 ; 总共 108 张牌
+  )
+
+  ;; ===== Special Mechanics: 特殊机制（幺鸡、红中等） =====
+  (special_mechanics
+    ;; 幺鸡作为赖子牌
+    (wildcard
+      (name "yaoji")                            ; 幺鸡为赖子
+      (tiles { "Tiao" 1 })
+      (substitute_any true)                     ; 幺鸡可以作为任意牌
+      (allow_meld_with_real_tile_only true)     ; 不允许空碰/空杠，必须有真实牌
+      (added_kong_replace_wildcard_back true)   ; 摸到相同牌可以把幺鸡换回手中
+    )
+    ;; 红中作为赖子牌
+    (wildcard
+      (name "hongzhong")                        ; 红中为赖子
+      (tiles { "Zhong" })
+      (substitute_any true)
+      (as_special_yaku_on_discard (name "hongzhong_gang") (mult 10) (draw_after true)) ; 红中杠×10
+      (allow_single_wait_win true)              ; 允许单吊红中胡
+    )
+    ;; 可以继续扩展其他赖子或特殊机制
+  )
+
+  ;; ===== Rule-Core: 玩法本体继续 =====
+  (seats { "A1" "A2" "A3" "A4" })             ; 玩家座位
+  (turn_order cyclic A1 A2 A3 A4)             ; 出牌顺序，循环进行
+  (actions
+    (allow_chi false)                         ; 吃牌规则
+    (allow_peng true)                         ; 碰牌规则
+    (allow_gang { "concealed" "melded" "added" }) ; 杠牌规则：暗杠、明杠、补杠
+    (one_tile_multi_claim true)                ; 允许同张牌同时被胡/碰/杠
+  )
+
+  (phases [ "choose_que" "exchange_three" "play" "settle" ])  ; 游戏阶段：定缺、换三张、行牌、结算
+
+  (setup
+    (dealer "random")                         ; 庄家随机选定
+    (initial_hand 13)                         ; 初始牌 13 张
+    (choose_que
+      (enabled true)
+      (must_keep_under_two_suits_to_win true)  ; 胡牌时手牌中不能超过2门花色
+      (lock_que true)                           ; 锁定定缺，不能更改
+    )
+    (exchange_three
+      (enabled true)
+      (mode "random_one_player")               ; 随机换三张
+      (require_same_suit true)                 ; 要求换三张的牌要同花色
+      (good_hand_protection
+        (enabled true)
+        (trigger "other_two_suits_count_each_lt_3")) ; 如果剩余两门花色张数少于3，则保护好牌不换
+      (exclude_wildcards true)                 ; 不允许用红中、幺鸡换牌
+    )
+  )
+
+  (win_rules
+    (allow_discard_win true)      ; 点炮胡
+    (allow_rob_kong true)         ; 允许抢杠胡
+    (allow_multi_win true)        ; 一炮多响
+    (post_win_continuation
+      (mode "xuezhan")
+      (end_when_third_player_wins true) ; 继续直到第三位玩家胡牌，或牌尽
+    )
+  )
+
+  (scoring
+    (base_point 1)                ; 基础分 1
+    (self_draw_multiplier 2)      ; 自摸×2
+    (discard_win_multiplier 1)    ; 点炮×1
+    (start_multiplier 8)          ; 起胡倍数：8倍
+    (cap_multiplier 128)          ; 封顶倍数：128倍
+    (count_gang_point false)      ; 不计杠分
+  )
+
+  ;; 动态番型与倍数定义
+  (fan_table
+    ;; ---- 基础番型 ----
+    (yaku pinghu             (mult 1))
+    (yaku pengpenghu         (mult 2))
+    (yaku gangshangkaihua    (mult 2))
+    (yaku gangshangpao       (mult 2))
+    (yaku qiangganghu        (mult 2))
+    (yaku haidilao           (mult 2))
+    (yaku haidipao           (mult 2))
+    (yaku qidui              (mult 4))
+    (yaku qingyise           (mult 4))
+    (yaku jingoudiao         (mult 4))
+    (yaku longqidui          (mult 8))
+    (yaku qingpeng           (mult 8))
+    (yaku shuanglongqidui    (mult 16))
+    (yaku qingqidui          (mult 16))
+    (yaku qingjingoudiao     (mult 16))
+    (yaku sanlongqidui       (mult 32))
+    (yaku qinglongqidui      (mult 32))
+    (yaku shibaluohan        (mult 64))
+    (yaku qingshuanglongqidui (mult 64))
+    (yaku qingsanlongqidui   (mult 128))
+    (yaku qingshibaluohan    (mult 256))
+    (yaku tianhu             (force_cap true))  ; 天胡：封顶
+    (yaku dihu               (force_cap true))  ; 地胡：封顶
+
+    ;; ---- 动态添加的番型（基于特殊机制启用） ----
+    ;; 幺鸡启用后添加相关番型
+    (if (enabled "yaoji") 
+      (yaku laizihu          (mult 5) (desc "赖子胡：含幺鸡的胡牌"))  ; 赖子胡番型
+      (yaku yaoji_jiafu      (mult 2) (desc "幺鸡加番：幺鸡作为加番"))   ; 幺鸡加番
+
+    ;; 红中启用后添加相关番型
+    (if (enabled "hongzhong") 
+      (yaku hongzhong_gang   (mult 10) (desc "红中杠：红中作为杠牌计分"))
+      (yaku hongzhong_hu     (mult 3) (desc "红中胡：胡牌时红中作为赖子"))
+    )
+
+    ;; ---- 其他倍数 ----
+    (yaku wujichi            (mult 2) (desc "无鸡胡"))
+    (yaku sanji              (mult 4) (desc "三幺鸡"))
+    (yaku siji               (mult 8) (desc "四幺鸡"))
+    (yaku gen                (mult 2) (desc "四张相同即可，不一定为杠"))
+  )
+
+  (settlement
+    (order [ "flower_pig" "big_call" ])   ; 查花猪 → 查大叫
+    (flower_pig (penalty "to_each_non_pig" (amount "cap_multiplier")))
+    (big_call   (penalty "max_potential_without_selfdraw")) ; 不含自摸倍数
+  )
+
+  ;; ===== Rule-Addons: 玩法插件（不改变合法性的一致性规则细化） =====
+  (wildcard
+    (type "none"))
+  (kong_rules
+    (after_added_kong_if_win_count_as "gangshangkaihua")
+  )
+
+  ;; ===== Policy Packs: 对局策略（外置，不改变玩法本体） =====
+  (policy_ref
+    (source "/mnt/data/xueliu_hz3_v2温暖摸牌.xlsm")
+    (maps (deal.opening_warm_pools "温暖摸牌/好牌池配置") (room_binding "房间→暖手策略"))
+    (rng (algo "PCG32") (seed "room|server|fixed"))
+  )
+  (policy_ref
+    (source "/mnt/data/疯狂血流摸牌规则.xlsm")
+    (maps (draw.draw_strategies "摸牌规则/有无红中分支/余牌分段权重"))
+  )
+  (policy_ref
+    (source "/mnt/data/疯狂血流番型叠加.xlsx")
+    (maps (fan_table.stack_matrix "叠加矩阵")) ; 上文已固化为 stack-with；此处保留外部来源追溯
+  )
+)

ai_service.py

@@ -0,0 +1,239 @@
+"""
+AI 服务模块 - 处理与 AI 模型的交互（支持原生流式输出）
+"""
+from openai import OpenAI
+from config import API_KEY, API_BASE_URL, MODEL_NAME, MAX_TOKENS, TEMPERATURE, TOP_P, SYSTEM_PROMPT
+from file_handler import load_gdl_text
+from cache_manager import request_cache
+from security import input_validator
+from default_content import get_default_gdl, get_default_prompt, get_default_example_gdl
+
+# 初始化OpenAI客户端（DeepSeek V3兼容）
+client = OpenAI(
+    api_key=API_KEY,
+    base_url=API_BASE_URL
+)
+
+
+# ========== 公共小工具 ==========
+def _prepare_messages(message, history, uploaded_files, custom_prompt_text, prompt_mode):
+    """
+    组装 messages，保证与非流式/流式两条路径的提示词一致
+    """
+    # 1) 选择 System Prompt
+    base_sys = (SYSTEM_PROMPT or "").strip()
+    user_sys = (custom_prompt_text or "").strip()
+    mode = (prompt_mode or "覆盖默认SYSTEM_PROMPT").strip()
+    
+    # 🟢 如果用户没有提供自定义 prompt，则使用默认的 prompt 内容
+    if not user_sys:
+        default_prompt = get_default_prompt()
+        if default_prompt:
+            user_sys = default_prompt
+
+    if user_sys:
+        wrapped_user_sys = f"<TEAM_PROMPT>\n{user_sys}\n</TEAM_PROMPT>"
+        system_to_use = (base_sys + "\n\n" + wrapped_user_sys) if mode.startswith("合并") else wrapped_user_sys
+    else:
+        system_to_use = base_sys
+
+    messages = [{"role": "system", "content": system_to_use}]
+
+    # 2) 注入上传的 GDL（作为第二条 system）
+    # 🟢 如果用户没有上传文件，则使用默认的 GDL 内容
+    gdl_spec = load_gdl_text(uploaded_files)
+    if not gdl_spec:
+        gdl_spec = get_default_gdl()
+    
+    if gdl_spec:
+        messages.append({
+            "role": "system",
+            "content": "以下为用户上传的麻将游戏通用语言（mGDL）规范或示例，请在设计与输出中严格遵循：\n<GDL_SPEC>\n"
+                       + gdl_spec + "\n</GDL_SPEC>"
+        })
+
+    # 2.5) 注入示例 GDL 文档（作为参考示例）
+    # 🟢 自动加载示例 GDL 文档，供 AI 参考
+    example_gdl = get_default_example_gdl()
+    if example_gdl:
+        messages.append({
+            "role": "system",
+            "content": "以下为示例 GDL 文档，供您参考设计时使用：\n<EXAMPLE_GDL>\n"
+                       + example_gdl + "\n</EXAMPLE_GDL>"
+        })
+
+    # 3) 追加历史对话
+    for human, assistant in (history or []):
+        if human:
+            messages.append({"role": "user", "content": human})
+        if assistant:
+            messages.append({"role": "assistant", "content": assistant})
+
+    # 4) 当前输入
+    messages.append({"role": "user", "content": message})
+
+    return messages
+
+
+def _yield_chunks(text, step=40):
+    """把整段文本切成小块，伪流式输出。"""
+    s = str(text or "")
+    for i in range(0, len(s), step):
+        yield s[i:i + step]
+
+
+
+
+
+# ========== 非流式（保留你原实现，便于兼容） ==========
+def design_mahjong_game(message, history, uploaded_files, custom_prompt_text, prompt_mode):
+    """
+    设计麻将玩法的主要函数（非流式）
+    """
+    # 输入验证
+    is_valid, error_msg = input_validator.validate_message(message)
+    if not is_valid:
+        return f"❌ 输入验证失败：{error_msg}"
+
+    is_valid, error_msg = input_validator.validate_custom_prompt(custom_prompt_text)
+    if not is_valid:
+        return f"❌ 自定义提示词验证失败：{error_msg}"
+
+    is_valid, error_msg = input_validator.validate_file_list(uploaded_files)
+    if not is_valid:
+        return f"❌ 文件验证失败：{error_msg}"
+
+    messages = _prepare_messages(message, history, uploaded_files, custom_prompt_text, prompt_mode)
+
+    # 仅在“无历史”时启用缓存（沿用你的策略）
+    if len(history or []) == 0:
+        cached_response = request_cache.get(messages)
+        if cached_response:
+            return cached_response
+
+    response = _call_ai_model(messages)
+
+    if len(history or []) == 0 and response and not response.startswith(("❌", "💥")):
+        request_cache.set(messages, response)
+
+    return response
+
+
+def _call_ai_model(messages):
+    """
+    调用 AI 模型（非流式）
+    """
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            temperature=TEMPERATURE,
+            top_p=TOP_P,
+            max_tokens=MAX_TOKENS,
+        )
+
+        content = response.choices[0].message.content
+        if not content or content.strip() == "":
+            return "🤔 AI 返回了空内容，请尝试重新发送或调整输入。"
+        return content
+
+    except ConnectionError as e:
+        return f"🌐 网络连接错误：{str(e)}\n\n请检查网络连接是否正常。"
+    except TimeoutError as e:
+        return f"⏰ 请求超时：{str(e)}\n\n请稍后重试，��尝试减少输入内容长度。"
+    except Exception as e:
+        error_type = type(e).__name__
+        error_msg = str(e)
+        return f"💥 调用失败：{error_type}: {error_msg}\n\n请检查 API Key 是否正确，或网络是否通畅。"
+
+
+# ========== 新增：原生流式 ==========
+def design_mahjong_game_stream(message, history, uploaded_files, custom_prompt_text, prompt_mode):
+    """
+    原生流式：逐段 yield 文本片段（字符串）
+    """
+    # 1) 输入验证（与非流式一致）
+    is_valid, error_msg = input_validator.validate_message(message)
+    if not is_valid:
+        yield f"❌ 输入验证失败：{error_msg}"
+        return
+
+    is_valid, error_msg = input_validator.validate_custom_prompt(custom_prompt_text)
+    if not is_valid:
+        yield f"❌ 自定义提示词验证失败：{error_msg}"
+        return
+
+    is_valid, error_msg = input_validator.validate_file_list(uploaded_files)
+    if not is_valid:
+        yield f"❌ 文件验证失败：{error_msg}"
+        return
+
+    # 2) 组装 messages（与非流式完全一致）
+    messages = _prepare_messages(message, history, uploaded_files, custom_prompt_text, prompt_mode)
+
+    # 3) 无历史时的缓存命中
+    no_hist = len(history or []) == 0
+    if no_hist:
+        cached = request_cache.get(messages)
+        if cached:
+            for piece in _yield_chunks(cached, step=48):
+                yield piece
+            return
+
+    # 4) 原生流式调用（OpenAI兼容API）
+    buf = []
+    try:
+        stream = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            temperature=TEMPERATURE,
+            top_p=TOP_P,
+            max_tokens=MAX_TOKENS,
+            stream=True,
+        )
+
+        # 简单的字符级节流（攒到一定长度再刷新，提高前端性能）
+        cache_piece = []
+        cache_len = 0
+        FLUSH_EVERY = 24  # 每凑够 N 字符刷新一次；可按需调整
+
+        for chunk in stream:
+            # 安全地提取增量文本
+            delta = None
+            if chunk.choices and len(chunk.choices) > 0:
+                delta_obj = chunk.choices[0].delta
+                if delta_obj and hasattr(delta_obj, 'content'):
+                    delta = delta_obj.content
+
+            # 有的帧是控制帧，不含文本
+            if not delta:
+                continue
+
+            buf.append(delta)
+            cache_piece.append(delta)
+            cache_len += len(delta)
+
+            # 小节流：积累到一定字符再 yield
+            if cache_len >= FLUSH_EVERY:
+                text_chunk = "".join(cache_piece)
+                cache_piece.clear()
+                cache_len = 0
+                yield text_chunk
+
+        # 循环结束，把最后没刷出去的片段刷掉
+        if cache_piece:
+            yield "".join(cache_piece)
+
+        # 5) 写入缓存（仅无历史 & 正常内容）
+        full = "".join(buf).strip()
+        if no_hist and full and not full.startswith(("❌", "💥")):
+            request_cache.set(messages, full)
+
+    except ConnectionError as e:
+        yield f"\n🌐 网络连接错误：{str(e)}"
+    except TimeoutError as e:
+        yield f"\n⏰ 请求超时：{str(e)}"
+    except Exception as e:
+        # 这里不再抛具体 KeyError，而是把异常消息直接展示出来，避免中断生成器
+        yield f"\n💥 流式调用失败：{type(e).__name__}: {e}"
+

app.py

@@ -0,0 +1,537 @@
+import gradio as gr
+import os
+
+# ===== 你的自定义模块 =====
+from config import APP_TITLE, CHATBOT_HEIGHT, MIN_WIDTH_LEFT, MIN_WIDTH_RIGHT
+from styles import MAHJONG_THEME_CSS
+
+# Extra CSS to force dark & counter browser auto-invert
+EXTRA_FIX_CSS = '''/* === Force dark site and neutralize browser-side auto-invert === */
+html, body{ background-color:#0b1220 !important; color-scheme: dark !important; }
+/* When browser/extension applies global invert, add a counter-invert on our app root */
+html.force-dark-fix #app-root{ filter: invert(1) hue-rotate(180deg) !important; }'''
+# Redirect to ?__theme=dark
+FORCE_DARK_REDIRECT = '''<script>
+(function(){
+  try{
+    const url=new URL(window.location.href);
+    if(url.searchParams.get("__theme")!=="dark"){
+      url.searchParams.set("__theme","dark");
+      window.location.replace(url.toString());
+    }
+  }catch(e){}
+})();
+</script>'''
+# Detect browser force-dark and set html class
+DETECT_FORCE_DARK = '''<script>
+(function(){
+  try{
+    const html=document.documentElement;
+    const cs=getComputedStyle(html);
+    const hasGlobalFilter=(cs.filter && cs.filter!=="none");
+    const darkReaderOn=!!document.querySelector('style#dark-reader-style')||!!document.querySelector('meta[name="darkreader"]');
+    if(hasGlobalFilter||darkReaderOn){ html.classList.add('force-dark-fix'); }
+  }catch(e){}
+})();
+</script>'''
+from ai_service import design_mahjong_game
+# 优先尝试原生流式；没有则自动回退为伪流式
+try:
+    from ai_service import design_mahjong_game_stream
+except Exception:
+    design_mahjong_game_stream = None
+
+
+# ====== 🔧 Hotfix: 兼容 gradio_client 对 additionalProperties(bool) 的解析 ======
+try:
+    import gradio_client.utils as _gc_utils
+
+    _orig_get_type = _gc_utils.get_type
+    def _safe_get_type(schema):
+        if isinstance(schema, bool):
+            return "any" if schema else "never"
+        return _orig_get_type(schema)
+    _gc_utils.get_type = _safe_get_type
+
+    _orig_json2py = _gc_utils._json_schema_to_python_type
+    def _safe_json2py(schema, defs):
+        if isinstance(schema, bool):
+            return "any" if schema else "never"
+        if isinstance(schema, dict) and "additionalProperties" in schema:
+            ap = schema["additionalProperties"]
+            if isinstance(ap, bool):
+                inner = "any" if ap else "never"
+                return f"dict[str, {inner}]"
+        return _orig_json2py(schema, defs)
+    _gc_utils._json_schema_to_python_type = _safe_json2py
+
+    _orig_json_schema_to_python_type = _gc_utils.json_schema_to_python_type
+    def _safe_json_schema_to_python_type(schema):
+        if isinstance(schema, bool):
+            return "any" if schema else "never"
+        return _orig_json_schema_to_python_type(schema)
+    _gc_utils.json_schema_to_python_type = _safe_json_schema_to_python_type
+except Exception:
+    pass
+# ====== 🔧 Hotfix 结束 ======
+
+
+# ==================== 工具函数 ====================
+def _messages_to_tuples(history):
+    """
+    将 Chatbot 的 messages 格式（[{role, content}, ...]）转换为 [(user, bot), ...]。
+    若已是 tuples，则原样返回。
+    """
+    if not history:
+        return []
+
+    if isinstance(history, list) and history and isinstance(history[0], dict):
+        pairs = []
+        last_user = None
+        for msg in history:
+            role = msg.get("role")
+            content = msg.get("content", "")
+            if role == "user":
+                last_user = content
+            elif role == "assistant":
+                pairs.append((last_user or "", content))
+                last_user = None
+        return pairs
+
+    return history
+
+
+def _chunk_fake_stream(text, step=40):
+    """把整段文本切成小块，伪流式输出。"""
+    s = str(text or "")
+    for i in range(0, len(s), step):
+        yield s[i:i + step]
+
+
+def _load_base64_image(path):
+    """读取本地图片并返回 data URI"""
+    import base64
+    import pathlib
+
+    p = pathlib.Path(path)
+    if not p.exists():
+        return ""
+    try:
+        data = base64.b64encode(p.read_bytes()).decode("ascii")
+        suffix = p.suffix.lower()
+        mime = "image/png" if suffix == ".png" else "image/jpeg"
+        return f"data:{mime};base64,{data}"
+    except Exception:
+        return ""
+
+
+HERO_TILE_PATHS = ["UI00001.jpg", "UI00002.jpg", "UI00003.jpg", "UI00004.jpg"]
+HERO_TILE_IMAGES = [_load_base64_image(p) for p in HERO_TILE_PATHS]
+
+
+def _render_hero_tiles():
+    tiles = [
+        f'<span class="hero-photo" style="background-image:url(\'{src}\');" title="参考图 {idx + 1}"></span>'
+        for idx, src in enumerate(HERO_TILE_IMAGES)
+        if src
+    ]
+    return "".join(tiles)
+
+
+def clear_cache():
+    """清空缓存"""
+    from cache_manager import file_cache, request_cache
+    file_cache.clear()
+    request_cache.clear()
+    return "✅ 缓存已清空"
+
+
+def clear_files():
+    """清空文件上传"""
+    return None
+
+
+def update_file_status(files):
+    """更新文件状态显示"""
+    if not files:
+        return "📁 文件状态：未上传"
+    file_list = files if isinstance(files, (list, tuple)) else [files]
+    names = []
+    for f in file_list:
+        if isinstance(f, str):
+            names.append(os.path.basename(f))
+        else:
+            names.append(os.path.basename(getattr(f, "name", str(f))))
+    head = "\n".join(f"  • {n}" for n in names[:3])
+    tail = "\n  ..." if len(names) > 3 else ""
+    return f"📁 文件状态：已上传 {len(names)} 个文件\n{head}{tail}"
+
+
+def export_history_to_markdown(history):
+    """将聊天历史导出为 Markdown 文件，并返回文件路径供下载"""
+    import time
+    import pathlib
+    from datetime import datetime
+
+    pairs = _messages_to_tuples(history)
+
+    lines = ["# 对话记录", ""]
+    lines.append(f"- 导出时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    lines.append("")
+    for idx, (user_msg, bot_msg) in enumerate(pairs, start=1):
+        lines.append(f"## 轮次 {idx}")
+        if user_msg:
+            lines.append("**用户**:\n")
+            lines.append(user_msg)
+            lines.append("")
+        if bot_msg:
+            lines.append("**助手**:\n")
+            lines.append(bot_msg)
+            lines.append("")
+
+    content = "\n".join(lines).strip() + "\n"
+
+    export_dir = pathlib.Path("exports")
+    export_dir.mkdir(parents=True, exist_ok=True)
+    filename = export_dir / f"chat_history_{int(time.time())}.md"
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(content)
+    return str(filename)
+
+# ==================== 新增：提取 GDL 和自然语言描述 ====================
+def extract_gdl_and_narrative(content):
+    """提取 GDL 和自然语言部分（支持多种格式变体）"""
+    import re
+    
+    # 定义多种可能的标记格式（按优先级排序，支持更多变体）
+    gdl_patterns = [
+        r"##\s*m?GDL\s*描述",          # ## GDL描述 / ## mGDL 描述
+        r"m?GDL\s*描述",               # GDL描述 / mGDL 描述
+        r"##\s*GDL\s*Description",    # ## GDL Description（英文）
+        r"##\s*m?GDL",                 # ## GDL / ## mGDL
+        r"m?GDL\s*规则代码",            # mGDL 规则代码
+        r"m?GDL\s*规则",               # mGDL 规则
+    ]
+    
+    narrative_patterns = [
+        r"##\s*自然语言规则说明",      # ## 自然语言规则说明
+        r"##\s*自然语言规则",          # ## 自然语言规则
+        r"自然语言规则说明",            # 自然语言规则说明
+        r"自然语言规则",                # 自然语言规则
+        r"##\s*规则说明",              # ## 规则说明
+        r"规则说明",                    # 规则说明
+    ]
+    
+    # 尝试查找 GDL 部分（支持大小写不敏感）
+    gdl_start = -1
+    for pattern in gdl_patterns:
+        match = re.search(pattern, content, re.IGNORECASE)
+        if match:
+            gdl_start = match.start()
+            break
+    
+    # 尝试查找自然语言部分（支持大小写不敏感）
+    narrative_start = -1
+    for pattern in narrative_patterns:
+        match = re.search(pattern, content, re.IGNORECASE)
+        if match:
+            narrative_start = match.start()
+            break
+    
+    if gdl_start != -1 and narrative_start != -1:
+        # 确保顺序正确（GDL应该在自然语言之前）
+        if gdl_start >= narrative_start:
+            gdl_start, narrative_start = narrative_start, gdl_start
+        
+        # 获取 GDL 部分（从标记开始到自然语言标记之前）
+        gdl_content = content[gdl_start:narrative_start].strip()
+        
+        # 获取自然语言部分（从标记开始到结尾）
+        narrative_content = content[narrative_start:].strip()
+        
+        return gdl_content, narrative_content
+    
+    elif gdl_start != -1:
+        # 只找到GDL，将后面全部作为GDL
+        print(f"⚠️ 仅找到GDL标记，将其后内容作为GDL")
+        return content[gdl_start:].strip(), ""
+    
+    elif narrative_start != -1:
+        # 只找到自然语言，将后面全部作为自然语言
+        print(f"⚠️ 仅找到自然语言标记，将其后内容作为自然语言")
+        return "", content[narrative_start:].strip()
+    
+    else:
+        # 都没找到，返回空
+        print(f"⚠️ 提取警告: 未找到GDL和自然语言标记")
+        return "", ""
+
+def save_gdl_and_narrative(gdl_content, narrative_content):
+    """保存 GDL 和自然语言内容到文件"""
+    # 定义文件存储路径
+    export_dir = os.path.join("exports")
+    os.makedirs(export_dir, exist_ok=True)
+    
+    gdl_file_path = os.path.join(export_dir, "gdl_output.txt")
+    narrative_file_path = os.path.join(export_dir, "narrative_output.txt")
+
+    # 保存 GDL
+    with open(gdl_file_path, "w", encoding="utf-8") as f:
+        f.write(gdl_content)
+
+    # 保存自然语言
+    with open(narrative_file_path, "w", encoding="utf-8") as f:
+        f.write(narrative_content)
+
+    return gdl_file_path, narrative_file_path
+
+
+# ==================== Gradio 界面（Mahjong Skin） ====================
+with gr.Blocks(
+    theme=gr.themes.Soft(primary_hue='green', neutral_hue='slate'),
+    title=APP_TITLE,
+    css=MAHJONG_THEME_CSS + EXTRA_FIX_CSS,
+    elem_id='app-root'
+) as demo:
+    gr.HTML(FORCE_DARK_REDIRECT)
+    gr.HTML(DETECT_FORCE_DARK)
+    # 顶部 Hero
+    hero_tiles_html = _render_hero_tiles()
+    gr.HTML(f"""
+    <div class="hero">
+      <div style="display:flex;align-items:center;gap:12px;">
+        <div style="font-size:30px;">🀄️ 麻将玩法灵感工坊 · KOI Lab</div>
+      </div>
+      <div style="margin-top:6px;opacity:.92;">与 AI 麻将策划智囊对话，快速生成番型体系与玩法流程</div>
+      <div class="hero-icons" aria-hidden="true">
+        {hero_tiles_html or '<span class="hero-photo"></span>'}
+      </div>
+    </div>
+    """)
+
+    with gr.Row(equal_height=True):
+        # 左侧：设置区
+        with gr.Column(scale=1, min_width=MIN_WIDTH_LEFT):
+            with gr.Group(elem_classes="side-card"):
+                gr.Markdown("### 输入与约束")
+                gr.Markdown("✅ **系统已预加载 Mahjong GDL 规范与提示词**，可直接开局。", elem_classes="hint")
+                file_uploader = gr.File(
+                    label="上传自定义 Mahjong GDL/番型示例（.txt，可多选）",
+                    file_types=[".txt"],
+                    file_count="multiple",
+                    type="filepath",
+                    interactive=True,
+                    show_label=True,
+                    container=True,
+                    scale=1
+                )
+                custom_prompt_box = gr.Textbox(
+                    label="自定义 System Prompt（可选）",
+                    placeholder="系统已经载入麻将玩法专家提示词。如需特殊规则，可在此粘贴。",
+                    lines=10,
+                    max_lines=20,
+                    show_copy_button=True
+                )
+                prompt_mode = gr.Radio(
+                    choices=["覆盖默认SYSTEM_PROMPT", "合并（默认在前）"],
+                    value="覆盖默认SYSTEM_PROMPT",
+                    label="自定义 Prompt 的使用方式"
+                )
+                gr.Markdown("💡 提示：系统默认包含麻将通用语法、番型模板与 Prompt；仅当你要替换地方规则时再上传或输入。", elem_classes="hint")
+
+            with gr.Group(elem_classes="side-card"):
+                gr.Markdown("### 使用说明")
+                gr.Markdown(
+                    "- ✅ **快速开始**：直接描述你想要的麻将玩法主题或目标。\n"
+                    "- 📁 **可选上传**：导入地方番型表或自定义 GDL 模板以便引用。\n"
+                    "- ✏️ **可选自定义**：针对特殊风格重写 System Prompt。\n"
+                    "- 🔄 **清空缓存**：切换规则后建议刷新缓存，避免残留设定。"
+                )
+
+            with gr.Group(elem_classes="side-card"):
+                gr.Markdown("### 快捷操作")
+                with gr.Row():
+                    clear_cache_btn = gr.Button("清空缓存", variant="secondary")
+                    clear_files_btn = gr.Button("清空文件", variant="secondary")
+                cache_status = gr.Markdown("💾 缓存状态：正常", elem_classes="hint")
+                file_status = gr.Markdown("📁 文件状态：使用默认麻将配置（GDL + Prompt 已预加载）", elem_classes="hint")
+
+        # 右侧：聊天区（手动事件绑定 + 流式输出）
+        with gr.Column(scale=2, min_width=MIN_WIDTH_RIGHT):
+            with gr.Group(elem_classes="table"):
+                chatbot = gr.Chatbot(
+                    height=CHATBOT_HEIGHT,
+                    type="messages",
+                    elem_classes="custom-chatbot",
+                    avatar_images=("landlord.png", "bot.png"),
+                )
+                # 用 State 保存 messages 历史
+                chat_state = gr.State([])  # list[dict]: [{"role":"user","content":...}, {"role":"assistant","content":...}]
+                gdl_file_path = gr.State("")
+                narrative_file_path = gr.State("")
+
+                user_input = gr.Textbox(
+                    placeholder="例如：为4人竞速推倒胡设计番型与流程；或“做一个双人合作麻将 roguelike” …",
+                    show_label=False,
+                    max_lines=5,
+                    lines=3,
+                    show_copy_button=True,
+                    autofocus=True,
+                )
+
+                with gr.Row():
+                    send_btn = gr.Button("发送", variant="primary")
+                    stop_info = gr.Markdown("", visible=False)
+
+                # ====== 核心：流式提交回调（生成器） ======
+                def on_submit(user_text, history_msgs, files, custom_prompt, mode):
+                    user_text = (user_text or "").strip()
+                    if not user_text:
+                        # 不提交空消息：输出不变
+                        yield history_msgs, "", history_msgs, "", ""  # 🟩【修改】输出数量改为5个
+                        return
+
+                    # 立即显示“用户消息”
+                    history = list(history_msgs or [])
+                    history.append({"role": "user", "content": user_text})
+                    yield history, "", history, "", ""
+
+                    # 添加空的助手气泡，用于逐步填充
+                    history.append({"role": "assistant", "content": ""})
+                    yield history, "", history, "", ""
+
+                    # 流式生成内容
+                    tuples_hist = _messages_to_tuples(history)
+
+                    if design_mahjong_game_stream is not None:
+                        try:
+                            for piece in design_mahjong_game_stream(user_text, tuples_hist, files, custom_prompt, mode):
+                                if not piece:
+                                    continue
+                                history[-1]["content"] += str(piece)
+                                yield history, "", history, "", ""
+                        except Exception as e:
+                            history[-1]["content"] += f"\n（流式出错）{type(e).__name__}: {e}"
+                            yield history, "", history, "", ""
+                    else:
+                        try:
+                            full = design_mahjong_game(user_text, tuples_hist, files, custom_prompt, mode)
+                        except Exception as e:
+                            full = f"（出错）{type(e).__name__}: {e}"
+                        for piece in _chunk_fake_stream(str(full), step=40):
+                            history[-1]["content"] += piece
+                            yield history, "", history, "", ""
+
+                    # 提取 GDL 和自然语言描述并保存
+                    try:
+                        gdl_content, narrative_content = extract_gdl_and_narrative(history[-1]["content"])
+                        
+                        # 保存 GDL 和自然语言文件
+                        gdl_path, narrative_path = save_gdl_and_narrative(gdl_content, narrative_content)
+                        
+                        # 返回文件路径，以便下载
+                        yield history, "", history, gdl_path, narrative_path  # 🟩【修改】返回文件路径
+                    except Exception as e:
+                        print(f"保存GDL和自然语言文件时出错: {e}")
+                        yield history, "", history, "", ""  # 🟩【修改】返回空路径
+
+                # 绑定：回车提交（Enter=提交；Shift+Enter=换行由浏览器处理）
+                user_input.submit(
+                    fn=on_submit,
+                    inputs=[user_input, chat_state, file_uploader, custom_prompt_box, prompt_mode],
+                    outputs=[chatbot, user_input, chat_state, gdl_file_path, narrative_file_path],  # 🟩【修改】输出改为5个
+                    preprocess=True,
+                )
+
+                # 绑定：点击"发送"
+                send_btn.click(
+                    fn=on_submit,
+                    inputs=[user_input, chat_state, file_uploader, custom_prompt_box, prompt_mode],
+                    outputs=[chatbot, user_input, chat_state, gdl_file_path, narrative_file_path],  # 🟩【修改】输出改为5个
+                    preprocess=True,
+                )
+
+                # 导出对话
+                with gr.Row():
+                    export_btn = gr.Button("导出对话（Markdown）", variant="secondary")
+                    export_file = gr.File(label="点击下载导出文件", interactive=False)
+
+                # 清空对话
+                with gr.Row():
+                    clear_dialog_btn = gr.Button("清空对话", variant="secondary")
+
+                def _clear_chat():
+                    return [], "", [], "", "" 
+
+                clear_dialog_btn.click(
+                    fn=_clear_chat,
+                    inputs=None,
+                    outputs=[chatbot, user_input, chat_state, gdl_file_path, narrative_file_path],  # 🟩【修改】输出改为5个
+                )
+
+                # ==================== 下载按钮部分 ====================
+                with gr.Row():
+                    gr.Markdown("### 下载 GDL 和自然语言描述")
+                    download_gdl_btn = gr.Button("下载 GDL 文件", variant="secondary")  # 下载 GDL 按钮
+                    download_narrative_btn = gr.Button("下载自然语言文件", variant="secondary")  # 下载自然语言按钮
+
+                    download_gdl_file = gr.File(label="GDL 文件", interactive=False)  # 文件下载区域
+                    download_narrative_file = gr.File(label="自然语言文件", interactive=False)  # 文件下载区域
+
+                # 🟩【修改】绑定下载按钮与文件路径 - 修复版本
+                def get_gdl_file(gdl_path):
+                    if gdl_path and os.path.exists(gdl_path):
+                        return gdl_path
+                    return None
+
+                def get_narrative_file(narrative_path):
+                    if narrative_path and os.path.exists(narrative_path):
+                        return narrative_path
+                    return None
+
+                # 绑定下载按钮与文件路径
+                download_gdl_btn.click(
+                    fn=get_gdl_file,
+                    inputs=[gdl_file_path],  # 🟩【修改】接收State中的路径
+                    outputs=[download_gdl_file]
+                )
+
+                download_narrative_btn.click(
+                    fn=get_narrative_file,
+                    inputs=[narrative_file_path],  # 🟩【修改】接收State中的路径
+                    outputs=[download_narrative_file]
+                )
+
+    # ==================== 事件绑定（左侧） ====================
+    clear_cache_btn.click(fn=clear_cache, outputs=[cache_status])
+    clear_files_btn.click(fn=clear_files, outputs=[file_uploader])
+    file_uploader.change(fn=update_file_status, inputs=[file_uploader], outputs=[file_status])
+
+    # 导出按钮
+    def _export_wrapper(chat_history):
+        try:
+            path = export_history_to_markdown(chat_history)
+            return path
+        except Exception as e:
+            import tempfile
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".md")
+            with open(tmp.name, 'w', encoding='utf-8') as f:
+                f.write(f"导出失败：{type(e).__name__}: {e}\n")
+            return tmp.name
+
+    export_btn.click(fn=_export_wrapper, inputs=[chatbot], outputs=[export_file])
+
+
+# ==================== 启动应用 ====================
+if __name__ == "__main__":
+    # 兼容不同 gradio 版本：
+    # - 有的版本 queue() 不接受 concurrency_count/status_update_rate
+    # - 有的版本甚至不需要手动 queue()
+    app = demo
+    try:
+        app = demo.queue()   # 不带参数，启用队列以支持生成器流式
+    except TypeError:
+        # 某些版本 queue() 可能参数或签名不同，直接跳过即可
+        app = demo
+    app.launch(share=True, show_api=False)
+

cache_manager.py

@@ -0,0 +1,190 @@
+"""
+缓存管理模块 - 提供文件缓存和请求缓存功能
+"""
+import hashlib
+import os
+import time
+from typing import Dict, Any, Optional
+
+
+class FileCache:
+    """文件缓存管理器"""
+    
+    def __init__(self, cache_dir: str = ".cache", max_age: int = 3600):
+        """
+        初始化文件缓存
+        
+        Args:
+            cache_dir: 缓存目录
+            max_age: 缓存最大存活时间（秒）
+        """
+        self.cache_dir = cache_dir
+        self.max_age = max_age
+        self._ensure_cache_dir()
+    
+    def _ensure_cache_dir(self):
+        """确保缓存目录存在"""
+        if not os.path.exists(self.cache_dir):
+            os.makedirs(self.cache_dir, exist_ok=True)
+    
+    def _get_cache_key(self, file_path: str) -> str:
+        """生成缓存键"""
+        # 使用文件路径和修改时间生成唯一键
+        stat = os.stat(file_path)
+        key_data = f"{file_path}:{stat.st_mtime}:{stat.st_size}"
+        return hashlib.md5(key_data.encode()).hexdigest()
+    
+    def _get_cache_path(self, cache_key: str) -> str:
+        """获取缓存文件路径"""
+        return os.path.join(self.cache_dir, f"{cache_key}.cache")
+    
+    def get(self, file_path: str) -> Optional[str]:
+        """
+        从缓存获取文件内容
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            文件内容或None（如果缓存不存在或过期）
+        """
+        if not os.path.exists(file_path):
+            return None
+            
+        cache_key = self._get_cache_key(file_path)
+        cache_path = self._get_cache_path(cache_key)
+        
+        if not os.path.exists(cache_path):
+            return None
+            
+        # 检查缓存是否过期
+        cache_age = time.time() - os.path.getmtime(cache_path)
+        if cache_age > self.max_age:
+            os.remove(cache_path)
+            return None
+            
+        try:
+            with open(cache_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except Exception:
+            # 缓存文件损坏，删除它
+            if os.path.exists(cache_path):
+                os.remove(cache_path)
+            return None
+    
+    def set(self, file_path: str, content: str) -> bool:
+        """
+        将文件内容存入缓存
+        
+        Args:
+            file_path: 文件路径
+            content: 文件内容
+            
+        Returns:
+            是否成功缓存
+        """
+        try:
+            cache_key = self._get_cache_key(file_path)
+            cache_path = self._get_cache_path(cache_key)
+            
+            with open(cache_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            return True
+        except Exception:
+            return False
+    
+    def clear(self):
+        """清空所有缓存"""
+        if os.path.exists(self.cache_dir):
+            for file in os.listdir(self.cache_dir):
+                if file.endswith('.cache'):
+                    os.remove(os.path.join(self.cache_dir, file))
+
+
+class RequestCache:
+    """请求缓存管理器"""
+    
+    def __init__(self, max_size: int = 100, max_age: int = 1800):
+        """
+        初始化请求缓存
+        
+        Args:
+            max_size: 最大缓存条目数
+            max_age: 缓存最大存活时间（秒）
+        """
+        self.max_size = max_size
+        self.max_age = max_age
+        self._cache: Dict[str, Dict[str, Any]] = {}
+    
+    def _get_cache_key(self, messages: list) -> str:
+        """生成请求缓存键"""
+        # 使用消息内容生成唯一键
+        key_data = str(messages)
+        return hashlib.md5(key_data.encode()).hexdigest()
+    
+    def _cleanup_expired(self):
+        """清理过期的缓存条目"""
+        current_time = time.time()
+        expired_keys = []
+        
+        for key, data in self._cache.items():
+            if current_time - data['timestamp'] > self.max_age:
+                expired_keys.append(key)
+        
+        for key in expired_keys:
+            del self._cache[key]
+    
+    def _cleanup_oldest(self):
+        """清理最旧的缓存条目"""
+        if len(self._cache) >= self.max_size:
+            # 找到最旧的条目
+            oldest_key = min(self._cache.keys(), 
+                           key=lambda k: self._cache[k]['timestamp'])
+            del self._cache[oldest_key]
+    
+    def get(self, messages: list) -> Optional[str]:
+        """
+        从缓存获取响应
+        
+        Args:
+            messages: 消息列表
+            
+        Returns:
+            缓存的响应或None
+        """
+        self._cleanup_expired()
+        
+        cache_key = self._get_cache_key(messages)
+        if cache_key in self._cache:
+            return self._cache[cache_key]['response']
+        return None
+    
+    def set(self, messages: list, response: str) -> bool:
+        """
+        将响应存入缓存
+        
+        Args:
+            messages: 消息列表
+            response: 响应内容
+            
+        Returns:
+            是否成功缓存
+        """
+        self._cleanup_expired()
+        self._cleanup_oldest()
+        
+        cache_key = self._get_cache_key(messages)
+        self._cache[cache_key] = {
+            'response': response,
+            'timestamp': time.time()
+        }
+        return True
+    
+    def clear(self):
+        """清空所有缓存"""
+        self._cache.clear()
+
+
+# 全局缓存实例
+file_cache = FileCache()
+request_cache = RequestCache()

config.py

@@ -0,0 +1,34 @@
+"""
+配置文件 - 集中管理应用配置
+"""
+import os
+
+# ==================== API 配置 ====================
+# DeepSeek V3 API 配置
+API_KEY = os.getenv("DEEPSEEK_API_KEY") or "tmBBchNoClGSrUmV"
+API_BASE_URL = os.getenv("DEEPSEEK_BASE_URL") or "http://env-cvcgvp6m1hkmaaarobeg-cn-wulanchabu.alicloudapi.com/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "DeepSeek-V3-0324"
+
+if not API_KEY:
+    print("⚠️  警告：未找到 DEEPSEEK_API_KEY 环境变量")
+    print("请设置环境变量：export DEEPSEEK_API_KEY='your-api-key'")
+
+# 模型参数配置
+MAX_TOKENS = 8192
+TEMPERATURE = 0.85
+TOP_P = 0.9
+
+# ==================== 文件处理配置 ====================
+# 上传GDL文本的本地合并上限（仅本地拼接、非服务端限制）
+MAX_FILE_CHARS = 200000
+SUPPORTED_FILE_TYPES = [".txt"]
+
+# ==================== 默认提示词 ====================
+SYSTEM_PROMPT = """你是一位资深的麻将与东亚棋牌玩法设计专家，熟悉各地番型体系、操作节奏与现代桌游融合设计手法。
+请根据用户需求，输出兼具创新性与可落地性的麻将玩法方案（包含番型结构、组件、流程与体验亮点）。"""
+
+# ==================== UI 配置 ====================
+APP_TITLE = "🀄️ 麻将玩法创意工坊"
+CHATBOT_HEIGHT = 640
+MIN_WIDTH_LEFT = 320
+MIN_WIDTH_RIGHT = 640

default_content.py

@@ -0,0 +1,101 @@
+"""
+默认内容模块 - 存储预加载的 GDL 规范和 System Prompt
+"""
+import os
+
+# 默认 GDL 规范文件路径
+DEFAULT_GDL_FILE = "麻将游戏mGDL通用语法.txt"
+
+# 默认 System Prompt 文件路径  
+DEFAULT_PROMPT_FILE = "prompt.txt"
+
+# 默认示例 GDL 文档路径
+DEFAULT_EXAMPLE_GDL_FILE = "幺鸡血战_mGDL.txt"
+
+
+def load_default_gdl():
+    """
+    加载默认的 GDL 规范内容
+    
+    Returns:
+        str: GDL 规范文本，如果文件不存在则返回空字符串
+    """
+    try:
+        gdl_path = os.path.join(os.path.dirname(__file__), DEFAULT_GDL_FILE)
+        if os.path.exists(gdl_path):
+            with open(gdl_path, "r", encoding="utf-8") as f:
+                return f.read()
+    except Exception as e:
+        print(f"⚠️ 加载默认 GDL 文件失败：{e}")
+    return ""
+
+
+def load_default_prompt():
+    """
+    加载默认的 System Prompt 内容
+    
+    Returns:
+        str: System Prompt 文本，如果文件不存在则返回空字符串
+    """
+    try:
+        prompt_path = os.path.join(os.path.dirname(__file__), DEFAULT_PROMPT_FILE)
+        if os.path.exists(prompt_path):
+            with open(prompt_path, "r", encoding="utf-8") as f:
+                return f.read()
+    except Exception as e:
+        print(f"⚠️ 加载默认 Prompt 文件失败：{e}")
+    return ""
+
+
+def load_default_example_gdl():
+    """
+    加载默认的示例 GDL 文档内容
+    
+    Returns:
+        str: 示例 GDL 文本，如果文件不存在则返回空字符串
+    """
+    try:
+        example_path = os.path.join(os.path.dirname(__file__), DEFAULT_EXAMPLE_GDL_FILE)
+        if os.path.exists(example_path):
+            with open(example_path, "r", encoding="utf-8") as f:
+                return f.read()
+    except Exception as e:
+        print(f"⚠️ 加载默认示例 GDL 文件失败：{e}")
+    return ""
+
+
+# 在模块加载时预加载内容（提高性能）
+DEFAULT_GDL_CONTENT = load_default_gdl()
+DEFAULT_PROMPT_CONTENT = load_default_prompt()
+DEFAULT_EXAMPLE_GDL_CONTENT = load_default_example_gdl()
+
+
+def get_default_gdl():
+    """
+    获取默认的 GDL 规范内容（使用预加载的内容）
+    
+    Returns:
+        str: GDL 规范文本
+    """
+    return DEFAULT_GDL_CONTENT
+
+
+def get_default_prompt():
+    """
+    获取默认的 System Prompt 内容（使用预加载的内容）
+    
+    Returns:
+        str: System Prompt 文本
+    """
+    return DEFAULT_PROMPT_CONTENT
+
+
+def get_default_example_gdl():
+    """
+    获取默认的示例 GDL 文档内容（使用预加载的内容）
+    
+    Returns:
+        str: 示例 GDL 文本
+    """
+    return DEFAULT_EXAMPLE_GDL_CONTENT
+

env_example.txt

@@ -0,0 +1,30 @@
+# DeepSeek V3 API 环境变量配置示例
+# 如果不设置这些环境变量，程序会使用 config.py 中的默认值
+
+# DeepSeek V3 API Key
+DEEPSEEK_API_KEY=tmBBchNoClGSrUmV
+
+# DeepSeek V3 API Base URL
+DEEPSEEK_BASE_URL=http://env-cvcgvp6m1hkmaaarobeg-cn-wulanchabu.alicloudapi.com/v1
+
+# 模型名称
+MODEL_NAME=DeepSeek-V3-0324
+
+# ===============================
+# 使用方法：
+# ===============================
+# 
+# 在 Linux/Mac 上：
+# export DEEPSEEK_API_KEY="your-api-key"
+# export DEEPSEEK_BASE_URL="your-base-url"
+# export MODEL_NAME="DeepSeek-V3-0324"
+#
+# 在 Windows 上：
+# set DEEPSEEK_API_KEY=your-api-key
+# set DEEPSEEK_BASE_URL=your-base-url
+# set MODEL_NAME=DeepSeek-V3-0324
+#
+# 或使用 .env 文件（需要安装 python-dotenv）：
+# 1. 将本文件重命名为 .env
+# 2. pip install python-dotenv
+# 3. 在代码中添加：from dotenv import load_dotenv; load_dotenv()

extract_gdl_optimized.py

@@ -0,0 +1,199 @@
+"""
+优化的 GDL 和自然语言提取函数
+可以直接复制到 app.py 中使用
+"""
+import re
+
+
+def extract_gdl_and_narrative(content):
+    """
+    提取 GDL 和自然语言部分（优化版 - 平衡功能与复杂度）
+    
+    支持的格式：
+    - ## GDL描述 / ## GDL 描述
+    - ##GDL描述 / GDL描述
+    - ## 自然语言规则说明 / ##自然语言规则说明
+    - 以及其他常见变体
+    
+    Args:
+        content: AI 生成的完整文本
+        
+    Returns:
+        tuple: (gdl_content, narrative_content)
+    """
+    
+    # ========== 定义标记模式（按优先级排序） ==========
+    gdl_patterns = [
+        r"##\s*GDL\s*描述",          # ## GDL描述 或 ## GDL 描述（推荐格式）
+        r"##\s*GDL描述",              # ##GDL描述
+        r"GDL\s*描述",                # GDL描述 或 GDL 描述
+        r"##\s*GDL\s*Description",    # ## GDL Description（英文）
+        r"##\s*GDL",                  # ## GDL（简化版）
+    ]
+    
+    narrative_patterns = [
+        r"##\s*自然语言规则说明",      # ## 自然语言规则说明（推荐格式）
+        r"##\s*自然语言规则",          # ## 自然语言规则
+        r"自然语言规则说明",            # 自然语言规则说明
+        r"自然语言规则",                # 自然语言规则
+        r"##\s*Natural\s*Language",   # ## Natural Language（英文）
+        r"规则说明",                    # 规则说明（简化版）
+    ]
+    
+    # ========== 查找标记位置 ==========
+    gdl_start = -1
+    gdl_marker = None
+    for pattern in gdl_patterns:
+        match = re.search(pattern, content, re.IGNORECASE)
+        if match:
+            gdl_start = match.start()
+            gdl_marker = match.group()
+            break
+    
+    narrative_start = -1
+    narrative_marker = None
+    for pattern in narrative_patterns:
+        match = re.search(pattern, content, re.IGNORECASE)
+        if match:
+            narrative_start = match.start()
+            narrative_marker = match.group()
+            break
+    
+    # ========== 处理提取结果 ==========
+    if gdl_start != -1 and narrative_start != -1:
+        # 正常情况：两个标记都找到
+        
+        # 检查顺序（GDL 应该在自然语言之前）
+        if gdl_start >= narrative_start:
+            print(f"⚠️ 警告: 标记顺序异常，已自动纠正")
+            gdl_start, narrative_start = narrative_start, gdl_start
+        
+        # 提取内容
+        gdl_content = content[gdl_start:narrative_start].strip()
+        narrative_content = content[narrative_start:].strip()
+        
+        # 验证长度
+        if len(gdl_content) < 20 or len(narrative_content) < 20:
+            print(f"⚠️ 警告: 提取内容过短 (GDL:{len(gdl_content)}, 自然语言:{len(narrative_content)})")
+        
+        print(f"✅ 提取成功: GDL({len(gdl_content)}字符), 自然语言({len(narrative_content)}字符)")
+        return gdl_content, narrative_content
+    
+    elif gdl_start != -1:
+        # 只找到 GDL 标记
+        print(f"⚠️ 仅找到GDL标记 '{gdl_marker}'，将其后全部内容作为GDL")
+        gdl_content = content[gdl_start:].strip()
+        return gdl_content, ""
+    
+    elif narrative_start != -1:
+        # 只找到自然语言标记
+        print(f"⚠️ 仅找到自然语言标记 '{narrative_marker}'，将其后全部内容作为自然语言")
+        narrative_content = content[narrative_start:].strip()
+        return "", narrative_content
+    
+    else:
+        # 都没找到：尝试智能分割
+        print(f"❌ 未找到任何标记，尝试智能分割...")
+        return smart_split_content(content)
+
+
+def smart_split_content(content):
+    """
+    智能分割内容（后备方案）
+    
+    策略：通过识别 GDL 代码特征（如 (game "..." ）来分割
+    """
+    # 查找 GDL 代码块的起始标志
+    gdl_code_pattern = r'\(game\s+"[^"]+?"'
+    match = re.search(gdl_code_pattern, content)
+    
+    if match:
+        gdl_start = match.start()
+        
+        # 简单的括号匹配查找结束位置
+        count = 0
+        gdl_end = -1
+        for i in range(gdl_start, len(content)):
+            if content[i] == '(':
+                count += 1
+            elif content[i] == ')':
+                count -= 1
+                if count == 0:
+                    gdl_end = i
+                    break
+        
+        if gdl_end != -1:
+            gdl_content = content[gdl_start:gdl_end + 1].strip()
+            narrative_content = content[gdl_end + 1:].strip()
+            print(f"🔍 智能分割成功: 识别到GDL代码块")
+            return gdl_content, narrative_content
+    
+    print(f"❌ 智能分割失败")
+    return "", ""
+
+
+# ========== 测试代码 ==========
+if __name__ == "__main__":
+    # 测试用例
+    test_cases = [
+        # 测试 1: 标准格式
+        """
+## 游戏名称
+测试游戏
+
+## GDL描述
+(game "TestGame"
+  (players 3)
+)
+
+## 自然语言规则说明
+1. 这是规则
+""",
+        # 测试 2: 无空格格式
+        """
+##GDL描述
+(game "TestGame"
+  (players 3)
+)
+
+##自然语言规则说明
+1. 这是规则
+""",
+        # 测试 3: 带空格格式
+        """
+## GDL 描述
+(game "TestGame"
+  (players 3)
+)
+
+## 自然语言规则说明
+1. 这是规则
+""",
+        # 测试 4: 无标记（智能分割）
+        """
+(game "TestGame"
+  (players 3)
+)
+
+这是自然语言规则说明
+""",
+    ]
+    
+    print("=" * 60)
+    print("测试 GDL 提取功能")
+    print("=" * 60)
+    
+    for i, test_content in enumerate(test_cases, 1):
+        print(f"\n测试用例 {i}:")
+        print("-" * 60)
+        gdl, narrative = extract_gdl_and_narrative(test_content)
+        
+        if gdl or narrative:
+            print(f"GDL 长度: {len(gdl)}")
+            print(f"自然语言长度: {len(narrative)}")
+        else:
+            print("提取失败")
+    
+    print("\n" + "=" * 60)
+
+

file_handler.py

@@ -0,0 +1,109 @@
+"""
+文件处理模块 - 处理文件上传和读取
+"""
+import os
+from config import MAX_FILE_CHARS, SUPPORTED_FILE_TYPES
+from cache_manager import file_cache
+
+
+def load_gdl_text(uploaded_files, max_chars=MAX_FILE_CHARS):
+    """
+    读取上传的 GDL 文本文件
+    
+    Args:
+        uploaded_files: 上传的文件列表
+        max_chars: 最大字符数限制
+        
+    Returns:
+        str: 合并后的文本内容
+    """
+    if not uploaded_files:
+        return ""
+    
+    files = uploaded_files if isinstance(uploaded_files, (list, tuple)) else [uploaded_files]
+    parts = []
+    total_size = 0
+    
+    for f in files:
+        try:
+            path = getattr(f, "name", None) or str(f)
+            
+            # 检查文件是否存在
+            if not os.path.exists(path):
+                parts.append(f"\n# FILE_NOT_FOUND: {os.path.basename(path)}\n")
+                continue
+                
+            # 检查文件扩展名
+            file_ext = os.path.splitext(path)[1].lower()
+            if file_ext not in SUPPORTED_FILE_TYPES:
+                parts.append(f"\n# UNSUPPORTED_FILE_TYPE: {os.path.basename(path)} (expected: {', '.join(SUPPORTED_FILE_TYPES)})\n")
+                continue
+                
+            # 检查文件大小
+            file_size = os.path.getsize(path)
+            if file_size > max_chars:
+                parts.append(f"\n# FILE_TOO_LARGE: {os.path.basename(path)} ({file_size} bytes, skipped)\n")
+                continue
+                
+            # 尝试从缓存获取
+            txt = file_cache.get(path)
+            if txt is None:
+                # 缓存未命中，读取文件
+                with open(path, "r", encoding="utf-8", errors="ignore") as fh:
+                    txt = fh.read()
+                # 存入缓存
+                file_cache.set(path, txt)
+                
+            # 检查内容长度
+            if len(txt) + total_size > max_chars:
+                remaining = max_chars - total_size
+                if remaining > 100:  # 至少保留100字符
+                    txt = txt[:remaining] + "\n[...TRUNCATED...]"
+                else:
+                    parts.append(f"\n# FILE_SKIPPED: {os.path.basename(path)} (would exceed limit)\n")
+                    continue
+                    
+            parts.append(f"\n# FILE: {os.path.basename(path)}\n{txt}\n")
+            total_size += len(txt)
+            
+        except PermissionError:
+            parts.append(f"\n# FILE_PERMISSION_ERROR: {os.path.basename(path)} (access denied)\n")
+        except UnicodeDecodeError as e:
+            parts.append(f"\n# FILE_ENCODING_ERROR: {os.path.basename(path)} ({str(e)})\n")
+        except Exception as e:
+            parts.append(f"\n# FILE_READ_ERROR: {os.path.basename(path)} ({type(e).__name__}: {str(e)})\n")
+    
+    text = "\n".join(parts).strip()
+    return text
+
+
+def validate_file_upload(files):
+    """
+    验证文件上传的有效性
+    
+    Args:
+        files: 上传的文件列表
+        
+    Returns:
+        tuple: (is_valid, error_message)
+    """
+    if not files:
+        return True, ""
+    
+    file_list = files if isinstance(files, (list, tuple)) else [files]
+    
+    for f in file_list:
+        path = getattr(f, "name", None) or str(f)
+        
+        if not os.path.exists(path):
+            return False, f"文件不存在: {os.path.basename(path)}"
+            
+        file_ext = os.path.splitext(path)[1].lower()
+        if file_ext not in SUPPORTED_FILE_TYPES:
+            return False, f"不支持的文件类型: {os.path.basename(path)} (支持: {', '.join(SUPPORTED_FILE_TYPES)})"
+            
+        file_size = os.path.getsize(path)
+        if file_size > MAX_FILE_CHARS:
+            return False, f"文件过大: {os.path.basename(path)} ({file_size} bytes, 最大: {MAX_FILE_CHARS})"
+    
+    return True, ""

prompt.txt

@@ -0,0 +1,192 @@
+## System Prompt
+你是一位麻将游戏设计专家，精通传统麻将、血战麻将、血流麻将等玩法的规则设计。  
+你现在的任务是：**在给定 mGDL 通用语法约束下，生成一个新的麻将玩法，并确保所有规则清晰、可编程、无歧义。**
+
+你的输出必须包含：
+
+1. **游戏名称与理念**
+2. **符合 mGDL 语法的完整 GDL 描述（含中文注释）**
+3. **番型与倍数规则的说明（自然语言）**
+4. **特殊机制规则（如幺鸡、红中等）的说明**
+5. **游戏阶段与玩家操作规则的说明**
+6. **平衡性分析**
+7. **规则自检清单（你自己对上面 1–6 的检查）**
+
+---
+
+### 上下文说明（已给定的参考文件）
+
+1. **现有的三种麻将玩法 mGDL 文档**：
+   - 幺鸡血战_mGDL.txt
+   - 疯狂血战_mGDL.txt
+   - 疯狂血流_mGDL.txt
+   这些文档已经定义了三种玩法的核心规则、番型、倍数以及特殊机制（如幺鸡赖子、红中赖子）。
+
+2. **mGDL 通用语法**：
+   - 《麻将游戏mGDL通用语法.txt》给出了统一的骨架：
+     - 顶层结构：`(game ...)`
+     - Rule-Core：players / tileset / seats / turn_order / actions / phases / setup / win_rules / scoring / fan_table / settlement
+     - Rule-Addons：wildcard / kong_rules
+     - Policy Packs：policy_ref
+   - 你必须 **遵循这套语法** 来生成规则。  
+   - 你只能使用通用语法和三种示例中已经出现过的字段与结构，不得虚构新的结构（例如：**禁止使用 `zone`、`path`、`board` 等本项目没有定义的字段**）。
+
+---
+
+### 规则严谨性与可编程性要求（非常重要）
+
+在设计新玩法和编写 mGDL 时，必须遵守以下原则：
+
+1. **所有关键规则必须在 mGDL 中显式写出**
+   - 包括但不限于：
+     - 是否允许：吃（allow_chi）、碰（allow_peng）、各种杠（allow_gang）、点炮胡（allow_discard_win）、抢杠胡（allow_rob_kong）、一炮多响（allow_multi_win）。
+     - 胡后是否继续、已胡玩家是否退出、何时结束牌局：通过 `post_win_continuation` 显式描述，例如：
+       - 血战类：`(mode "xuezhan") (winner_exit true) (end_when_third_player_wins true)`
+       - 血流类：`(mode "xueliu") (winner_exit false) (keep_turn_order true) (after_gun_next_draw "shooter_next")`
+   - 不允许只在自然语言里说“类似疯狂血战/血流”，必须在 mGDL 里完整展开。
+
+2. **计分体系必须一致、选一并说清楚**
+   你可以从以下三种计分风格中**任选一种**，也可以在其基础上小幅修改，但必须在 mGDL 中清晰表达，并在自然语言说明中写明“本玩法采用 X 风格”：
+   - 倍数制：
+     - 典型结构：`(base_point 1) (self_draw_multiplier 2) (discard_win_multiplier 1) (start_multiplier 8) (cap_multiplier 128) (fan_table (yaku ... (mult ...)))`
+   - 番制 + 番映射倍数（类似疯狂血战）：
+     - 典型结构：`(scoring (fan_system (base 10)) (fan_cap_by_room {...}) ...) (fan_table (yaku ... (fan n multiplier)))`
+   - 血流大倍数制（类似疯狂血流）：
+     - 典型结构：`(scoring (base_point 1) (self_draw_multiplier 10) (discard_win_multiplier 1) ...) (fan_table (yaku ... (mult ...)))`
+
+   不允许出现含糊描述，例如“起胡倍数稍高”“封顶较高一些”“倍数可由运营调整”，必须写出具体数字。
+
+3. **禁止模糊或不可编程的表达**
+   在 mGDL 和自然语言规则说明中都禁止使用以下模糊表达：
+   - “一般情况下…”
+   - “通常…”
+   - “视情况而定…”
+   - “可以考虑…”
+   - “可由运营调整…”
+   - “略有调整即可…”
+   - “与 XX 类似，未说明处同 XX 玩法”
+   你必须把逻辑展开成 **明确条件和结果**，例如：
+   - 错误：`起胡倍数略高于幺鸡血战`
+   - 正确：`起胡倍数=16，封顶倍数=256`
+
+4. **自然语言规则必须与 mGDL 严格对齐**
+   - 不允许文案和代码出现冲突，比如文案里说“不允许抢杠胡”，mGDL 写 `(allow_rob_kong true)`。
+   - 你在写完 mGDL 后，生成自然语言说明时要显式对照 mGDL 中的字段来逐项解释。
+
+5. **不要留下空洞或未定义的情况**
+   - 每一个阶段（定缺、换三张、行牌、结算），都要说明：
+     - 触发条件；
+     - 玩家可选动作；
+     - 阶段结束条件。
+   - 若不启用某个阶段（例如不换三张），要显式写：
+     - mGDL：`(exchange_three (enabled false))`
+     - 文案：说明“本玩法不启用换三张”。
+
+---
+
+### 核心设计要求（你需要在此基础上做出新玩法）
+
+根据以下信息，生成一个新的麻将玩法。  
+**每一个设计点都必须在 mGDL 中有对应字段，在自然语言说明中有清晰解释。**
+
+1. **玩法名称与理念**
+   - 给出一个新玩法的名称。
+   - 简要描述新玩法的核心理念和创新点（例如：更快节���、更高风险、更强调赖子等）。
+
+2. **玩法类型**
+   - 在以下三种中选择其一，并在 mGDL 中通过 `(game_variant ...)` 明确声明：
+     - `"blood_war"`：血战类，推荐使用类似幺鸡血战 / 疯狂血战的 `post_win_continuation` 模板：
+       - 已胡玩家退出本局（winner_exit true）
+       - 至第 3 家胡牌或牌摸完结束（end_when_third_player_wins true）
+     - `"blood_flow"`：血流类，推荐使用类似疯狂血流的模板：
+       - winner_exit false
+       - 胡不改顺 / 点炮者下家摸牌（keep_turn_order true, after_gun_next_draw "shooter_next"）
+     - `"<custom_variant>"`：自定义类型，但仍需在 `win_rules` 里完整定义胡后继续逻辑和结束条件。
+   - 自然语言中要解释清楚：“本玩法为 XX 类，胡牌后是否退出/是否可多次胡/何时结束”。
+
+3. **特殊机制**
+   针对幺鸡/红中等，必须在以下两层都写清楚：
+   - `special_mechanics` 或 `wildcard` 段落内的 mGDL 配置；
+   - 文案中解释：
+     - 是否启用幺鸡赖子；
+     - 是否启用红中赖子；
+     - 赖子是否可打出、是否算杠、是否可以单吊胡；
+     - 补杠时如何处理赖子（例如“摸到相同牌可将赖子换回手中”）。
+
+4. **番型与倍数规则**
+   - 设计番型时，建议在以下几类中选择组合：
+     - 基础番型：平胡、碰碰胡、七对、清一色、金钩钓、龙七对、清碰等；
+     - 血流大牌型：大威天龙、万中无双、十八罗汉、绿一色、大车轮、十二金钗等；
+     - 与赖子相关的特殊番型：赖子胡、红中杠、无鸡胡、三鸡/四鸡等。
+   - 对每个番型，你必须在 `fan_table` 中给出：
+     - 唯一名称（yaku name）；
+     - 番数或倍数（fan / mult）；
+     - 简短 desc（中文描述）。
+   - 必须指出番型是否叠加，以及封顶规则：
+     - 番制：设置 `fan_cap_by_room`；
+     - 倍数制：设置 `cap_multiplier` 或通过特殊 yaku 的 `force_cap true` 表示封顶。
+
+5. **游戏阶段与玩家操作**
+   - 至少包含以下阶段中的一部分：
+     - `choose_que`（定缺）；
+     - `exchange_three`（换三张）；
+     - `play`（行牌）；
+     - `settle`（结算）。
+   - 需要在 mGDL 的 `phases` 和 `setup` 中显式描述，并在文案中说明每个阶段：
+     - 何时开始；
+     - 玩家有哪些合法动作；
+     - 阶段如何结束。
+   - 如果某些阶段不启用（例如血流类一般不换三张），要显式 `(enabled false)` 并在文案中写明“不启用某阶段”。
+
+6. **平衡性要求**
+   - 通过以下方式论证玩法不会过于偏向某一类手牌或某一种打发：
+     - 起胡倍数 / 封顶倍数的选取；
+     - 大牌番型的出现概率 vs 倍数收益；
+     - 赖子数量：例如只用幺鸡、不加红中，或红中数量=6/8；
+     - 血战 vs 血流的节奏差异。
+   - 可以用区间描述，如“普通番型（1–4 倍）占多数，大牌型（100 倍以上）出现频率较低，适合作为高风险高收益”。
+
+---
+
+### 输出要求
+
+你的回答必须按以下结构组织：
+
+1. **玩法名称与理念**
+   - 1–3 段自然语言描述。
+
+2. **mGDL 规则代码**
+   - 使用代码块（```）包裹完整的 `(game "...")` 定义。
+   - 必须仅使用通用语法和三种示例中已有的字段和结构，不要引入新概念字段。
+   - 每个关键段落（tileset / actions / setup / win_rules / scoring / fan_table / settlement / wildcard 等）添加简短中文注释，说明其作用。
+
+3. **自然语言规则说明**
+   - 以玩家视角，按阶段拆解：
+     - 准备阶段（定缺、换三张、起手牌数等）；
+     - 对战阶段（行牌顺序、吃/碰/杠/胡的条件）；
+     - 结算阶段（胡牌、自摸/点炮结算、查花猪/查大叫等）。
+   - “番型与倍数”用表格或分条列出，并说明是否叠加、封顶方式。
+   - 明确说明：
+     - 胡后是否继续 / 已胡玩家是否退出；
+     - 每局何时结束；
+     - 自摸与点炮的倍率区别；
+     - 特殊机制（幺鸡/红中）在计分上的影响。
+
+4. **平衡性分析**
+   - 简要从以下角度分析：
+     - 典型一局的得分范围；
+     - 赖子/大牌型对节奏的影响；
+     - 是否鼓励积极进攻或稳健防守；
+     - 与现有三种玩法相比的差异和可能的优势/风险。
+
+5. **规则自检清单**
+   - 列出一个清单，并针对每一项用“是/否”自查，格式示例：
+     - [ ] 已显式设置 `allow_chi/allow_peng/allow_gang/allow_discard_win/allow_rob_kong/allow_multi_win`（mGDL 中有具体 true/false）。
+     - [ ] 已在 `post_win_continuation` 中明确胡后继续规则（血战/血流或自定义）。
+     - [ ] 已在 scoring 中选择并说明一种计分体系，包含自摸/点炮倍率、起胡和封顶。
+     - [ ] 所有番型在 `fan_table` 中都有��确的 fan/mult 数值，且文案中有对应说明。
+     - [ ] 特殊赖子（幺鸡/红中）在 mGDL 中有配置，在文案中有解释，并与计分规则一致。
+     - [ ] 未使用“视情况”“略有调整”“类似 XX 玩法”这类模糊表达。
+     - [ ] 文案描述与 mGDL 中的布尔/枚举/数值不冲突。
+
+请严格遵守以上约束，确保生成的 mGDL 规则在形式上合法、在含义上清晰、在自然语言说明中可被玩家无歧义理解。

requirements.txt

@@ -0,0 +1,2 @@
+gradio==4.44.1
+openai>=1.0.0

security.py

@@ -0,0 +1,249 @@
+"""
+安全模块 - 提供输入验证和安全检查功能
+"""
+import os
+import re
+from typing import List, Tuple, Optional
+
+
+class SecurityValidator:
+    """安全验证器"""
+    
+    # 危险文件扩展名
+    DANGEROUS_EXTENSIONS = {
+        '.exe', '.bat', '.cmd', '.com', '.pif', '.scr', '.vbs', '.js', '.jar',
+        '.php', '.asp', '.aspx', '.jsp', '.py', '.pl', '.sh', '.ps1'
+    }
+    
+    # 最大文件大小（字节）
+    MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+    
+    # 最大文件名长度
+    MAX_FILENAME_LENGTH = 255
+    
+    # 危险关键词模式
+    DANGEROUS_PATTERNS = [
+        r'<script[^>]*>.*?</script>',
+        r'javascript:',
+        r'data:text/html',
+        r'vbscript:',
+        r'onload\s*=',
+        r'onerror\s*=',
+        r'eval\s*\(',
+        r'exec\s*\(',
+        r'system\s*\(',
+    ]
+    
+    @staticmethod
+    def _is_cjk(char: str) -> bool:
+        """
+        判断字符是否为常见东亚字符（中文、日文、韩文、全角符号等）
+        """
+        return re.match(r"[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\uff00-\uffef\u3040-\u30ff\uac00-\ud7af]", char) is not None
+    
+    @classmethod
+    def validate_file_upload(cls, file_path: str) -> Tuple[bool, str]:
+        """
+        验证文件上传的安全性
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        try:
+            # 检查文件是否存在
+            if not os.path.exists(file_path):
+                return False, "文件不存在"
+            
+            # 检查文件大小
+            file_size = os.path.getsize(file_path)
+            if file_size > cls.MAX_FILE_SIZE:
+                return False, f"文件过大 ({file_size} bytes, 最大: {cls.MAX_FILE_SIZE})"
+            
+            # 检查文件名
+            filename = os.path.basename(file_path)
+            if len(filename) > cls.MAX_FILENAME_LENGTH:
+                return False, f"文件名过长 ({len(filename)} 字符, 最大: {cls.MAX_FILENAME_LENGTH})"
+            
+            # 检查文件扩展名
+            _, ext = os.path.splitext(filename.lower())
+            if ext in cls.DANGEROUS_EXTENSIONS:
+                return False, f"不支持的文件类型: {ext}"
+            
+            # 检查文件名中的危险字符
+            if not cls._is_safe_filename(filename):
+                return False, "文件名包含危险字符"
+            
+            return True, ""
+            
+        except Exception as e:
+            return False, f"文件验证失败: {str(e)}"
+    
+    @classmethod
+    def validate_text_input(cls, text: str, max_length: int = 10000) -> Tuple[bool, str]:
+        """
+        验证文本输入的安全性
+        
+        Args:
+            text: 输入文本
+            max_length: 最大长度
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        if not text:
+            return True, ""
+        
+        # 检查长度
+        if len(text) > max_length:
+            return False, f"输入过长 ({len(text)} 字符, 最大: {max_length})"
+        
+        # 检查危险模式
+        for pattern in cls.DANGEROUS_PATTERNS:
+            if re.search(pattern, text, re.IGNORECASE | re.DOTALL):
+                return False, "输入包含潜在危险内容"
+        
+        # 检查非常规字符比例（放宽中文/日文/韩文及常见标点）
+        def _is_safe_char(c: str) -> bool:
+            if not c:
+                return True
+            # 字母数字与空白
+            if c.isalnum() or c.isspace():
+                return True
+            # 常见中英文标点
+            if re.match(r"[\.,;:!\?\-_'\"(){}\[\]\\/@#%&\+=<>~\^\|$，。；：！？、（）【】《》—…·]", c):
+                return True
+            # CJK 字符与全角符号
+            if SecurityValidator._is_cjk(c):
+                return True
+            return False
+
+        total_len = len(text)
+        if total_len > 0:
+            unsafe_count = sum(1 for ch in text if not _is_safe_char(ch))
+            # 只有当非常规字符比例很高时才判为风险（阈值 0.5）
+            if unsafe_count / total_len > 0.5:
+                return False, "输入包含大量非常规字符"
+        
+        return True, ""
+    
+    @classmethod
+    def sanitize_filename(cls, filename: str) -> str:
+        """
+        清理文件名，移除危险字符
+        
+        Args:
+            filename: 原始文件名
+            
+        Returns:
+            清理后的文件名
+        """
+        # 移除路径分隔符和危险字符
+        dangerous_chars = r'[<>:"/\\|?*\x00-\x1f]'
+        sanitized = re.sub(dangerous_chars, '_', filename)
+        
+        # 限制长度
+        if len(sanitized) > cls.MAX_FILENAME_LENGTH:
+            name, ext = os.path.splitext(sanitized)
+            max_name_length = cls.MAX_FILENAME_LENGTH - len(ext)
+            sanitized = name[:max_name_length] + ext
+        
+        return sanitized
+    
+    @classmethod
+    def _is_safe_filename(cls, filename: str) -> bool:
+        """
+        检查文件名是否安全
+        
+        Args:
+            filename: 文件名
+            
+        Returns:
+            是否安全
+        """
+        # 检查危险字符
+        dangerous_chars = r'[<>:"/\\|?*\x00-\x1f]'
+        if re.search(dangerous_chars, filename):
+            return False
+        
+        # 检查保留名称（Windows）
+        reserved_names = {
+            'CON', 'PRN', 'AUX', 'NUL',
+            'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+            'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'
+        }
+        
+        name_without_ext = os.path.splitext(filename)[0].upper()
+        if name_without_ext in reserved_names:
+            return False
+        
+        return True
+
+
+class InputValidator:
+    """输入验证器"""
+    
+    @staticmethod
+    def validate_message(message: str) -> Tuple[bool, str]:
+        """
+        验证用户消息
+        
+        Args:
+            message: 用户消息
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        if not message or not message.strip():
+            return False, "消息不能为空"
+        
+        # 放宽消息长度上限（本地校验）
+        return SecurityValidator.validate_text_input(message, max_length=200000)
+    
+    @staticmethod
+    def validate_custom_prompt(prompt: str) -> Tuple[bool, str]:
+        """
+        验证自定义提示词
+        
+        Args:
+            prompt: 自定义提示词
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        if not prompt:
+            return True, ""
+        
+        # 放宽自定义提示词长度上限（本地校验）
+        return SecurityValidator.validate_text_input(prompt, max_length=200000)
+    
+    @staticmethod
+    def validate_file_list(files: List) -> Tuple[bool, str]:
+        """
+        验证文件列表
+        
+        Args:
+            files: 文件列表
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        if not files:
+            return True, ""
+        
+        file_list = files if isinstance(files, (list, tuple)) else [files]
+        
+        for file_obj in file_list:
+            file_path = getattr(file_obj, "name", None) or str(file_obj)
+            is_valid, error_msg = SecurityValidator.validate_file_upload(file_path)
+            if not is_valid:
+                return False, error_msg
+        
+        return True, ""
+
+
+# 全局验证器实例
+security_validator = SecurityValidator()
+input_validator = InputValidator()

styles.py

@@ -0,0 +1,232 @@
+"""
+样式文件 - 集中管理 CSS 样式 (强制深色主题)
+"""
+
+MAHJONG_THEME_CSS = """
+html, body{ background-color:#0b1220 !important; color-scheme: dark !important; }
+/* ===== 仅添加强制深色主题的关键代码 ===== */
+:root {
+  color-scheme: dark !important;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color-scheme: dark !important;
+  }
+}
+
+/* 修复HuggingFace可能添加的滤镜效果 */
+.gradio-container {
+  filter: none !important;
+  -webkit-filter: none !important;
+}
+
+/* ===== Mahjong 主题配色 ===== */
+:root{
+  --felt:#0f5132;          /* 青 jade */
+  --felt-2:#09301d;
+  --felt-light:#1c7d4f;
+  --wood:#5e4430;         
+  --wood-2:#3f2f21;
+  --paper:#f8f3e7;
+  --ink:#f3f4f6;          
+  --muted:#cbd5e1;
+  --accent: #ffcc4d;
+
+  /* HERO 渐变（青→竹→朱） */
+  --hero-left:#041b16;
+  --hero-mid:#0c6244;
+  --hero-right:#b7452f;
+}
+
+body, .gradio-container{
+background: radial-gradient(1200px 800px at 15% -20%, #143828 0%, #0a1f18 45%, #050c0a 100%) !important;
+}
+
+/* 顶部 HERO：左深右浅的线性渐变，白字清晰 */
+.hero{
+position:relative;
+background: linear-gradient(90deg, var(--hero-left) 0%, var(--hero-mid) 48%, var(--hero-right) 100%);
+color:#fff;                       /* 固定白字 */
+text-shadow: 0 2px 6px rgba(0,0,0,.35);
+border-radius:20px;
+padding:18px 16px;
+box-shadow: 0 10px 28px rgba(0,0,0,.25), inset 0 -3px 0 rgba(255,255,255,.25);
+margin-bottom: 10px;
+}
+
+/* Hero 右上角麻将牌组 */
+.hero-icons{
+position:absolute;
+top:12px;
+right:18px;
+display:flex;
+gap:8px;
+}
+.hero-icons .hero-photo{
+  width:40px;
+  height:50px;
+  border-radius:8px;
+  background: linear-gradient(180deg, #fdf9f0 0%, #efe4cf 55%, #d9c4a3 100%);
+  box-shadow: 0 4px 0 rgba(0,0,0,.35), inset 0 0 0 1px rgba(255,255,255,.8);
+  border:1px solid rgba(0,0,0,.28);
+  background-color:#fdf9f0;
+  background-size:cover;
+  background-position:center;
+  background-repeat:no-repeat;
+}
+/* 左侧设置卡片（半透明） */
+.side-card{
+  background: rgba(255,255,255,.06);
+  border: 1px solid rgba(255,255,255,.12);
+  border-radius:16px; padding:14px;
+  box-shadow: 0 4px 14px rgba(0,0,0,.18);
+  backdrop-filter: blur(3px);
+  color:var(--ink);
+}
+.side-card h3{ margin:0 0 8px 0; }
+
+/* 麻将桌容器：木框 + 翡翠台呢 + 竹纹 */
+.table{
+  position:relative;
+  background:
+    radial-gradient(900px 600px at 35% 10%, rgba(255,255,255,.08) 0%, transparent 60%),
+    radial-gradient(1200px 800px at 35% 10%, var(--felt) 0%, var(--felt-2) 60%, #041912 100%);
+  border-radius:22px;
+  border: 12px solid transparent;
+  background-clip: padding-box;
+  box-shadow:
+    inset 0 0 50px rgba(0,0,0,.35),
+    0 20px 60px rgba(0,0,0,.35);
+}
+.table:before{ /* 木质外框 */
+  content:"";
+  position:absolute; inset:-14px;
+  border-radius:28px;
+  background: linear-gradient(90deg, var(--wood), var(--wood-2));
+  z-index:-1;
+  box-shadow: 0 8px 28px rgba(0,0,0,.45), inset 0 0 8px rgba(255,255,255,.1);
+}
+.table:after{ /* 低透竹纹 */
+  content:"";
+  position:absolute; inset:0;
+  background-image: linear-gradient(120deg, rgba(255,255,255,.05) 15%, transparent 30%),
+                    linear-gradient(300deg, rgba(0,0,0,.12) 20%, transparent 40%);
+  background-size: 140px 140px;
+  pointer-events:none;
+}
+
+/* 聊天组件细节：头像更小、气泡更易读 */
+.custom-chatbot .message{ font-size:16px; line-height:1.6; color:var(--ink); word-break:break-word; }
+.custom-chatbot .message.user{ background: rgba(255,255,255,.08) !important; }
+.custom-chatbot .message.bot{  background: rgba(0,0,0,.20) !important; }
+
+/* 按钮：麻将牌风格 */
+.gradio-container button.gr-button{
+  border:2px solid rgba(255,255,255,.35);
+  color:#193c2a;
+  font-weight:700;
+  letter-spacing:.3px;
+  background: linear-gradient(180deg, var(--paper) 0%, #efe6d2 60%, #dccdb0 100%);
+  border-radius:18px;
+  box-shadow: 0 6px 0 rgba(0,0,0,.35), inset 0 0 0 2px rgba(255,255,255,.6);
+  padding:10px 20px;
+  transition: transform .08s ease, box-shadow .08s ease;
+}
+.gradio-container button.gr-button:hover{ transform: translateY(-1px); }
+.gradio-container button.gr-button:active{
+  transform: translateY(2px);
+  box-shadow: 0 3px 0 rgba(0,0,0,.45), inset 0 0 0 2px rgba(255,255,255,.6);
+}
+
+/* 输入框在桌面里更融洽 */
+.table .gr-textbox textarea{
+  background: rgba(0,0,0,.20) !important; color:#e5e7eb !important;
+  border-radius:12px !important;
+  border:1px solid rgba(255,255,255,.18) !important;
+}
+
+/* 小提示文字颜色 */
+.hint{ color:var(--muted); font-size:12px; }
+
+@media (max-width: 820px){
+  .custom-chatbot .avatar,
+  .custom-chatbot .message .avatar{
+    width: 62px !important;
+    height: 62px !important;
+  }
+  .custom-chatbot .avatar-image{ width:58px !important; height:58px !important; }
+}
+/* === 修复 ChatInterface 内嵌发送/停止按钮在深色主题下不可见的问题 === */
+:where(.gradio-container) button[aria-label="submit"],
+:where(.gradio-container) button[aria-label="stop"]{
+  display: inline-flex !important;
+  align-items: center;
+  justify-content: center;
+  opacity: 1 !important;
+  visibility: visible !important;
+  pointer-events: auto !important;
+  border: 1px solid rgba(255,255,255,.22) !important;
+  background: rgba(255,255,255,.09) !important;
+  color: #fff !important;
+  border-radius: 10px !important;
+  height: 36px !important;
+  width: 36px !important;
+  cursor: pointer !important;
+}
+
+/* 保证输入框容器能正确容纳右侧内嵌按钮 */
+:where(.gradio-container) .gr-chat-interface .gr-textbox{
+  position: relative;
+}
+:where(.gradio-container) .gr-chat-interface .gr-textbox textarea{
+  padding-right: 48px !important;
+}
+
+/* === Chatbot 头像尺寸 & 对齐（稳定版）=== */
+/* 放大 Chatbot 头像（统一设置） */
+.custom-chatbot .avatar,
+.custom-chatbot .message .avatar{
+  width: 88px !important;
+  height: 88px !important;
+  min-width: 88px !important;
+  min-height: 88px !important;
+  border-radius: 9999px !important;
+  overflow: hidden !important;
+  border: 2px solid #ffffffcc !important;
+  box-shadow: 0 2px 6px rgba(0,0,0,.25) !important;
+  flex-shrink: 0 !important;
+  align-self: flex-start !important;
+}
+
+/* 控制头像尺寸（命中 gradio v4/5 的 DOM 结构） */
+.custom-chatbot .avatar-image {
+  width: 82px !important;
+  height: 82px !important;
+  border-radius: 50% !important; /* 保持圆形 */
+  object-fit: cover !important;
+}
+
+/* 可选：调整气泡和头像的间距 */
+.custom-chatbot .message {
+  gap: 12px !important; /* 改成更大/更小 */
+}
+
+
+
+/* 头像图片填充容器，不变形 */
+.custom-chatbot .avatar > img,
+.custom-chatbot .avatar-image{
+  width: 100% !important;
+  height: 100% !important;
+  object-fit: cover !important;
+  object-position: 50% 50% !important;
+  display: block !important;
+  border: 0 !important;
+  background: transparent !important;
+}
+
+/* 头像与气泡的间距与对齐（可选） */
+.custom-chatbot .message{ gap: 12px !important; align-items: flex-start !important; }
+.custom-chatbot .message .message-content{ margin-top: 2px !important; }
+"""