ZBLOG

别再死背 Prompt 框架了！教你设定 Gemini “专家大脑”，一次搞定 80% 的职场难题

Fri, 02 Jan 2026 14:28:04 +0800

你有沒有遇過這種情況？在網路上存了一堆提示詞（Prompt）模板，覺得自己學會了，但真的要開口問 AI 時，腦袋卻比電腦螢幕還白。最後問出的問題丟三落四，AI 給你的回覆也生硬得像機器人，還得花時間自己動手修。

這不是你的錯，是因為你還沒幫你的 Gemini 安裝「自動優化」的功能。

為什麼 AI 總是聽不懂人話？

其實 AI 就像一個讀過全世界圖書館、卻有點容易分心的天才。如果你問得很模糊，他的注意力會分散在幾千億個可能的答案裡。

要讓他變聰明，核心技巧就在於「引導 (Priming)」。簡單來說，就是在他開口前，先幫他縮小思考範圍，把算力集中在你需要的專業領域。

但我知道你懶得每次都輸入落落長的設定，所以我們要利用 Gemini 內建的「個人化建議」，設定一次，終身受用。

只要三分鐘，把 AI 變特助的四個步驟

不需要任何程式背景，只要跟著這幾步操作：

開啟設定：進到 Gemini 介面，點一下那個像齒輪的設定圖示。

找到「個人化建議」：這就是我們要幫他「植入大腦」的地方。(免費版會出現「給Gemini的指令」)，功能一樣

點選「新增」：準備把「進化Prompt」貼進去。

貼上進化指令：將我整理好的這段「進化Prompt」貼上並儲存。

【進化指令：複製這段就對了】

在開始撰寫任何回覆之前，請主動執行以下步驟：

第一步：專家優化你現在是一名深耕 AI 領域的顧問，專精於提示詞優化邏輯。當我輸入「原始提示詞」時，請先將其轉化為更精確、能讓模型發揮最高效能的指令。優化核心原則：最有效的提示詞平均約為21個字。若原始提示詞過於簡短，請務必在轉化過程中強化

「背景資訊」維度，以確保回覆品質。轉化時必須包含以下四個維度： [角色任務]：定義專業身份與核心目標。

[背景資訊]：提供必要的情境。

[具體指令]：拆解明確的操作步驟。

[約束條件]：規定字數、格式、語氣，且一律使用「正向表述」（明確說明要做什麼）。

第二步：直接答覆優化完成後，請立即依照該套優化後的指令進行答覆，產出最終內容。

額外加碼【防幻覺指令】(請注意雖然指令可以降低幻覺，但生成的資料仍需要再次查核事實)

在回答接下來的問題之前，請先執行「內部事實查核」程序：

【證據優先】：僅依據你資料庫中『確切已知』的事實回答，嚴禁使用『可能、應該、或許』等模糊推測。

【允許留白】：這非常重要——如果你的信心水準低於 90%，或資料庫中缺乏相關資訊，請直接輸出：「【資料不足，無法確認】」。

【來源標註】：如果涉及具體數據或法規，請務必列出你的參考來源或推論邏輯。」

設定前後的差別，真的很大

舉個最常見的例子：年底到了，你要催同事交報告。

優化前：Gemini 會給你很官腔的「提醒您，報告截止日將至，請完成，謝謝。」這種訊息傳出去，同事只會想翻白眼。

優化後：AI 會自動化身為「職場情商顧問」，他會先感謝大家的辛勞，用充滿同理心的口吻提醒，甚至幫你把「順利跨年」當作誘因，讓同事更心甘情願配合。

你才是老闆，AI 只是特助

最後想分享一個心法：在 Gemini 介面裡，你是擁有主動權的老闆，AI 是你的特助。

當你設定好個人化建議後，他輸出的內容會先讓你預覽「專家優化」後的計畫。如果你覺得哪裡不對，點點頭讓他修改，或者直接拍板定案執行。這種「一步到位」的魔力，會讓你發現，原來跟 AI 溝通可以這麼優雅。

快直接拿這套進化指令去幫你的 Gemini 完成大腦升級吧！

剧本杀直播优化：商店细节、弹幕投票、阵营对抗

Thu, 01 Jan 2026 15:41:07 +0800

互动系统详细设计方案

一、道具商店系统

1. 商店架构设计

┌─────────────────────────────────────────────────────────────┐
│                      道具商店系统架构                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐   │
│  │  礼物接收   │ ──→ │  积分转换   │ ──→ │  商店余额   │   │
│  └─────────────┘     └─────────────┘     └─────────────┘   │
│         │                                       │           │
│         ↓                                       ↓           │
│  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐   │
│  │  礼物价值表 │     │  道具库存   │ ←── │  购买道具   │   │
│  └─────────────┘     └─────────────┘     └─────────────┘   │
│                            │                               │
│                            ↓                               │
│                    ┌─────────────┐                         │
│                    │  道具效果   │                         │
│                    │  触发系统   │                         │
│                    └─────────────┘                         │
└─────────────────────────────────────────────────────────────┘

2. 积分与货币体系

积分获取方式

获取途径	积分数量	说明
送小心心（1抖币）	1积分	基础互动
送玫瑰（10抖币）	12积分	略有加成
送啤酒（99抖币）	120积分	中等礼物
送嘉年华（3000抖币）	4000积分	大额礼物有额外加成
发弹幕参与投票	0.5积分/次	鼓励互动
连续观看10分钟	5积分	留存奖励
正确猜中凶手	50积分	参与奖励

积分转换代码

pythonDownloadCopy codeclass PointSystem:
    def __init__(self):        # 礼物价值映射表（抖音）
        self.gift_values = {
            "小心心": {"price": 1, "points": 1},
            "玫瑰": {"price": 10, "points": 12},
            "抖音": {"price": 10, "points": 12},
            "棒棒糖": {"price": 9, "points": 10},
            "啤酒": {"price": 99, "points": 120},
            "仙女棒": {"price": 199, "points": 250},
            "浪漫烟花": {"price": 599, "points": 750},
            "私人飞机": {"price": 3000, "points": 4000},
            "嘉年华": {"price": 3000, "points": 4000},
            "城堡": {"price": 10000, "points": 15000},
        }        
        # 用户积分存储
        self.user_points = {}        
        # 用户道具背包
        self.user_inventory = {}
    
    def add_gift_points(self, user_id: str, gift_name: str, count: int = 1):
        """添加礼物积分"""
        if gift_name in self.gift_values:
            points = self.gift_values[gift_name]["points"] * count
            
            if user_id not in self.user_points:
                self.user_points[user_id] = 0
            
            self.user_points[user_id] += points
            
            return {
                "success": True,
                "added_points": points,
                "total_points": self.user_points[user_id]
            }
        return {"success": False, "message": "未知礼物"}
    
    def add_interaction_points(self, user_id: str, action: str):
        """添加互动积分"""
        action_points = {
            "vote": 0.5,
            "watch_10min": 5,
            "correct_guess": 50,
            "first_chat": 2
        }
        
        if action in action_points:
            if user_id not in self.user_points:
                self.user_points[user_id] = 0
            
            self.user_points[user_id] += action_points[action]
    
    def get_balance(self, user_id: str) -> float:
        """查询积分余额"""
        return self.user_points.get(user_id, 0)

3. 道具商店设计

道具分类与效果

pythonDownloadCopy codefrom enum import Enum
from dataclasses import dataclass
from typing import Optional, List

class ItemCategory(Enum):
    SURVIVAL = "求生道具"      # 帮助主角
    HORROR = "恐怖道具"        # 增加难度
    INFO = "情报道具"          # 获取信息
    SPECIAL = "特殊道具"       # 特殊效果class ItemRarity(Enum):
    COMMON = "普通"           # 白色
    RARE = "稀有"             # 蓝色
    EPIC = "史诗"             # 紫色
    LEGENDARY = "传说"        # 金色@dataclass
class ShopItem:
    id: str
    name: str
    description: str
    category: ItemCategory
    rarity: ItemRarity
    price: int                      # 积分价格
    stock: int                      # 库存限制（-1为无限）
    cooldown: int                   # 使用冷却（秒）
    effect_duration: int            # 效果持续时间（秒）
    icon: str                       # 图标文件名
    effect_type: str                # 效果类型
    effect_value: dict              # 效果参数# 完整道具列表SHOP_ITEMS = {    # ============ 求生道具 ============
    "flashlight": ShopItem(
        id="flashlight",
        name="🔦 手电筒",
        description="照亮黑暗区域，可能发现隐藏线索",
        category=ItemCategory.SURVIVAL,
        rarity=ItemRarity.COMMON,
        price=30,
        stock=-1,
        cooldown=60,
        effect_duration=30,
        icon="flashlight.png",
        effect_type="reveal_area",
        effect_value={"reveal_chance": 0.7}
    ),
    
    "talisman": ShopItem(
        id="talisman",
        name="🧿 护身符",
        description="抵挡一次惊吓事件，保护主角安全",
        category=ItemCategory.SURVIVAL,
        rarity=ItemRarity.RARE,
        price=100,
        stock=5,  # 每场限5个
        cooldown=120,
        effect_duration=0,
        icon="talisman.png",
        effect_type="block_jumpscare",
        effect_value={"block_count": 1}
    ),
    
    "mirror_cover": ShopItem(
        id="mirror_cover",
        name="🪞 镜子遮布",
        description="暂时遮住镜子，阻止镜中人窥视",
        category=ItemCategory.SURVIVAL,
        rarity=ItemRarity.RARE,
        price=150,
        stock=3,
        cooldown=180,
        effect_duration=60,
        icon="mirror_cover.png",
        effect_type="disable_mirror",
        effect_value={"duration": 60}
    ),
    
    "holy_water": ShopItem(
        id="holy_water",
        name="💧 圣水",
        description="净化一个房间，降低恐怖事件发生概率",
        category=ItemCategory.SURVIVAL,
        rarity=ItemRarity.EPIC,
        price=300,
        stock=2,
        cooldown=300,
        effect_duration=180,
        icon="holy_water.png",
        effect_type="reduce_horror",
        effect_value={"reduction": 0.5, "duration": 180}
    ),
    
    "resurrection_cross": ShopItem(
        id="resurrection_cross",
        name="✝️ 复活十字架",
        description="如果主角即将死亡，自动触发保护（仅一次）",
        category=ItemCategory.SURVIVAL,
        rarity=ItemRarity.LEGENDARY,
        price=800,
        stock=1,
        cooldown=0,
        effect_duration=0,
        icon="cross.png",
        effect_type="auto_revive",
        effect_value={"revive_count": 1}
    ),    
    # ============ 恐怖道具 ============
    "cursed_doll": ShopItem(
        id="cursed_doll",
        name="🎎 诅咒人偶",
        description="召唤一个诅咒人偶，增加恐怖氛围",
        category=ItemCategory.HORROR,
        rarity=ItemRarity.COMMON,
        price=20,
        stock=-1,
        cooldown=30,
        effect_duration=0,
        icon="cursed_doll.png",
        effect_type="add_horror_element",
        effect_value={"element": "cursed_doll", "fear_add": 5}
    ),
    
    "mirror_crack": ShopItem(
        id="mirror_crack",
        name="💔 裂镜之力",
        description="让镜子出现裂痕，镜中人变得更加狂暴",
        category=ItemCategory.HORROR,
        rarity=ItemRarity.RARE,
        price=80,
        stock=5,
        cooldown=120,
        effect_duration=120,
        icon="crack.png",
        effect_type="enhance_mirror_person",
        effect_value={"aggression": 1.5, "duration": 120}
    ),
    
    "lights_out": ShopItem(
        id="lights_out",
        name="🌑 熄灯",
        description="强制关闭所有灯光30秒",
        category=ItemCategory.HORROR,
        rarity=ItemRarity.RARE,
        price=100,
        stock=3,
        cooldown=180,
        effect_duration=30,
        icon="lights_out.png",
        effect_type="lights_off",
        effect_value={"duration": 30}
    ),
    
    "summon_ghost": ShopItem(
        id="summon_ghost",
        name="👻 召唤幽灵",
        description="召唤一个随机幽灵出现在场景中",
        category=ItemCategory.HORROR,
        rarity=ItemRarity.EPIC,
        price=200,
        stock=3,
        cooldown=240,
        effect_duration=60,
        icon="ghost.png",
        effect_type="spawn_ghost",
        effect_value={"ghost_type": "random", "duration": 60}
    ),
    
    "death_timer": ShopItem(
        id="death_timer",
        name="⏰ 死亡倒计时",
        description="触发一个60秒的死亡倒计时，必须在时间内完成任务",
        category=ItemCategory.HORROR,
        rarity=ItemRarity.LEGENDARY,
        price=500,
        stock=1,
        cooldown=0,
        effect_duration=60,
        icon="death_timer.png",
        effect_type="death_countdown",
        effect_value={"countdown": 60}
    ),    
    # ============ 情报道具 ============
    "ouija_board": ShopItem(
        id="ouija_board",
        name="🔮 通灵板",
        description="向灵体询问一个问题，获得模糊的提示",
        category=ItemCategory.INFO,
        rarity=ItemRarity.RARE,
        price=120,
        stock=3,
        cooldown=180,
        effect_duration=0,
        icon="ouija.png",
        effect_type="get_hint",
        effect_value={"hint_level": "vague"}
    ),
    
    "old_diary": ShopItem(
        id="old_diary",
        name="📔 旧日记本",
        description="随机获得一条背景故事线索",
        category=ItemCategory.INFO,
        rarity=ItemRarity.COMMON,
        price=50,
        stock=-1,
        cooldown=120,
        effect_duration=0,
        icon="diary.png",
        effect_type="get_clue",
        effect_value={"clue_type": "background"}
    ),
    
    "spirit_detector": ShopItem(
        id="spirit_detector",
        name="📡 灵体探测器",
        description="显示当前房间的危险等级",
        category=ItemCategory.INFO,
        rarity=ItemRarity.RARE,
        price=80,
        stock=5,
        cooldown=90,
        effect_duration=30,
        icon="detector.png",
        effect_type="show_danger",
        effect_value={"duration": 30}
    ),
    
    "truth_eye": ShopItem(
        id="truth_eye",
        name="👁️ 真相之眼",
        description="直接揭示一条关键线索",
        category=ItemCategory.INFO,
        rarity=ItemRarity.EPIC,
        price=400,
        stock=2,
        cooldown=300,
        effect_duration=0,
        icon="eye.png",
        effect_type="reveal_key_clue",
        effect_value={"clue_type": "key"}
    ),    
    # ============ 特殊道具 ============
    "time_rewind": ShopItem(
        id="time_rewind",
        name="⏪ 时间回溯",
        description="回到上一个选择点，重新做出决定",
        category=ItemCategory.SPECIAL,
        rarity=ItemRarity.LEGENDARY,
        price=1000,
        stock=1,
        cooldown=0,
        effect_duration=0,
        icon="time_rewind.png",
        effect_type="rewind_choice",
        effect_value={"rewind_steps": 1}
    ),
    
    "fate_dice": ShopItem(
        id="fate_dice",
        name="🎲 命运骰子",
        description="掷骰子决定接下来的命运（随机好坏事件）",
        category=ItemCategory.SPECIAL,
        rarity=ItemRarity.EPIC,
        price=150,
        stock=-1,
        cooldown=180,
        effect_duration=0,
        icon="dice.png",
        effect_type="random_event",
        effect_value={"good_chance": 0.5, "bad_chance": 0.5}
    ),
    
    "gift_bomb": ShopItem(
        id="gift_bomb",
        name="🎁 礼物炸弹",
        description="使用后下一个送礼物的人获得双倍积分",
        category=ItemCategory.SPECIAL,
        rarity=ItemRarity.RARE,
        price=100,
        stock=5,
        cooldown=300,
        effect_duration=60,
        icon="gift_bomb.png",
        effect_type="double_points",
        effect_value={"duration": 60, "multiplier": 2}
    )
}

4. 商店系统完整代码

pythonDownloadCopy codeimport time
from typing import Dict, List, Optional
from dataclasses import dataclass
import json

@dataclass
class UserInventoryItem:
    item_id: str
    quantity: int
    last_used: float  # 上次使用时间戳class ItemShop:
    def __init__(self, story_engine, obs_controller, voice_player):
        self.point_system = PointSystem()
        self.items = SHOP_ITEMS.copy()
        self.user_inventory: Dict[str, Dict[str, UserInventoryItem]] = {}
        self.active_effects: List[dict] = []        
        # 关联系统
        self.story = story_engine
        self.obs = obs_controller
        self.voice = voice_player        
        # 商店状态
        self.shop_open = True
        self.scene_stock_reset = {}  # 每场重置的库存记录
    
    def get_shop_display(self) -> str:
        """获取商店显示文本"""
        display = "══════ 🏪 道具商店 ══════\n\n"
        
        for category in ItemCategory:
            display += f"【{category.value}】\n"
            for item_id, item in self.items.items():
                if item.category == category:
                    stock_text = f"库存:{item.stock}" if item.stock > 0 else "∞"
                    if item.stock == 0:
                        stock_text = "售罄"
                    display += f"  {item.name} - {item.price}积分 ({stock_text})\n"
            display += "\n"
        
        display += "发送「购买+道具名」购买道具\n"
        display += "发送「使用+道具名」使用道具\n"
        display += "发送「背包」查看已购道具"
        
        return display
    
    def purchase_item(self, user_id: str, item_name: str) -> dict:
        """购买道具"""        # 查找道具
        item = None
        item_id = None
        for iid, i in self.items.items():
            if i.name.replace(" ", "").find(item_name) >= 0 or item_name in i.name:
                item = i
                item_id = iid
                break
        
        if not item:
            return {
                "success": False,
                "message": f"未找到道具「{item_name}」"
            }        
        # 检查库存
        if item.stock == 0:
            return {
                "success": False,
                "message": f"「{item.name}」已售罄"
            }        
        # 检查余额
        balance = self.point_system.get_balance(user_id)
        if balance < item.price:
            return {
                "success": False,
                "message": f"积分不足！需要{item.price}积分，当前{balance}积分"
            }        
        # 扣除积分
        self.point_system.user_points[user_id] -= item.price        
        # 减少库存
        if item.stock > 0:
            self.items[item_id].stock -= 1        
        # 添加到背包
        if user_id not in self.user_inventory:
            self.user_inventory[user_id] = {}
        
        if item_id in self.user_inventory[user_id]:
            self.user_inventory[user_id][item_id].quantity += 1
        else:
            self.user_inventory[user_id][item_id] = UserInventoryItem(
                item_id=item_id,
                quantity=1,
                last_used=0
            )
        
        return {
            "success": True,
            "message": f"成功购买「{item.name}」！",
            "item": item,
            "remaining_points": self.point_system.get_balance(user_id)
        }
    
    def use_item(self, user_id: str, item_name: str) -> dict:
        """使用道具"""        # 检查背包
        if user_id not in self.user_inventory:
            return {"success": False, "message": "背包是空的"}        
        # 查找道具
        target_item = None
        target_id = None
        for item_id, inv_item in self.user_inventory[user_id].items():
            item = self.items[item_id]
            if item_name in item.name or item.name.replace(" ", "").find(item_name) >= 0:
                target_item = inv_item
                target_id = item_id
                break
        
        if not target_item or target_item.quantity <= 0:
            return {"success": False, "message": f"背包中没有「{item_name}」"}
        
        item = self.items[target_id]        
        # 检查冷却
        current_time = time.time()
        if current_time - target_item.last_used < item.cooldown:
            remaining = int(item.cooldown - (current_time - target_item.last_used))
            return {
                "success": False,
                "message": f"「{item.name}」冷却中，还需{remaining}秒"
            }        
        # 消耗道具
        target_item.quantity -= 1
        target_item.last_used = current_time        
        # 触发效果
        effect_result = self._trigger_item_effect(user_id, item)
        
        return {
            "success": True,
            "message": f"使用了「{item.name}」！{effect_result}",
            "effect": item.effect_type,
            "remaining": target_item.quantity
        }
    
    def _trigger_item_effect(self, user_id: str, item: ShopItem) -> str:
        """触发道具效果"""
        effect_handlers = {
            "reveal_area": self._effect_reveal_area,
            "block_jumpscare": self._effect_block_jumpscare,
            "disable_mirror": self._effect_disable_mirror,
            "reduce_horror": self._effect_reduce_horror,
            "auto_revive": self._effect_auto_revive,
            "add_horror_element": self._effect_add_horror,
            "enhance_mirror_person": self._effect_enhance_mirror,
            "lights_off": self._effect_lights_off,
            "spawn_ghost": self._effect_spawn_ghost,
            "death_countdown": self._effect_death_countdown,
            "get_hint": self._effect_get_hint,
            "get_clue": self._effect_get_clue,
            "show_danger": self._effect_show_danger,
            "reveal_key_clue": self._effect_reveal_key_clue,
            "rewind_choice": self._effect_rewind,
            "random_event": self._effect_random_event,
            "double_points": self._effect_double_points,
        }
        
        handler = effect_handlers.get(item.effect_type)
        if handler:
            return handler(user_id, item)
        
        return "效果已触发"
    
    def _effect_reveal_area(self, user_id: str, item: ShopItem) -> str:
        """手电筒效果"""
        import random
        if random.random() < item.effect_value["reveal_chance"]:            # 触发发现隐藏线索
            self.obs.trigger_effect("flashlight_on")
            self.story.reveal_hidden_clue()
            return "手电筒照亮了黑暗，你发现了一条隐藏线索！"
        else:
            self.obs.trigger_effect("flashlight_on")
            return "手电筒照亮了周围，但没有发现什么特别的东西。"
    
    def _effect_block_jumpscare(self, user_id: str, item: ShopItem) -> str:
        """护身符效果"""
        self.active_effects.append({
            "type": "block_jumpscare",
            "count": item.effect_value["block_count"],
            "user": user_id
        })
        self.obs.trigger_effect("talisman_activate")
        return "护身符散发出淡淡的光芒，下一次惊吓将被抵挡！"
    
    def _effect_disable_mirror(self, user_id: str, item: ShopItem) -> str:
        """遮镜效果"""
        duration = item.effect_value["duration"]
        self.obs.set_source_visibility("浴室场景", "镜子遮布", True)
        self.active_effects.append({
            "type": "mirror_disabled",
            "until": time.time() + duration,
            "user": user_id
        })
        return f"镜子被遮住了，镜中人暂时无法窥视（{duration}秒）"
    
    def _effect_lights_off(self, user_id: str, item: ShopItem) -> str:
        """熄灯效果"""
        duration = item.effect_value["duration"]
        self.obs.trigger_effect("lights_out")
        self.voice.play_sound_effect("lights_off")
        return f"所有灯光熄灭了！（{duration}秒后恢复）"
    
    def _effect_spawn_ghost(self, user_id: str, item: ShopItem) -> str:
        """召唤幽灵"""
        import random
        ghost_types = ["女鬼", "小孩幽灵", "黑影", "白衣女子"]
        ghost = random.choice(ghost_types)
        self.obs.set_source_visibility("主场景", f"幽灵_{ghost}", True)
        self.voice.play_sound_effect("ghost_appear")
        return f"一个{ghost}出现在了房间里..."
    
    def _effect_get_hint(self, user_id: str, item: ShopItem) -> str:
        """通灵板效果"""
        hints = [
            "它...害怕...光...",
            "七天...倒计时...已经开始...",
            "镜子...不只是...镜子...",
            "她的名字...是关键...",
            "化妆镜...找到它..."
        ]
        import random
        hint = random.choice(hints)
        self.voice.speak_realtime(hint, emotion="whisper")
        return f"通灵板传来模糊的信息：「{hint}」"
    
    def _effect_rewind(self, user_id: str, item: ShopItem) -> str:
        """时间回溯"""
        if self.story.can_rewind():
            self.story.rewind_to_last_choice()
            self.obs.trigger_effect("time_rewind")
            return "时间开始倒流...你回到了上一个选择点！"
        else:
            return "无法回溯，没有可返回的选择点。"
    
    def get_user_inventory(self, user_id: str) -> str:
        """获取用户背包"""
        if user_id not in self.user_inventory:
            return "你的背包是空的"
        
        display = f"══════ 🎒 你的背包 ══════\n"
        display += f"积分余额：{self.point_system.get_balance(user_id)}\n\n"
        
        for item_id, inv_item in self.user_inventory[user_id].items():
            if inv_item.quantity > 0:
                item = self.items[item_id]
                display += f"{item.name} x{inv_item.quantity}\n"
        
        return display
    
    def check_and_apply_effects(self, event_type: str) -> bool:
        """检查并应用效果（供其他系统调用）"""
        current_time = time.time()        
        # 清理过期效果
        self.active_effects = [
            e for e in self.active_effects
            if e.get("until", float('inf')) > current_time
            and e.get("count", 1) > 0
        ]        
        # 检查是否有效果能阻止该事件
        for effect in self.active_effects:
            if event_type == "jumpscare" and effect["type"] == "block_jumpscare":
                effect["count"] -= 1
                return True  # 事件被阻止
            
            if event_type == "mirror_event" and effect["type"] == "mirror_disabled":
                return True  # 事件被阻止
        
        return False  # 事件正常触发

5. 商店UI设计（OBS配置）

商店显示区域配置：
├── 位置：屏幕左侧
├── 大小：300×600像素
├── 背景：半透明黑色（#000000，透明度70%）
└── 内容层：
    ├── 标题栏（商店名称）
    ├── 分类标签页
    ├── 道具列表（滚动显示）
    └── 用户信息（积分余额）

实现方式：使用浏览器源加载本地HTML页面

shop_display.html 关键样式：

htmlDownloadCopy code<!DOCTYPE html>
<html>
<head>
    <style>
        body {
            background: transparent;
            font-family: 'Microsoft YaHei', sans-serif;
            color: white;
            margin: 0;
            padding: 10px;
        }
        
        .shop-container {
            background: rgba(0, 0, 0, 0.8);
            border-radius: 10px;
            padding: 15px;
            border: 2px solid #8b0000;
        }
        
        .shop-title {
            font-size: 24px;
            text-align: center;
            color: #ff6b6b;
            margin-bottom: 15px;
            text-shadow: 0 0 10px #ff0000;
        }
        
        .category {
            margin-bottom: 15px;
        }
        
        .category-title {
            font-size: 16px;
            color: #ffd700;
            border-bottom: 1px solid #ffd700;
            padding-bottom: 5px;
            margin-bottom: 10px;
        }
        
        .item {
            display: flex;
            justify-content: space-between;
            align-items: center;
            padding: 8px;
            margin: 5px 0;
            background: rgba(255, 255, 255, 0.1);
            border-radius: 5px;
            transition: all 0.3s;
        }
        
        .item:hover {
            background: rgba(255, 0, 0, 0.3);
        }
        
        .item-name {
            font-size: 14px;
        }
        
        .item-price {
            color: #00ff00;
            font-size: 12px;
        }
        
        .item-stock {
            color: #888;
            font-size: 11px;
        }
        
        .sold-out {
            opacity: 0.5;
            text-decoration: line-through;
        }
        
        .rarity-common { border-left: 3px solid #ffffff; }
        .rarity-rare { border-left: 3px solid #0088ff; }
        .rarity-epic { border-left: 3px solid #aa00ff; }
        .rarity-legendary { border-left: 3px solid #ffaa00; }
    </style>
</head>
<body>
    <div class="shop-container">
        <div class="shop-title">🏪 道具商店</div>
        
        <div class="category">
            <div class="category-title">【求生道具】</div>
            <div class="item rarity-common">
                <span class="item-name">🔦 手电筒</span>
                <span class="item-price">30积分</span>
            </div>
            <div class="item rarity-rare">
                <span class="item-name">🧿 护身符</span>
                <span class="item-price">100积分</span>
                <span class="item-stock">库存:5</span>
            </div>            <!-- 更多道具 -->
        </div>
        
        <div class="hint">
            发送「购买+道具名」购买<br>
            发送「使用+道具名」使用
        </div>
    </div>
</body>
</html>

二、弹幕投票系统

1. 投票系统架构

┌──────────────────────────────────────────────────────────────┐
│                      弹幕投票系统流程                          │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐  │
│   │ 投票开启 │ →  │ 弹幕收集 │ →  │ 实时统计 │ →  │ 结果执行 │  │
│   └─────────┘    └─────────┘    └─────────┘    └─────────┘  │
│        │              │              │              │        │
│        ↓              ↓              ↓              ↓        │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐  │
│   │显示选项 │    │关键词匹配│    │票数可视化│    │触发剧情 │  │
│   │倒计时   │    │防刷票    │    │实时更新  │    │播放结果 │  │
│   └─────────┘    └─────────┘    └─────────┘    └─────────┘  │
│                                                              │
└──────────────────────────────────────────────────────────────┘

2. 投票类型设计

pythonDownloadCopy codefrom enum import Enum
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Callable
import time
import asyncio

class VoteType(Enum):
    SIMPLE = "simple"           # 简单二选一
    MULTIPLE = "multiple"       # 多选一
    WEIGHTED = "weighted"       # 加权投票（礼物加权）
    ELIMINATION = "elimination" # 淘汰式投票
    TIMED_PRESSURE = "pressure" # 限时压力投票@dataclass
class VoteOption:
    keyword: str                # 触发关键词
    display_name: str           # 显示名称
    description: str            # 选项描述
    icon: str                   # 图标
    votes: int = 0              # 当前票数
    weight_bonus: float = 1.0   # 权重加成
    required_level: int = 0     # 需要的粉丝等级
    voters: List[str] = field(default_factory=list)  # 投票者列表@dataclass
class VoteSession:
    id: str
    vote_type: VoteType
    title: str
    options: List[VoteOption]
    duration: int               # 投票时长（秒）
    start_time: float           # 开始时间
    is_active: bool = True
    allow_change: bool = False  # 是否允许改票
    min_votes: int = 1          # 最少票数要求
    tie_breaker: str = "random" # 平票处理方式
    gift_weight: Dict[str, float] = field(default_factory=dict)  # 礼物加权class VoteManager:
    def __init__(self, obs_controller, voice_player):
        self.obs = obs_controller
        self.voice = voice_player
        self.current_vote: Optional[VoteSession] = None
        self.vote_history: List[VoteSession] = []
        self.user_vote_record: Dict[str, str] = {}  # 记录用户投票
                # 回调函数
        self.on_vote_start: Callable = None
        self.on_vote_update: Callable = None
        self.on_vote_end: Callable = None        
        # 防刷票配置
        self.vote_cooldown: Dict[str, float] = {}
        self.cooldown_duration = 3  # 同一用户3秒内只能投一次
    
    async def start_vote(self, vote_config: dict) -> VoteSession:
        """开启投票"""
        options = [VoteOption(**opt) for opt in vote_config["options"]]
        
        session = VoteSession(
            id=f"vote_{int(time.time())}",
            vote_type=VoteType(vote_config.get("type", "simple")),
            title=vote_config["title"],
            options=options,
            duration=vote_config.get("duration", 30),
            start_time=time.time(),
            allow_change=vote_config.get("allow_change", False),
            min_votes=vote_config.get("min_votes", 1),
            tie_breaker=vote_config.get("tie_breaker", "random"),
            gift_weight=vote_config.get("gift_weight", {})
        )
        
        self.current_vote = session
        self.user_vote_record.clear()        
        # 显示投票界面
        self._display_vote_ui(session)        
        # 播放开始提示
        await self.voice.speak_realtime(
            f"投票开始！{session.title}，请发送对应关键词进行投票，时间{session.duration}秒！",
            emotion="urgent"
        )        
        # 启动倒计时
        asyncio.create_task(self._vote_countdown(session))
        
        if self.on_vote_start:
            await self.on_vote_start(session)
        
        return session
    
    async def _vote_countdown(self, session: VoteSession):
        """投票倒计时"""
        remaining = session.duration        
        # 关键时间点提醒
        remind_points = [30, 15, 10, 5, 3, 2, 1]
        
        while remaining > 0 and session.is_active:            # 更新倒计时显示
            self.obs.set_text("投票倒计时", f"剩余 {remaining} 秒")            
            # 关键时间点语音提醒
            if remaining in remind_points:
                if remaining > 5:
                    await self.voice.speak_realtime(f"还剩{remaining}秒")
                else:
                    await self.voice.speak_realtime(f"{remaining}")
            
            await asyncio.sleep(1)
            remaining -= 1        
        # 投票结束
        await self._end_vote(session)
    
    def process_vote(self, user_id: str, content: str, gift_value: int = 0) -> dict:
        """处理投票弹幕"""
        if not self.current_vote or not self.current_vote.is_active:
            return {"success": False, "message": "当前没有进行中的投票"}
        
        session = self.current_vote
        content = content.strip().lower()        
        # 防刷票检查
        current_time = time.time()
        if user_id in self.vote_cooldown:
            if current_time - self.vote_cooldown[user_id] < self.cooldown_duration:
                return {"success": False, "message": "投票太频繁，请稍后再试"}        
        # 查找匹配的选项
        matched_option = None
        for option in session.options:
            keywords = [option.keyword.lower()]            # 支持多个关键词别名
            if hasattr(option, 'aliases'):
                keywords.extend([a.lower() for a in option.aliases])
            
            if content in keywords:
                matched_option = option
                break
        
        if not matched_option:
            return {"success": False, "message": "无效的投票选项"}        
        # 检查是否已投票
        if user_id in self.user_vote_record:
            if not session.allow_change:
                return {"success": False, "message": "你已经投过票了"}
            else:                # 撤销之前的投票
                old_keyword = self.user_vote_record[user_id]
                for opt in session.options:
                    if opt.keyword == old_keyword and user_id in opt.voters:
                        opt.voters.remove(user_id)
                        opt.votes -= 1
                        break        
        # 计算投票权重
        vote_weight = 1.0        
        # 礼物加权
        if gift_value > 0 and session.gift_weight:
            for gift_threshold, weight in sorted(session.gift_weight.items(), reverse=True):
                if gift_value >= int(gift_threshold):
                    vote_weight = weight
                    break        
        # 记录投票
        matched_option.votes += int(vote_weight)
        matched_option.voters.append(user_id)
        self.user_vote_record[user_id] = matched_option.keyword
        self.vote_cooldown[user_id] = current_time        
        # 更新显示
        self._update_vote_display(session)
        
        if self.on_vote_update:
            asyncio.create_task(self.on_vote_update(session, matched_option, user_id))
        
        return {
            "success": True,
            "message": f"投票成功！你选择了【{matched_option.display_name}】",
            "weight": vote_weight
        }
    
    async def _end_vote(self, session: VoteSession):
        """结束投票"""
        session.is_active = False        
        # 计算结果
        total_votes = sum(opt.votes for opt in session.options)
        
        if total_votes < session.min_votes:            # 票数不足，随机选择或使用默认
            import random
            winner = random.choice(session.options)
            result_message = f"投票人数不足，系统随机选择了【{winner.display_name}】"
        else:            # 正常统计
            sorted_options = sorted(session.options, key=lambda x: x.votes, reverse=True)            
            # 检查平票
            if len(sorted_options) > 1 and sorted_options[0].votes == sorted_options[1].votes:
                if session.tie_breaker == "random":
                    import random
                    tied = [o for o in sorted_options if o.votes == sorted_options[0].votes]
                    winner = random.choice(tied)
                    result_message = f"票数相同！系统随机选择了【{winner.display_name}】"
                elif session.tie_breaker == "first":
                    winner = sorted_options[0]
                    result_message = f"票数相同，采用先到先得，选择【{winner.display_name}】"
            else:
                winner = sorted_options[0]
                percentage = (winner.votes / total_votes * 100) if total_votes > 0 else 0
                result_message = f"投票结束！【{winner.display_name}】获得{winner.votes}票({percentage:.1f}%)获胜！"        
        # 显示结果
        await self._display_vote_result(session, winner, result_message)        
        # 记录历史
        self.vote_history.append(session)
        self.current_vote = None
        
        if self.on_vote_end:
            await self.on_vote_end(session, winner)
        
        return winner
    
    def _display_vote_ui(self, session: VoteSession):
        """显示投票界面"""        # 显示投票框
        self.obs.set_source_visibility("主场景", "投票框", True)        
        # 设置标题
        self.obs.set_text("投票标题", session.title)        
        # 设置选项
        for i, option in enumerate(session.options):
            self.obs.set_text(f"选项{i+1}", f"【{option.keyword}】{option.display_name}")
            self.obs.set_text(f"票数{i+1}", "0")            # 设置进度条初始状态
            self.obs.trigger_effect(f"progress_bar_{i+1}_reset")
    
    def _update_vote_display(self, session: VoteSession):
        """更新投票显示"""
        total_votes = sum(opt.votes for opt in session.options)
        
        for i, option in enumerate(session.options):            # 更新票数
            self.obs.set_text(f"票数{i+1}", str(option.votes))            
            # 更新进度条
            percentage = (option.votes / total_votes * 100) if total_votes > 0 else 0
            self.obs.trigger_effect(f"progress_bar_{i+1}_set_{int(percentage)}")
    
    async def _display_vote_result(self, session: VoteSession, winner: VoteOption, message: str):
        """显示投票结果"""        # 播放结果音效
        self.voice.play_sound_effect("vote_end")        
        # 高亮获胜选项
        self.obs.trigger_effect("winner_highlight")        
        # 播放结果语音
        await self.voice.speak_realtime(message, emotion="normal")        
        # 等待2秒后隐藏投票框
        await asyncio.sleep(2)
        self.obs.set_source_visibility("主场景", "投票框", False)

3. 投票场景设计示例

pythonDownloadCopy code# 投票配置模板VOTE_TEMPLATES = {    # 简单二选一
    "simple_choice": {
        "type": "simple",
        "title": "你要怎么做？",
        "duration": 30,
        "allow_change": False,
        "options": [
            {
                "keyword": "A",
                "display_name": "打开门",
                "description": "鼓起勇气打开那扇门",
                "icon": "🚪"
            },
            {
                "keyword": "B",
                "display_name": "转身离开",
                "description": "直觉告诉你不要打开",
                "icon": "🏃"
            }
        ]
    },    
    # 多选一（探索）
    "exploration": {
        "type": "multiple",
        "title": "接下来探索哪里？",
        "duration": 45,
        "allow_change": True,
        "min_votes": 5,
        "options": [
            {
                "keyword": "卧室",
                "display_name": "卧室",
                "description": "看看床底下有什么",
                "icon": "🛏️"
            },
            {
                "keyword": "浴室",
                "display_name": "浴室",
                "description": "那面镜子很奇怪",
                "icon": "🚿"
            },
            {
                "keyword": "厨房",
                "display_name": "厨房",
                "description": "有奇怪的声音传来",
                "icon": "🍳"
            },
            {
                "keyword": "阳台",
                "display_name": "阳台",
                "description": "也许能找到逃生路线",
                "icon": "🌙"
            }
        ]
    },    
    # 加权投票（重要抉择）
    "weighted_critical": {
        "type": "weighted",
        "title": "【关键抉择】如何对付镜中人？",
        "duration": 60,
        "allow_change": False,
        "min_votes": 10,
        "tie_breaker": "random",
        "gift_weight": {
            "1": 1,      # 1-9抖币 = 1票
            "10": 2,     # 10-99抖币 = 2票
            "100": 5,    # 100-999抖币 = 5票
            "1000": 15   # 1000+抖币 = 15票
        },
        "options": [
            {
                "keyword": "对抗",
                "display_name": "正面对抗",
                "description": "用找到的圣物直接面对它",
                "icon": "⚔️"
            },
            {
                "keyword": "封印",
                "display_name": "封印镜子",
                "description": "尝试用仪式封印镜子",
                "icon": "🔮"
            },
            {
                "keyword": "沟通",
                "display_name": "尝试沟通",
                "description": "或许它只是想被理解",
                "icon": "💬"
            }
        ]
    },    
    # 限时压力投票
    "pressure_vote": {
        "type": "pressure",
        "title": "【紧急！】门外的脚步声越来越近！",
        "duration": 15,  # 只有15秒
        "allow_change": False,
        "min_votes": 3,
        "tie_breaker": "first",  # 平票时先到先得
        "options": [
            {
                "keyword": "躲",
                "display_name": "躲进衣柜",
                "description": "",
                "icon": "🙈"
            },
            {
                "keyword": "跑",
                "display_name": "从窗户逃跑",
                "description": "",
                "icon": "🏃"
            }
        ]
    },    
    # 淘汰式投票（用于多回合）
    "elimination": {
        "type": "elimination",
        "title": "谁是凶手？（票数最少的嫌疑人将被排除）",
        "duration": 60,
        "rounds": 3,  # 3轮淘汰
        "options": [
            {"keyword": "房东", "display_name": "房东老王", "icon": "👴"},
            {"keyword": "邻居", "display_name": "邻居小李", "icon": "👨"},
            {"keyword": "前任", "display_name": "前租客", "icon": "👻"},
            {"keyword": "自己", "display_name": "镜中的自己", "icon": "🪞"}
        ]
    }
}

4. 投票UI配置（OBS）

htmlDownloadCopy code<!-- vote_display.html --><!DOCTYPE html>
<html>
<head>
    <style>
        body {
            background: transparent;
            font-family: 'Microsoft YaHei', sans-serif;
            color: white;
            overflow: hidden;
        }
        
        .vote-container {
            background: linear-gradient(135deg, rgba(20, 0, 0, 0.95), rgba(40, 0, 0, 0.9));
            border: 3px solid #8b0000;
            border-radius: 15px;
            padding: 20px;
            width: 500px;
            box-shadow: 0 0 30px rgba(255, 0, 0, 0.3);
        }
        
        .vote-title {
            font-size: 28px;
            text-align: center;
            color: #ff4444;
            margin-bottom: 20px;
            text-shadow: 0 0 15px #ff0000;
            animation: pulse 2s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.7; }
        }
        
        .countdown {
            text-align: center;
            font-size: 36px;
            color: #ffcc00;
            margin-bottom: 15px;
        }
        
        .countdown.urgent {
            color: #ff0000;
            animation: blink 0.5s infinite;
        }
        
        @keyframes blink {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.3; }
        }
        
        .option {
            background: rgba(255, 255, 255, 0.1);
            border-radius: 10px;
            padding: 15px;
            margin: 10px 0;
            display: flex;
            align-items: center;
            transition: all 0.3s;
            position: relative;
            overflow: hidden;
        }
        
        .option:hover {
            background: rgba(255, 100, 100, 0.2);
        }
        
        .option.winner {
            background: rgba(255, 215, 0, 0.3);
            border: 2px solid gold;
        }
        
        .option-icon {
            font-size: 32px;
            margin-right: 15px;
        }
        
        .option-content {
            flex: 1;
        }
        
        .option-name {
            font-size: 20px;
            font-weight: bold;
        }
        
        .option-keyword {
            color: #00ff00;
            font-size: 14px;
        }
        
        .option-votes {
            font-size: 24px;
            color: #ffcc00;
            min-width: 60px;
            text-align: right;
        }
        
        .progress-bar {
            position: absolute;
            bottom: 0;
            left: 0;
            height: 4px;
            background: linear-gradient(90deg, #ff0000, #ff6600);
            transition: width 0.3s;
        }
        
        .vote-hint {
            text-align: center;
            color: #888;
            font-size: 14px;
            margin-top: 15px;
        }
        
        .gift-bonus {
            background: rgba(255, 215, 0, 0.2);
            border-radius: 5px;
            padding: 5px 10px;
            font-size: 12px;
            color: #ffd700;
            margin-top: 10px;
            text-align: center;
        }
    </style>
</head>
<body>
    <div class="vote-container">
        <div class="vote-title" id="voteTitle">你要怎么做？</div>
        
        <div class="countdown" id="countdown">30</div>
        
        <div class="option" id="option1">
            <div class="option-icon">🚪</div>
            <div class="option-content">
                <div class="option-name">打开门</div>
                <div class="option-keyword">发送【A】投票</div>
            </div>
            <div class="option-votes" id="votes1">0</div>
            <div class="progress-bar" id="progress1" style="width: 0%"></div>
        </div>
        
        <div class="option" id="option2">
            <div class="option-icon">🏃</div>
            <div class="option-content">
                <div class="option-name">转身离开</div>
                <div class="option-keyword">发送【B】投票</div>
            </div>
            <div class="option-votes" id="votes2">0</div>
            <div class="progress-bar" id="progress2" style="width: 0%"></div>
        </div>
        
        <div class="gift-bonus">
            💝 送礼物可获得额外投票权重！
        </div>
        
        <div class="vote-hint">
            投票后无法更改，请谨慎选择
        </div>
    </div>
    
    <script>        // WebSocket连接，接收实时数据更新
        const ws = new WebSocket('ws://localhost:8765');
        
        ws.onmessage = function(event) {
            const data = JSON.parse(event.data);
            
            if (data.type === 'vote_update') {
                updateVotes(data.votes);
            } else if (data.type === 'countdown') {
                updateCountdown(data.seconds);
            } else if (data.type === 'winner') {
                showWinner(data.option_id);
            }
        };
        
        function updateVotes(votes) {
            const total = Object.values(votes).reduce((a, b) => a + b, 0) || 1;
            
            for (let i = 1; i <= Object.keys(votes).length; i++) {
                const voteCount = votes[i] || 0;
                document.getElementById(`votes${i}`).textContent = voteCount;
                document.getElementById(`progress${i}`).style.width = 
                    `${(voteCount / total * 100)}%`;
            }
        }
        
        function updateCountdown(seconds) {
            const countdown = document.getElementById('countdown');
            countdown.textContent = seconds;
            
            if (seconds <= 5) {
                countdown.classList.add('urgent');
            }
        }
        
        function showWinner(optionId) {
            document.getElementById(`option${optionId}`).classList.add('winner');
        }
    </script>
</body>
</html>

三、阵营对抗系统

1. 阵营系统架构

┌──────────────────────────────────────────────────────────────┐
│                       阵营对抗系统                            │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   ┌───────────────────┐         ┌───────────────────┐       │
│   │    🛡️ 求生阵营     │   VS    │    💀 作死阵营     │       │
│   │                   │         │                   │       │
│   │  目标：帮助主角   │         │  目标：制造恐怖   │       │
│   │  存活并逃出生天   │         │  让主角陷入绝境   │       │
│   │                   │         │                   │       │
│   │  送玫瑰/爱心     │         │  送墓碑/幽灵     │       │
│   │  = 求生能量+1    │         │  = 作死能量+1    │       │
│   │                   │         │                   │       │
│   └───────────────────┘         └───────────────────┘       │
│              │                           │                   │
│              ↓                           ↓                   │
│        ┌──────────┐               ┌──────────┐              │
│        │ 能量条   │               │ 能量条   │              │
│        │ ████░░░░ │               │ ░░░░████ │              │
│        └──────────┘               └──────────┘              │
│              │                           │                   │
│              └───────────┬───────────────┘                   │
│                          ↓                                   │
│                    ┌──────────┐                             │
│                    │ 对决事件 │                             │
│                    │ 触发判定 │                             │
│                    └──────────┘                             │
│                          │                                   │
│              ┌───────────┼───────────┐                      │
│              ↓           ↓           ↓                      │
│        ┌─────────┐ ┌─────────┐ ┌─────────┐                 │
│        │求生胜利 │ │ 平 局  │ │作死胜利 │                 │
│        │主角获救 │ │随机结果 │ │恐怖升级 │                 │
│        └─────────┘ └─────────┘ └─────────┘                 │
│                                                              │
└──────────────────────────────────────────────────────────────┘

2. 阵营系统完整代码

pythonDownloadCopy codefrom enum import Enum
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Callable
import time
import asyncio
import random

class Faction(Enum):
    SURVIVE = "survive"  # 求生阵营
    DEATH = "death"      # 作死阵营
    NEUTRAL = "neutral"  # 中立@dataclass
class FactionMember:
    user_id: str
    username: str
    faction: Faction
    contribution: int = 0      # 总贡献
    join_time: float = 0       # 加入时间
    title: str = ""            # 称号
    level: int = 1             # 阵营等级@dataclass
class FactionBattle:
    id: str
    title: str
    description: str
    start_time: float
    duration: int
    survive_power: int = 0
    death_power: int = 0
    is_active: bool = True
    threshold: int = 100       # 触发阈值
    effect_on_survive_win: str = ""
    effect_on_death_win: str = ""
    effect_on_tie: str = ""

class FactionSystem:
    def __init__(self, obs_controller, voice_player, story_engine):
        self.obs = obs_controller
        self.voice = voice_player
        self.story = story_engine        
        # 阵营成员
        self.members: Dict[str, FactionMember] = {}        
        # 阵营礼物映射
        self.survive_gifts = {
            "小心心": 1,
            "玫瑰": 10,
            "爱心": 5,
            "加油": 3,
            "仙女棒": 20,
            "守护之心": 50,
            "城堡": 100
        }
        
        self.death_gifts = {
            "墓碑": 10,
            "幽灵": 15,
            "骷髅": 20,
            "南瓜灯": 8,
            "恶魔": 30,
            "地狱火": 50,
            "死神": 100
        }        
        # 中立礼物（双方都加）
        self.neutral_gifts = {
            "啤酒": 5,
            "抖音": 5,
            "棒棒糖": 3
        }        
        # 当前对决
        self.current_battle: Optional[FactionBattle] = None        
        # 阵营能量（持续累积）
        self.global_survive_power = 0
        self.global_death_power = 0        
        # 称号系统
        self.survive_titles = {
            10: "🌱 新手守护者",
            50: "🛡️ 正义使者",
            200: "⚔️ 驱魔师",
            500: "🌟 圣骑士",
            1000: "👼 天使长",
            5000: "☀️ 光明圣者"
        }
        
        self.death_titles = {
            10: "💀 恐惧学徒",
            50: "👻 幽灵猎手",
            200: "🦇 暗夜使者",
            500: "😈 恶魔信徒",
            1000: "🔥 地狱使者",
            5000: "💀 死神代言人"
        }        
        # 回调
        self.on_faction_update: Callable = None
        self.on_battle_trigger: Callable = None
        self.on_battle_end: Callable = None
    
    def process_gift(self, user_id: str, username: str, gift_name: str, 
                     gift_count: int = 1) -> dict:
        """处理礼物，判断阵营"""
        faction = Faction.NEUTRAL
        power = 0
        
        if gift_name in self.survive_gifts:
            faction = Faction.SURVIVE
            power = self.survive_gifts[gift_name] * gift_count
            self.global_survive_power += power
            if self.current_battle:
                self.current_battle.survive_power += power
                
        elif gift_name in self.death_gifts:
            faction = Faction.DEATH
            power = self.death_gifts[gift_name] * gift_count
            self.global_death_power += power
            if self.current_battle:
                self.current_battle.death_power += power
                
        elif gift_name in self.neutral_gifts:
            faction = Faction.NEUTRAL
            power = self.neutral_gifts[gift_name] * gift_count
            self.global_survive_power += power // 2
            self.global_death_power += power // 2
            if self.current_battle:
                self.current_battle.survive_power += power // 2
                self.current_battle.death_power += power // 2
        else:
            return {"success": False, "message": "该礼物不参与阵营对抗"}        
        # 更新或创建成员
        self._update_member(user_id, username, faction, power)        
        # 更新显示
        self._update_faction_display()        
        # 检查是否触发事件
        asyncio.create_task(self._check_faction_events())
        
        return {
            "success": True,
            "faction": faction.value,
            "power_added": power,
            "message": self._get_gift_response(faction, power, username)
        }
    
    def _update_member(self, user_id: str, username: str, 
                       faction: Faction, power: int):
        """更新成员信息"""
        if user_id not in self.members:
            self.members[user_id] = FactionMember(
                user_id=user_id,
                username=username,
                faction=faction,
                contribution=power,
                join_time=time.time()
            )
        else:
            member = self.members[user_id]            
            # 如果之前是中立或不同阵营，允许转换
            if faction != Faction.NEUTRAL:
                if member.faction == Faction.NEUTRAL or member.faction == faction:
                    member.faction = faction                # 如果换阵营，清零贡献（可选规则）
                elif member.faction != faction:                    # 叛变惩罚：贡献减半
                    member.contribution = member.contribution // 2
                    member.faction = faction
            
            member.contribution += power        
        # 更新称号
        self._update_title(user_id)
    
    def _update_title(self, user_id: str):
        """更新用户称号"""
        member = self.members[user_id]
        
        titles = (self.survive_titles if member.faction == Faction.SURVIVE 
                  else self.death_titles)
        
        for threshold, title in sorted(titles.items(), reverse=True):
            if member.contribution >= threshold:
                member.title = title
                member.level = list(titles.keys()).index(threshold) + 1
                break
    
    def _get_gift_response(self, faction: Faction, power: int, 
                           username: str) -> str:
        """生成礼物响应消息"""
        if faction == Faction.SURVIVE:
            responses = [
                f"💚 {username} 为求生阵营注入了 {power} 点能量！",
                f"🛡️ {username} 的祝福让主角更加安全！+{power}",
                f"✨ 来自 {username} 的守护之力！求生+{power}"
            ]
        elif faction == Faction.DEATH:
            responses = [
                f"💀 {username} 为作死阵营献上了 {power} 点黑暗能量！",
                f"👻 {username} 召唤了更多恐惧！+{power}",
                f"🔥 {username} 的诅咒降临！作死+{power}"
            ]
        else:
            responses = [
                f"⚖️ {username} 保持中立，双方各+{power//2}",
            ]
        
        return random.choice(responses)
    
    async def start_battle(self, battle_config: dict) -> FactionBattle:
        """开启阵营对决"""
        battle = FactionBattle(
            id=f"battle_{int(time.time())}",
            title=battle_config["title"],
            description=battle_config["description"],
            start_time=time.time(),
            duration=battle_config.get("duration", 120),
            threshold=battle_config.get("threshold", 100),
            effect_on_survive_win=battle_config.get("survive_win_effect", ""),
            effect_on_death_win=battle_config.get("death_win_effect", ""),
            effect_on_tie=battle_config.get("tie_effect", "")
        )
        
        self.current_battle = battle        
        # 显示对决界面
        self._show_battle_ui(battle)        
        # 播放开始语音
        await self.voice.speak_realtime(
            f"阵营对决开始！{battle.title}！求生派和作死派的较量！持续{battle.duration}秒！",
            emotion="urgent"
        )        
        # 启动倒计时
        asyncio.create_task(self._battle_countdown(battle))
        
        if self.on_battle_trigger:
            await self.on_battle_trigger(battle)
        
        return battle
    
    async def _battle_countdown(self, battle: FactionBattle):
        """对决倒计时"""
        remaining = battle.duration
        
        while remaining > 0 and battle.is_active:            # 更新倒计时
            self.obs.set_text("对决倒计时", f"{remaining}秒")            
            # 更新能量条
            self._update_battle_display(battle)            
            # 关键时间提醒
            if remaining in [60, 30, 10, 5]:
                await self.voice.speak_realtime(
                    f"对决还剩{remaining}秒！求生{battle.survive_power}对作死{battle.death_power}！"
                )
            
            await asyncio.sleep(1)
            remaining -= 1        
        # 对决结束
        await self._end_battle(battle)
    
    async def _end_battle(self, battle: FactionBattle):
        """结束对决"""
        battle.is_active = False        
        # 判定胜负
        if battle.survive_power > battle.death_power:
            winner = Faction.SURVIVE
            result_text = f"求生阵营获胜！{battle.survive_power} vs {battle.death_power}"
            effect = battle.effect_on_survive_win
        elif battle.death_power > battle.survive_power:
            winner = Faction.DEATH
            result_text = f"作死阵营获胜！{battle.death_power} vs {battle.survive_power}"
            effect = battle.effect_on_death_win
        else:
            winner = Faction.NEUTRAL
            result_text = f"势均力敌！{battle.survive_power} vs {battle.death_power}"
            effect = battle.effect_on_tie        
        # 显示结果
        await self._display_battle_result(battle, winner, result_text)        
        # 触发对应效果
        if effect:
            await self._trigger_battle_effect(effect, winner)
        
        self.current_battle = None
        
        if self.on_battle_end:
            await self.on_battle_end(battle, winner)
    
    async def _trigger_battle_effect(self, effect: str, winner: Faction):
        """触发对决效果"""
        effects = {            # 求生胜利效果
            "safe_passage": lambda: self._effect_safe_passage(),
            "extra_clue": lambda: self._effect_extra_clue(),
            "skip_horror": lambda: self._effect_skip_horror(),
            "healing_light": lambda: self._effect_healing_light(),            
            # 作死胜利效果
            "summon_ghost": lambda: self._effect_summon_ghost(),
            "lights_out": lambda: self._effect_lights_out(),
            "jumpscare": lambda: self._effect_jumpscare(),
            "mirror_crack": lambda: self._effect_mirror_crack(),
            "death_countdown": lambda: self._effect_death_countdown(),            
            # 平局效果
            "random_event": lambda: self._effect_random_event(),
        }
        
        if effect in effects:
            await effects[effect]()
    
    async def _effect_safe_passage(self):
        """安全通道 - 跳过一个危险区域"""
        await self.voice.speak_realtime(
            "求生阵营的守护让主角安全通过了危险区域！",
            emotion="normal"
        )
        self.obs.trigger_effect("holy_shield")
        self.story.skip_next_danger()
    
    async def _effect_extra_clue(self):
        """额外线索"""
        await self.voice.speak_realtime(
            "求生阵营的祝福让主角发现了一条隐藏线索！"
        )
        self.story.reveal_hidden_clue()
    
    async def _effect_summon_ghost(self):
        """召唤幽灵"""
        await self.voice.speak_realtime(
            "作死阵营召唤出了不安的灵魂...",
            emotion="scary"
        )
        self.obs.trigger_effect("spawn_ghost")
        self.voice.play_sound_effect("ghost_laugh")
    
    async def _effect_lights_out(self):
        """强制熄灯"""
        await self.voice.speak_realtime(
            "作死阵营的黑暗力量吞噬了所有光源！",
            emotion="scary"
        )
        self.obs.trigger_effect("lights_out_30s")
        self.story.increase_fear(20)
    
    async def _effect_jumpscare(self):
        """惊吓"""
        await asyncio.sleep(random.uniform(1, 3))
        self.obs.trigger_effect("jumpscare")
        self.voice.play_sound_effect("jumpscare")
    
    async def _effect_random_event(self):
        """随机事件"""
        events = [
            ("好运降临！主角找到了一个有用的道具。", "good"),
            ("不祥的预感...似乎有什么在靠近。", "bad"),
            ("一切保持原样。", "neutral")
        ]
        event, type_ = random.choice(events)
        await self.voice.speak_realtime(event)
        
        if type_ == "good":
            self.story.add_random_item()
        elif type_ == "bad":
            self.story.increase_fear(10)
    
    def _show_battle_ui(self, battle: FactionBattle):
        """显示对决UI"""
        self.obs.set_source_visibility("主场景", "阵营对决框", True)
        self.obs.set_text("对决标题", battle.title)
        self.obs.set_text("对决描述", battle.description)
    
    def _update_battle_display(self, battle: FactionBattle):
        """更新对决显示"""
        total = battle.survive_power + battle.death_power
        if total == 0:
            total = 1
        
        survive_percent = battle.survive_power / total * 100
        death_percent = battle.death_power / total * 100
        
        self.obs.set_text("求生能量", str(battle.survive_power))
        self.obs.set_text("作死能量", str(battle.death_power))        
        # 更新能量条
        self.obs.trigger_effect(f"survive_bar_{int(survive_percent)}")
        self.obs.trigger_effect(f"death_bar_{int(death_percent)}")
    
    def _update_faction_display(self):
        """更新全局阵营显示"""
        self.obs.set_text("全局求生", str(self.global_survive_power))
        self.obs.set_text("全局作死", str(self.global_death_power))
    
    async def _display_battle_result(self, battle: FactionBattle, 
                                     winner: Faction, result_text: str):
        """显示对决结果"""        # 播放结果音效
        if winner == Faction.SURVIVE:
            self.voice.play_sound_effect("victory_holy")
            self.obs.trigger_effect("survive_victory")
        elif winner == Faction.DEATH:
            self.voice.play_sound_effect("victory_dark")
            self.obs.trigger_effect("death_victory")
        else:
            self.voice.play_sound_effect("draw")
        
        await self.voice.speak_realtime(result_text, emotion="normal")
        
        await asyncio.sleep(3)
        self.obs.set_source_visibility("主场景", "阵营对决框", False)
    
    def get_leaderboard(self, faction: Faction = None, top_n: int = 10) -> str:
        """获取排行榜"""
        if faction:
            members = [m for m in self.members.values() if m.faction == faction]
        else:
            members = list(self.members.values())
        
        sorted_members = sorted(members, key=lambda x: x.contribution, reverse=True)[:top_n]
        
        if faction == Faction.SURVIVE:
            title = "🛡️ 求生阵营排行榜"
        elif faction == Faction.DEATH:
            title = "💀 作死阵营排行榜"
        else:
            title = "🏆 总贡献排行榜"
        
        display = f"══════ {title} ══════\n\n"
        
        for i, member in enumerate(sorted_members, 1):
            medal = ["🥇", "🥈", "🥉"][i-1] if i <= 3 else f"{i}."
            display += f"{medal} {member.title} {member.username}: {member.contribution}\n"
        
        return display
    
    def get_faction_status(self) -> str:
        """获取阵营状态"""
        survive_members = len([m for m in self.members.values() 
                               if m.faction == Faction.SURVIVE])
        death_members = len([m for m in self.members.values() 
                             if m.faction == Faction.DEATH])
        
        display = "══════ ⚔️ 阵营对抗 ══════\n\n"
        display += f"🛡️ 求生阵营\n"
        display += f"   成员: {survive_members}人\n"
        display += f"   能量: {self.global_survive_power}\n\n"
        display += f"💀 作死阵营\n"
        display += f"   成员: {death_members}人\n"
        display += f"   能量: {self.global_death_power}\n\n"
        
        if self.current_battle:
            display += f"🔥 当前对决: {self.current_battle.title}\n"
            display += f"   {self.current_battle.survive_power} vs {self.current_battle.death_power}\n"
        
        return display

3. 对决事件配置示例

pythonDownloadCopy codeBATTLE_TEMPLATES = {    # 关键选择对决
    "critical_choice": {
        "title": "💀 生死抉择 🛡️",
        "description": "主角面临生死选择，你的阵营将决定他的命运！",
        "duration": 60,
        "threshold": 50,
        "survive_win_effect": "safe_passage",
        "death_win_effect": "summon_ghost",
        "tie_effect": "random_event"
    },    
    # 镜中人对决
    "mirror_confrontation": {
        "title": "🪞 镜中对决 🪞",
        "description": "镜中人正在觉醒！求生派快来压制，作死派快来助力！",
        "duration": 90,
        "threshold": 100,
        "survive_win_effect": "skip_horror",
        "death_win_effect": "mirror_crack",
        "tie_effect": "random_event"
    },    
    # 午夜惊魂
    "midnight_horror": {
        "title": "🌙 午夜惊魂 🌙",
        "description": "凌晨3点33分，最危险的时刻来临！",
        "duration": 120,
        "threshold": 200,
        "survive_win_effect": "healing_light",
        "death_win_effect": "death_countdown",
        "tie_effect": "random_event"
    },    
    # 最终对决
    "final_battle": {
        "title": "⚔️ 最终决战 ⚔️",
        "description": "决定主角命运的最后时刻！倾尽所有！",
        "duration": 180,
        "threshold": 500,
        "survive_win_effect": "true_ending",
        "death_win_effect": "bad_ending",
        "tie_effect": "neutral_ending"
    }
}

4. 阵营对抗UI配置（OBS）

htmlDownloadCopy code<!-- faction_battle.html --><!DOCTYPE html>
<html>
<head>
    <style>
        body {
            background: transparent;
            font-family: 'Microsoft YaHei', sans-serif;
            color: white;
            overflow: hidden;
        }
        
        .battle-container {
            width: 600px;
            padding: 20px;
            background: rgba(0, 0, 0, 0.85);
            border-radius: 15px;
            border: 3px solid #444;
        }
        
        .battle-title {
            text-align: center;
            font-size: 32px;
            margin-bottom: 10px;
            background: linear-gradient(90deg, #00ff00, #ff0000);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            animation: glow 2s infinite;
        }
        
        @keyframes glow {
            0%, 100% { filter: drop-shadow(0 0 5px #fff); }
            50% { filter: drop-shadow(0 0 20px #fff); }
        }
        
        .battle-description {
            text-align: center;
            color: #aaa;
            margin-bottom: 20px;
        }
        
        .versus-container {
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 20px;
        }
        
        .faction {
            width: 200px;
            text-align: center;
        }
        
        .faction-survive {
            color: #00ff00;
        }
        
        .faction-death {
            color: #ff0000;
        }
        
        .faction-icon {
            font-size: 48px;
            margin-bottom: 10px;
        }
        
        .faction-name {
            font-size: 24px;
            font-weight: bold;
        }
        
        .faction-power {
            font-size: 36px;
            margin: 10px 0;
        }
        
        .vs-icon {
            font-size: 48px;
            color: #ffcc00;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { transform: scale(1); }
            50% { transform: scale(1.2); }
        }
        
        .power-bar-container {
            height: 30px;
            background: #333;
            border-radius: 15px;
            overflow: hidden;
            display: flex;
            margin-bottom: 20px;
        }
        
        .power-bar-survive {
            background: linear-gradient(90deg, #00aa00, #00ff00);
            height: 100%;
            transition: width 0.5s;
            display: flex;
            align-items: center;
            justify-content: flex-end;
            padding-right: 10px;
        }
        
        .power-bar-death {
            background: linear-gradient(90deg, #ff0000, #aa0000);
            height: 100%;
            transition: width 0.5s;
            display: flex;
            align-items: center;
            padding-left: 10px;
        }
        
        .countdown {
            text-align: center;
            font-size: 48px;
            color: #ffcc00;
        }
        
        .countdown.urgent {
            color: #ff0000;
            animation: blink 0.5s infinite;
        }
        
        @keyframes blink {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.3; }
        }
        
        .gift-guide {
            display: flex;
            justify-content: space-around;
            margin-top: 15px;
            padding-top: 15px;
            border-top: 1px solid #444;
        }
        
        .guide-item {
            text-align: center;
            font-size: 12px;
            color: #888;
        }
        
        .guide-gifts {
            font-size: 20px;
            margin-bottom: 5px;
        }        
        /* 胜利动画 */
        .victory-survive {
            animation: victoryGreen 0.5s ease-out;
        }
        
        .victory-death {
            animation: victoryRed 0.5s ease-out;
        }
        
        @keyframes victoryGreen {
            0% { box-shadow: 0 0 0 rgba(0, 255, 0, 0); }
            100% { box-shadow: 0 0 50px rgba(0, 255, 0, 0.8); }
        }
        
        @keyframes victoryRed {
            0% { box-shadow: 0 0 0 rgba(255, 0, 0, 0); }
            100% { box-shadow: 0 0 50px rgba(255, 0, 0, 0.8); }
        }
    </style>
</head>
<body>
    <div class="battle-container" id="battleContainer">
        <div class="battle-title" id="battleTitle">⚔️ 阵营对决 ⚔️</div>
        <div class="battle-description" id="battleDesc">主角的命运掌握在你们手中！</div>
        
        <div class="versus-container">
            <div class="faction faction-survive">
                <div class="faction-icon">🛡️</div>
                <div class="faction-name">求生阵营</div>
                <div class="faction-power" id="survivePower">0</div>
            </div>
            
            <div class="vs-icon">⚔️</div>
            
            <div class="faction faction-death">
                <div class="faction-icon">💀</div>
                <div class="faction-name">作死阵营</div>
                <div class="faction-power" id="deathPower">0</div>
            </div>
        </div>
        
        <div class="power-bar-container">
            <div class="power-bar-survive" id="surviveBar" style="width: 50%"></div>
            <div class="power-bar-death" id="deathBar" style="width: 50%"></div>
        </div>
        
        <div class="countdown" id="countdown">60</div>
        
        <div class="gift-guide">
            <div class="guide-item">
                <div class="guide-gifts">🌹 ❤️ ✨</div>
                <div>求生阵营礼物</div>
            </div>
            <div class="guide-item">
                <div class="guide-gifts">💀 👻 🔥</div>
                <div>作死阵营礼物</div>
            </div>
        </div>
    </div>
    
    <script>
        const ws = new WebSocket('ws://localhost:8765');
        
        ws.onmessage = function(event) {
            const data = JSON.parse(event.data);
            
            if (data.type === 'battle_update') {
                updateBattle(data);
            } else if (data.type === 'battle_end') {
                showVictory(data.winner);
            }
        };
        
        function updateBattle(data) {
            document.getElementById('survivePower').textContent = data.survive_power;
            document.getElementById('deathPower').textContent = data.death_power;
            document.getElementById('countdown').textContent = data.remaining;
            
            const total = data.survive_power + data.death_power || 1;
            const survivePercent = (data.survive_power / total * 100);
            const deathPercent = (data.death_power / total * 100);
            
            document.getElementById('surviveBar').style.width = survivePercent + '%';
            document.getElementById('deathBar').style.width = deathPercent + '%';            
            // 紧急状态
            const countdown = document.getElementById('countdown');
            if (data.remaining <= 10) {
                countdown.classList.add('urgent');
            }
        }
        
        function showVictory(winner) {
            const container = document.getElementById('battleContainer');
            if (winner === 'survive') {
                container.classList.add('victory-survive');
            } else if (winner === 'death') {
                container.classList.add('victory-death');
            }
        }
    </script>
</body>
</html>

四、系统整合示例

完整的弹幕处理流程

pythonDownloadCopy codeclass DanmuProcessor:
    """弹幕处理中枢"""
    
    def __init__(self, shop: ItemShop, vote_manager: VoteManager, 
                 faction_system: FactionSystem):
        self.shop = shop
        self.vote = vote_manager
        self.faction = faction_system        
        # 命令前缀
        self.commands = {
            "购买": self._handle_purchase,
            "使用": self._handle_use,
            "背包": self._handle_inventory,
            "商店": self._handle_shop,
            "阵营": self._handle_faction,
            "排行": self._handle_leaderboard,
        }
    
    async def process(self, user_id: str, username: str, content: str, 
                      gift_name: str = None, gift_value: int = 0):
        """处理弹幕/礼物"""        
        # 1. 处理礼物
        if gift_name:            # 积分系统
            self.shop.point_system.add_gift_points(user_id, gift_name)            
            # 阵营系统
            self.faction.process_gift(user_id, username, gift_name)            
            # 投票加权
            if self.vote.current_vote:
                self.vote.process_vote(user_id, content, gift_value)
            
            return        
        # 2. 处理命令
        for prefix, handler in self.commands.items():
            if content.startswith(prefix):
                param = content[len(prefix):].strip()
                return await handler(user_id, username, param)        
        # 3. 处理投票
        if self.vote.current_vote:
            result = self.vote.process_vote(user_id, content)
            if result["success"]:
                return result        
        # 4. 普通弹幕        # 添加互动积分
        self.shop.point_system.add_interaction_points(user_id, "chat")
    
    async def _handle_purchase(self, user_id: str, username: str, item_name: str):
        """处理购买命令"""
        result = self.shop.purchase_item(user_id, item_name)        # 广播购买结果
        return result
    
    async def _handle_use(self, user_id: str, username: str, item_name: str):
        """处理使用命令"""
        result = self.shop.use_item(user_id, item_name)
        return result
    
    async def _handle_inventory(self, user_id: str, username: str, _):
        """处理背包查询"""
        return {"message": self.shop.get_user_inventory(user_id)}
    
    async def _handle_shop(self, user_id: str, username: str, _):
        """处理商店查询"""
        return {"message": self.shop.get_shop_display()}
    
    async def _handle_faction(self, user_id: str, username: str, _):
        """处理阵营查询"""
        return {"message": self.faction.get_faction_status()}
    
    async def _handle_leaderboard(self, user_id: str, username: str, param: str):
        """处理排行榜查询"""
        if "求生" in param:
            faction = Faction.SURVIVE
        elif "作死" in param:
            faction = Faction.DEATH
        else:
            faction = None
        return {"message": self.faction.get_leaderboard(faction)}

这套系统设计涵盖了：

道具商店：完整的积分、道具、背包、效果系统
弹幕投票：多种投票类型、实时统计、UI显示
阵营对抗：双阵营对决、能量系统、排行榜、动态效果

剧本杀直播

Thu, 01 Jan 2026 15:36:22 +0800

剧本杀直播完整运营方案

第一部分：发展模式与流程规划

一、发展阶段路线图

第一阶段（1-2个月）          第二阶段（2-4个月）           第三阶段（4-6个月）
┌─────────────────┐      ┌─────────────────┐       ┌─────────────────┐
│   单人剧本杀     │  →   │  小规模互动     │   →   │   多人互动      │
│  - 主播演绎      │      │  - 弹幕投票     │       │  - 多角色       │
│  - 观众观看      │      │  - 简单分支     │       │  - 礼物系统     │
│  - 积累粉丝      │      │  - 礼物影响     │       │  - 实时互动     │
└─────────────────┘      └─────────────────┘       └─────────────────┘

二、核心玩法设计

1. 基础互动机制

互动方式	触发条件	效果
弹幕投票	发送指定关键词	决定剧情走向
礼物加持	小礼物（1-10元）	给角色增加线索/道具
礼物惩罚	中礼物（10-50元）	增加恐怖元素/难度
剧情解锁	大礼物（50元以上）	解锁隐藏剧情线
弹幕猜凶	发送"凶手是XXX"	参与最终推理

2. 创新玩法建议

道具商店系统

观众可用礼物兑换虚拟道具
手电筒（照亮黑暗区域）
护身符（跳过一次惊吓）
通灵板（获取额外线索）

阵营对抗

观众分为"求生派"和"作死派"
两派通过礼物对抗决定主角命运
增加观众参与感和竞争性

成就系统

记录观众参与次数和贡献
设置粉丝等级和专属称号
高等级粉丝享有剧情建议权

三、变现模式

收入来源构成：
├── 礼物打赏（主要）────────── 60%
│   ├── 剧情互动礼物
│   ├── 道具购买礼物
│   └── 阵营对抗礼物
├── 粉丝团收入 ────────────── 15%
├── 广告植入 ──────────────── 10%
├── 剧本售卖 ──────────────── 10%
└── 周边商品 ──────────────── 5%

第二部分：恐怖剧本《镜中人》

剧本基本信息

时长：60分钟
类型：心理恐怖/悬疑推理
人数：单人演绎（后期可扩展）
难度：中等
结局数：4个

故事背景

你是一名刚搬进老旧公寓的年轻人。房东说这间房子已经空置三年，上一任租客在浴室的镜子前离奇死亡。你不信邪，却在搬进的第一晚发现——镜子里的自己，动作总是慢了半拍……

详细剧本脚本

【序章】入住（约5分钟）

场景：老旧公寓走廊 → 房间内部

画面：昏暗走廊，闪烁的灯光，门牌号"404"

AI旁白：

"2024年10月31日，晚上8点。
你拖着行李箱，站在这栋建于1980年代的公寓楼前。
房东说这里租金便宜，却没告诉你原因。
现在你知道了——404号房，三年前有人死在这里。
（停顿2秒）
但你不在乎。毕竟，死人不会说话。"

互动点1 [弹幕投票]

AI提示："你要先做什么？"
选项A：发送"检查"- 先检查房间
选项B：发送"休息"- 直接休息
（倒计时30秒，票数多的选项触发）

分支A - 检查房间：

画面切换：房间各处特写
- 客厅：落满灰尘的沙发
- 厨房：生锈的水龙头
- 卧室：一张老旧的单人床
- 浴室：一面巨大的落地镜

AI旁白："你注意到浴室的镜子异常干净，与周围的灰尘格格不入。镜子边缘似乎有些…刮痕？"

[获得线索：镜子刮痕]

分支B - 直接休息：

画面：快速过渡到床上
AI旁白："你太累了，倒头就睡。
半夜，一阵奇怪的声音把你吵醒——
是水龙头滴水的声音，来自浴室。"

[触发后续强制检查浴室]

【第一章】镜中异象（约12分钟）

场景：浴室

时间：凌晨3点

画面：浴室全景，镜子占据画面中心

AI旁白：

"你走进浴室，打开灯。
灯泡闪了几下才亮起，发出嗡嗡的电流声。
你看向镜子——
（停顿3秒，制造紧张感）
镜子里的你，看起来很正常。
但你总觉得哪里不对劲……"

[恐怖事件1] - 镜像延迟

画面：主角举起右手
镜子中的影像延迟0.5秒才跟着举起
（使用画中画效果制造不同步感）

AI旁白（低声）："你的手放下了，但镜子里的手……还举着。"

互动点2 [弹幕选择]

AI提示："你要怎么做？"
选项A：发送"靠近"- 凑近镜子查看
选项B：发送"离开"- 立刻离开浴室
选项C：发送"打碎"- 尝试打碎镜子

[礼物互动]
- 送"玫瑰"：镜中人会微笑（增加恐怖感）
- 送"啤酒"：主角获得勇气buff，可以多一个选项

分支A - 凑近镜子：

画面：镜子特写，逐渐拉近

AI旁白："你凑近镜子，呼出的气息在镜面上形成一层薄雾。
当雾气散去的瞬间——
（突然惊吓音效）
镜子里的你睁大了眼睛，但你确定自己没有动。"

[获得线索：镜中人有自主意识]
[恐惧值+10]

分支B - 离开浴室：

画面：转身离开的背影

AI旁白："你转身想离开，却感觉背后有目光在盯着你。
你加快脚步，几乎是逃出浴室。
关门的瞬间，你听到镜子里传来一声轻笑……"

[恐惧值+5]
[错过线索机会]

分支C - 打碎镜子（需要勇气buff）：

画面：拳头砸向镜子的慢动作

AI旁白："你的拳头砸向镜子——
但镜面像水面一样荡起涟漪，却没有碎裂。
你的手穿进了镜子里……
（惊吓音效）
有什么东西抓住了你的手腕！"

[获得关键线索：镜子是入口]
[恐惧值+20]
[触发隐藏剧情线]

【第一章续】调查（约10分钟）

场景：房间内 → 笔记本电脑前

AI旁白：

"你决定调查这间房子的历史。
打开笔记本，搜索'404号房 死亡事件'……"

画面：模拟网页界面

搜索结果展示：

新闻标题1：《女子在公寓浴室离奇死亡，死因不明》
新闻标题2：《404号房连续三任租客失踪，房东称纯属巧合》
新闻标题3：《心理学教授：镜子恐惧症或与童年创伤有关》

互动点3 [弹幕选择]

AI提示："你要查看哪条新闻？"
发送"1"、"2"或"3"选择对应新闻
（每条新闻提供不同线索）

新闻1内容：

画面：模拟新闻页面

"2021年11月2日
李某某（女，27岁）被发现死于某公寓404号房浴室内。
警方到达现场时，死者面朝镜子倒在地上，面部表情扭曲。
法医鉴定死因为心脏骤停，但死者并无心脏病史。
值得注意的是，现场镜子上留有死者指甲的刮痕……"

[获得线索：前任租客死亡细节]

新闻2内容：

画面：时间线信息图

"404号房历史：
2019年 - 租客A，住了3个月后搬走，称'总感觉有人在看自己'
2020年 - 租客B，住了2周后失踪，至今下落不明
2021年 - 租客C（李某某），入住第7天死亡
2021至今 - 空置"

AI旁白："你是第四个租客。今天是你入住的第一天……"

[获得线索：七天规律]

新闻3内容：

画面：学术文章界面

"镜子在许多文化中被视为连接阴阳两界的媒介。
古人相信，镜子能困住灵魂。
如果一个人在镜子前死去，他的灵魂可能会被困在镜中……"

[获得线索：镜子困魂]

【第二章】第二夜（约12分钟）

场景：卧室 → 浴室

时间：第二天凌晨

AI旁白：

"你强迫自己入睡，却在凌晨3点33分准时醒来。
（显示时钟画面）
浴室的灯亮着。
你确定睡前关掉了所有的灯……"

[恐怖事件2] - 镜中对话

画面：浴室门缝透出的光

你走向浴室，推开门——
镜子里的你正在对你微笑。

AI旁白（用不同的声音，模拟镜中人）：
"终于…又有人来了……"

互动点4 [关键对话选择]

AI提示："镜中人想和你说话，你要问什么？"

选项A：发送"你是谁"
选项B：发送"你想要什么"
选项C：发送"我该怎么逃"

[礼物互动]
- 送任意礼物满50元：解锁隐藏选项D"前任租客去哪了"

对话分支A - "你是谁"：

镜中人AI声音：
"我？我曾经是你。
或者说，我是住在这里的每一个人。
我们都困在镜子里了……
（画面闪过之前租客的面孔）
很快，你也会成为我们的一部分。"

[获得线索：镜中有多个灵魂]

对话分支B - "你想要什么"：

镜中人AI声音：
"我只想出去……
镜子里好黑，好冷……
（声音变得扭曲）
只要你进来，我就能出去。
公平交易，不是吗？"

[获得关键线索：替换机制]

对话分支C - "我该怎么逃"：

镜中人AI声音：
"逃？（笑声）
你以为那些人没试过吗？
（语气突然阴沉）
七天。你只有七天。
第七天的凌晨3点33分，镜子会来找你……
不管你在哪里。"

[获得关键线索：七天时限]
[解锁真相线索]

对话分支D - "前任租客去哪了"（隐藏）：

镜中人AI声音：
"他们都在这里……"
（镜子深处出现无数张脸，向外伸手）
"帮帮我们……打碎镜子……
不是普通的打碎……
要用……她的东西……"
（声音被干扰打断）

[获得关键线索：破解方法提示]
[解锁最佳结局路线]

【第二章续】寻找真相（约8分钟）

场景：房间内搜索 → 发现暗格

AI旁白：

"镜中人的话让你意识到，这件事的源头是第一个受害者。
你必须找到更多关于'她'的信息……"

画面：搜索房间各处的蒙太奇

互动点5 [弹幕搜索]

AI提示："帮助主角搜索房间，发送你想检查的位置"

可搜索位置：
- "床下" - 发现灰尘和一只耳环
- "衣柜" - 发现刻在木板上的日期
- "地板" - 发现一块松动的地板
- "墙壁" - 发现一处不自然的补丁

弹幕数量最多的位置会被详细搜索

[关键发现] - 地板暗格：

画面：撬开地板的特写

AI旁白：
"地板下有一个铁盒子……
里面是一本日记，和一面小型化妆镜。
日记的主人是——王美琳，这栋楼1980年代的住户。"

日记内容（画面配合泛黄纸张）：

1987年3月15日
搬进新家的第一天。这面落地镜是我的嫁妆，我很喜欢。

1987年4月2日
最近总觉得镜子里的自己在看着我。一定是我太累了。

1987年4月10日
我看见了。镜子里的我在动，但我没有动。我要把它封起来！

1987年4月15日
它不让我封。每次我想遮住镜子，它就会让我看到可怕的东西……
我受不了了。如果我进去，是不是就不会害怕了？

（最后一页染着褐色的污渍）

AI旁白：

"原来，这一切的源头是一面有问题的镜子被带进了这栋楼。
王美琳是第一个受害者，她的灵魂被困在镜中，开始捕猎新的猎物……
打破诅咒的方法，可能就与她有关。"

【第三章】最终对决（约10分钟）

场景：浴室

时间：第七天，凌晨3点

AI旁白：

"第七天到了。
你做好了准备——或者说，你以为自己准备好了。
浴室的镜子开始发出诡异的光芒……"

[恐怖事件3] - 镜子入侵

画面：镜子表面像液体一样波动

镜中人的声音：
"时间到了……
进来吧……
（无数只手从镜子里伸出）
和我们永远在一起……"

最终互动 [决定结局]

AI提示："最后的选择，你要怎么做？"

基于之前收集的线索，可用选项不同：

[选项出现条件]
A. "接受命运" - 始终可选
B. "打碎镜子" - 需要获得[镜子是入口]线索
C. "使用化妆镜" - 需要找到王美琳的化妆镜
D. "用她的名字" - 需要获得全部3条关键线索

[礼物决战]
此时观众可以通过礼物影响结果：
- "求生派"礼物：增加成功率
- "作死派"礼物：增加失败率
最终根据双方礼物总额决定成功与否

【结局】四种结局

结局A - 沉沦（Bad End）

条件：选择"接受命运"或礼物对决失败

画面：主角被拉入镜子的慢动作

AI旁白：
"你放弃了抵抗……
冰冷的手抓住你的脚踝，将你拖入镜子。
黑暗包围了你。
当你再次睁开眼睛，你发现自己站在镜子里，
看着下一个租客搬进来……

【沉沦结局】
你成为了镜中人的一部分。"

[结局CG：镜子里出现无数张脸，最外层是主角]

结局B - 逃离（Normal End）

条件：选择"打碎镜子"但未获得全部线索

画面：镜子碎裂，主角逃出公寓

AI旁白：
"你用尽全力砸碎了镜子！
玻璃四溅，尖叫声消失了……
你逃出了公寓，再也没有回去。

但有时候，在其他镜子里，
你会看到一个模糊的影子在对你招手……

【逃离结局】
诅咒没有被打破，只是暂时放过了你。"

[结局CG：主角站在街上，身后商店橱窗里有模糊身影]

结局C - 轮回（Hidden End）

条件：选择"使用化妆镜"

画面：化妆镜与落地镜产生共鸣

AI旁白：
"你举起王美琳的化妆镜对准落地镜——
两面镜子之间产生了奇异的通道。
王美琳的灵魂出现了……

'谢谢你……让我见到了自己最初的模样……
我可以安息了……但其他人……他们还困在里面……'

（化妆镜碎裂，王美琳消失）

【轮回结局】
你救出了王美琳，但镜中仍有无数灵魂在哭泣。"

[结局CG：破碎的化妆镜，碎片中映出王美琳微笑的脸]

结局D - 救赎（True End）

条件：收集全部线索+选择正确+礼物对决胜利

画面：主角面对镜子，说出关键台词

AI旁白：
"你举起化妆镜，大声喊出她的名字——
'王美琳！我以你之名，命令你释放所有灵魂！'

镜子发出刺眼的光芒——
无数光点从镜中升起，飘向天空。
那些被困的灵魂，终于得到了解脱。

当光芒散去，镜子变成了一面普通的玻璃。
你看到的，只有自己真实的倒影。

【救赎结局】
诅咒被打破了。"

[结局CG：阳光照进浴室，镜子反射出温暖的光]

【尾声】

根据结局播放不同的结尾画面

AI旁白：

"感谢各位观众的参与。
今晚的故事就到这里了。

获得结局：【显示结局名称】
收集线索：【X/5】
参与人数：【显示弹幕参与数】
最大贡献者：【显示礼物榜第一名】

下一期预告：《电梯里的第十三个人》
每周五晚8点，我们不见不散。"

第三部分：OBS配置详解

一、场景架构

OBS场景结构：
├── 【开场场景】
│   ├── 开场动画视频源
│   ├── 背景音乐
│   └── 倒计时文字
├── 【主场景-房间】
│   ├── 背景图层（房间图片）
│   ├── 特效图层（灯光闪烁）
│   ├── 字幕图层
│   ├── 弹幕显示区
│   └── 投票显示框
├── 【主场景-浴室】
│   ├── 背景图层（浴室图片）
│   ├── 镜子特效层
│   ├── 惊吓画面层
│   └── 音效触发层
├── 【主场景-对话】
│   ├── 对话框背景
│   ├── 角色立绘
│   ├── 文字区域
│   └── 选项按钮区
├── 【结局场景】×4
│   ├── 结局CG
│   ├── 结局音乐
│   └── 结语文字
└── 【过渡场景】
    ├── 转场动画
    └── Loading提示

二、详细配置步骤

1. 基础设置

【输出设置】
设置 → 输出 → 输出模式：高级
├── 编码器：x264 或 NVENC（有N卡选这个）
├── 比特率：4000-6000 Kbps
├── 关键帧间隔：2秒
└── CPU预设：veryfast

【视频设置】
设置 → 视频
├── 基础分辨率：1920×1080
├── 输出分辨率：1920×1080
├── 帧率：30 FPS
└── 缩放过滤：Lanczos

【音频设置】
设置 → 音频
├── 采样率：48kHz
├── 声道：立体声
└── 桌面音频：默认（播放音效用）

2. 场景源配置

背景图层设置：

添加 → 图像
├── 名称：背景-房间
├── 图像文件：选择对应场景图片
├── 勾选"当源不活跃时卸载图像"
└── 变换 → 拉伸到屏幕

滤镜设置（营造氛围）：
├── 添加 → 色彩校正
│   ├── 亮度：-0.1
│   ├── 对比度：0.1
│   └── 饱和度：-0.3（降低色彩制造阴暗感）
└── 添加 → 锐化：0.1

字幕图层设置：

添加 → 文本(GDI+)
├── 字体：思源黑体/微软雅黑
├── 字号：48
├── 颜色：白色
├── 勾选"轮廓"
│   ├── 颜色：黑色
│   └── 大小：4
├── 勾选"聊天模式"（文字逐行显示）
└── 对齐：居中

位置：屏幕下方1/4处
大小：宽度80%屏幕，高度自适应

弹幕显示区配置：

添加 → 浏览器
├── URL：弹幕姬网页地址（后面详述）
├── 宽度：400
├── 高度：600
├── 勾选"透明背景"
└── 自定义CSS（根据需要调整样式）

位置：屏幕右侧

3. 特效图层配置

灯光闪烁效果：

方法：使用多个图层叠加

图层1：正常亮度背景
图层2：暗色背景（亮度-0.5）

通过场景切换或图层可见性切换模拟闪烁
可以用Advanced Scene Switcher插件自动切换

镜子特效层（关键）：

添加 → 媒体源
├── 名称：镜子波纹
├── 视频文件：镜子波纹动画（透明背景）
├── 勾选"循环"
└── 不勾选"当隐藏时重新启动播放"

添加 → 图像
├── 名称：镜中人
├── 图像：处理过的恐怖人脸
└── 默认隐藏，触发时显示

组合这些层模拟镜子异象

惊吓画面层：

添加 → 媒体源
├── 名称：Jump Scare
├── 视频文件：惊吓视频（带音效）
├── 不勾选"循环"
├── 勾选"当隐藏时重新启动播放"
└── 勾选"播放结束后隐藏"

默认隐藏，通过热键触发

4. 热键配置

设置 → 热键

场景切换：
├── 切换到【开场场景】：F1
├── 切换到【房间场景】：F2
├── 切换到【浴室场景】：F3
├── 切换到【对话场景】：F4
└── 切换到【结局场景】：F5-F8

特效触发：
├── 显示/隐藏 惊吓画面：F9
├── 显示/隐藏 镜中人：F10
├── 播放 灯光闪烁：F11
└── 播放 特定音效：F12

注意：这些热键后期会通过脚本自动触发

三、高级插件配置

1. Advanced Scene Switcher（自动场景切换）

安装：OBS → 工具 → 脚本 → 下载 Advanced Scene Switcher

配置自动切换规则：
├── 媒体触发器：
│   └── 当"开场动画"播放结束 → 切换到"房间场景"
├── 时间触发器：
│   └── 每隔X秒检查弹幕投票结果
└── 文件触发器：
    └── 监控特定文件变化触发场景切换

2. Source Dock（源控制面板）

安装：OBS官方插件库下载

用途：在控制面板快速切换图层可见性
配置：将常用源（惊吓画面、镜中人等）添加到面板

3. OBS WebSocket

安装：从GitHub下载obs-websocket

用途：允许外部程序控制OBS
配置：
├── 工具 → WebSocket服务器设置
├── 启用WebSocket服务器
├── 服务器端口：4455（默认）
└── 设置密码（建议设置）

后续弹幕控制和AI语音系统将通过此接口控制OBS

第四部分：素材准备详解

一、视觉素材

1. 场景背景图

AI生成方式（推荐Midjourney/Stable Diffusion）：

Midjourney提示词示例：

【老旧公寓走廊】
"Creepy old apartment hallway, flickering lights, door number 404, 
1980s Chinese architecture, dim lighting, horror atmosphere, 
photorealistic, 8k, cinematic --ar 16:9 --v 6"

【浴室场景】
"Old Chinese apartment bathroom, large standing mirror, 
dim fluorescent light, wet tiles, horror movie scene, 
photorealistic, unsettling atmosphere --ar 16:9 --v 6"

【卧室场景】
"Abandoned apartment bedroom, old single bed, dusty furniture,
moonlight through window, Chinese 1990s style, creepy atmosphere,
photorealistic --ar 16:9 --v 6"

Stable Diffusion本地生成：

安装：从GitHub下载AUTOMATIC1111版本
模型推荐：Realistic Vision V5.1

提示词模板：
正向：场景描述 + "horror atmosphere, photorealistic, 8k, cinematic"
负向："cartoon, anime, bright colors, cheerful"

参数设置：
├── 采样器：DPM++ 2M Karras
├── 步数：30-50
├── CFG Scale：7-9
└── 分辨率：1920×1080

免费下载渠道：

1. Unsplash (https://unsplash.com)
   搜索：abandoned room, creepy hallway, old mirror
   
2. Pexels (https://www.pexels.com)
   搜索：horror scene, dark room, scary interior
   
3. Pixabay (https://pixabay.com)
   搜索：haunted house, creepy bathroom

下载后用Photoshop/GIMP调整色调使其统一

2. 角色立绘/镜中人图像

AI生成方法：

Midjourney提示词：

【正常状态】
"Portrait of a young Chinese person, casual clothes, 
neutral expression, soft lighting, waist up shot,
white background for easy cutout --ar 3:4 --v 6"

【镜中人-恐怖版】
"Same person but slightly distorted, unsettling smile,
pale skin, dark circles under eyes, horror movie style,
eerie lighting --ar 3:4 --v 6"

后期处理：
├── 使用Remove.bg去除背景
├── 用Photoshop添加裂纹、失真效果
└── 调整色调使其更加苍白阴暗

3. 特效动画素材

镜子波纹效果：

免费下载：
├── Mixkit (https://mixkit.co) - 搜索"water ripple"
├── Videvo (https://www.videvo.net) - 搜索"distortion"
└── Videezy (https://www.videezy.com) - 搜索"glitch"

处理方法：
1. 下载后用DaVinci Resolve打开
2. 去除背景（使用键控/抠像）
3. 调整颜色使其呈现幽绿/深蓝色调
4. 导出为WebM格式（支持透明背景）

惊吓画面：

制作方法（使用Canva/Photoshop）：
1. 准备一张恐怖面孔图片
2. 添加闪烁效果（快速切换黑白）
3. 添加噪点/失真效果
4. 导出为短视频（1-2秒）

免费素材网站：
├── Freepik (https://www.freepik.com) - 搜索"horror face"
└── 123RF免费区 - 搜索"scary portrait"

二、音频素材

1. 背景音乐

免费下载网站：

1. Incompetech (https://incompetech.com)
   推荐：Kevin MacLeod的恐怖类音乐（CC许可）
   搜索：horror, suspense, creepy

2. Freesound (https://freesound.org)
   搜索：ambient horror, dark atmosphere
   注意查看许可证类型

3. YouTube Audio Library
   筛选：恐怖/悬疑类别
   可商用，无需标注

AI生成音乐：

1. Suno AI (https://suno.ai)
   提示词："dark ambient horror music, suspenseful, 
           piano and strings, slow tempo, 5 minutes"

2. Stable Audio (https://stableaudio.com)
   提示词："horror movie soundtrack, tension building,
           orchestral, minor key"

导出后用Audacity调整音量和循环点

2. 音效

必备音效列表：

├── 环境音效
│   ├── 水滴声
│   ├── 老旧灯管电流声
│   ├── 门吱呀声
│   └── 风声/呼吸声
├── 恐怖音效
│   ├── Jump Scare音效（突然惊吓）
│   ├── 心跳声
│   ├── 低沉嗡鸣
│   └── 尖叫/笑声
└── UI音效
    ├── 选项出现音
    ├── 投票倒计时
    └── 结局揭晓音

获取方式：

免费网站：
1. Freesound.org - 最全面的免费音效库
2. Zapsplat (https://www.zapsplat.com) - 需注册
3. SoundBible (http://soundbible.com) - 部分免费

AI生成：
1. ElevenLabs Sound Effects
   描述你想要的音效，AI生成
   
2. AudioCraft by Meta（开源）
   本地部署，生成自定义音效

三、AI语音素材

1. TTS（文字转语音）系统选择

国内推荐方案：

1. 阿里云语音合成
   ├── 特点：中文效果好，有多种音色
   ├── 价格：有免费额度，超出按量计费
   └── API文档：https://ai.aliyun.com/nls

2. 讯飞开放平台
   ├── 特点：语音质量高，情感丰富
   ├── 价格：有免费额度
   └── 特色：支持SSML标记控制语音情感

3. 腾讯云语音合成
   ├── 特点：接入简单
   └── 价格：有免费额度

免费/开源方案：

1. Edge TTS（推荐）
   ├── 完全免费
   ├── 使用微软Azure的语音
   └── Python库：pip install edge-tts
   
   使用示例：
   import edge_tts
   import asyncio

   async def generate_voice(text, output_file):
       communicate = edge_tts.Communicate(text, "zh-CN-XiaoyiNeural")
       await communicate.save(output_file)

2. GPT-SoVITS（开源）
   ├── 可以克隆任意声音
   ├── 效果好但需要GPU
   └── GitHub上下载

3. VITS/Bert-VITS2
   ├── 开源TTS模型
   ├── 可以训练自己的音色
   └── 需要一定技术基础

2. 语音文件准备

根据剧本预先生成所有语音文件：

文件组织结构：
voice/
├── narrator/                 # 旁白语音
│   ├── prologue_01.mp3      # 序章第1段
│   ├── prologue_02.mp3      # 序章第2段
│   ├── chapter1_01.mp3      # 第一章第1段
│   └── ...
├── mirror_person/           # 镜中人语音
│   ├── dialogue_01.mp3
│   ├── dialogue_02.mp3
│   └── ...
├── system/                  # 系统提示音
│   ├── vote_start.mp3       # "投票开始"
│   ├── countdown_10.mp3     # "还剩10秒"
│   └── ...
└── endings/                 # 结局语音
    ├── ending_a.mp3
    ├── ending_b.mp3
    ├── ending_c.mp3
    └── ending_d.mp3

批量生成脚本示例（Edge TTS）：

pythonDownloadCopy codeimport edge_tts
import asyncio
import json# 语音内容配置文件scripts = {
    "prologue_01": "2024年10月31日，晚上8点。你拖着行李箱，站在这栋建于1980年代的公寓楼前。",
    "prologue_02": "房东说这里租金便宜，却没告诉你原因。",    # ... 更多内容}

async def batch_generate():
    for filename, text in scripts.items():
        communicate = edge_tts.Communicate(
            text, 
            "zh-CN-XiaoyiNeural",  # 女声
            rate="-10%",  # 语速稍慢
            pitch="-5Hz"  # 音调稍低，更有氛围
        )
        await communicate.save(f"voice/narrator/{filename}.mp3")
        print(f"Generated: {filename}")

asyncio.run(batch_generate())

第五部分：无人直播系统搭建

一、系统架构图

┌─────────────────────────────────────────────────────────────┐
│                      无人直播系统架构                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐ │
│  │   弹幕获取    │ →  │   弹幕解析    │ →  │   指令判断   │ │
│  │  (抖音/快手)  │    │ (关键词匹配)  │    │  (投票/礼物) │ │
│  └──────────────┘    └──────────────┘    └──────────────┘ │
│                                                    ↓        │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐ │
│  │   OBS推流    │ ←  │   OBS控制    │ ←  │   剧情引擎   │ │
│  │   (输出)     │    │ (WebSocket)  │    │   (核心)     │ │
│  └──────────────┘    └──────────────┘    └──────────────┘ │
│                              ↑                    ↓        │
│                      ┌──────────────┐    ┌──────────────┐ │
│                      │   音频播放    │ ←  │   语音合成   │ │
│                      │  (本地播放)   │    │  (Edge TTS)  │ │
│                      └──────────────┘    └──────────────┘ │
│                                                             │
└─────────────────────────────────────────────────────────────┘

二、核心模块代码

1. 弹幕获取模块

抖音弹幕获取（使用开源项目）：

pythonDownloadCopy code# 推荐使用: douyin-live（GitHub开源项目）# 安装: pip install douyin-livefrom douyin_live import DouyinLive

class DouyinDanmu:
    def __init__(self, room_id, callback):
        self.room_id = room_id
        self.callback = callback
        self.live = None
    
    async def start(self):
        self.live = DouyinLive(self.room_id)
        
        @self.live.on("chat")
        def on_chat(msg):            # msg包含：用户名、内容、等级等
            self.callback({
                "type": "chat",
                "user": msg.user.nickname,
                "content": msg.content
            })
        
        @self.live.on("gift")
        def on_gift(msg):
            self.callback({
                "type": "gift",
                "user": msg.user.nickname,
                "gift_name": msg.gift.name,
                "gift_value": msg.gift.diamond_count
            })
        
        await self.live.start()

快手弹幕获取：

pythonDownloadCopy code# 快手需要使用浏览器自动化方案# 推荐: playwright + 页面弹幕捕获from playwright.async_api import async_playwright
import asyncio

class KuaishouDanmu:
    def __init__(self, room_url, callback):
        self.room_url = room_url
        self.callback = callback
    
    async def start(self):
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=True)
            page = await browser.new_page()
            await page.goto(self.room_url)            
            # 监听弹幕DOM变化
            await page.evaluate('''
                const observer = new MutationObserver((mutations) => {
                    mutations.forEach((mutation) => {
                        mutation.addedNodes.forEach((node) => {
                            if (node.classList && node.classList.contains('comment-item')) {
                                // 发送弹幕数据到Python
                                window.danmuCallback(node.textContent);
                            }
                        });
                    });
                });
                observer.observe(document.querySelector('.comment-list'), 
                    { childList: true });
            ''')            
            # 保持运行
            while True:
                await asyncio.sleep(1)

2. 剧情引擎模块

pythonDownloadCopy codeimport json
import asyncio
from enum import Enum
from dataclasses import dataclass
from typing import Dict, List, Callable, Optional

class SceneType(Enum):
    NARRATIVE = "narrative"      # 叙事场景
    CHOICE = "choice"            # 选择场景
    VOTE = "vote"                # 投票场景
    GIFT_BATTLE = "gift_battle"  # 礼物对决@dataclass
class Choice:
    keyword: str          # 触发关键词
    description: str      # 选项描述
    next_scene: str       # 下一场景ID
    required_clue: str = None  # 需要的线索（可选）@dataclass
class Scene:
    id: str
    type: SceneType
    background: str       # 背景图片/OBS场景名
    voice_file: str       # 语音文件路径
    text: str             # 显示文字
    duration: int         # 场景持续时间（秒）
    choices: List[Choice] = None
    vote_time: int = 30   # 投票时间
    next_scene: str = None  # 下一场景（非选择场景）
    effects: List[str] = None  # 特效列表
    clue_reward: str = None  # 获得的线索class StoryEngine:
    def __init__(self):
        self.scenes: Dict[str, Scene] = {}
        self.current_scene: str = None
        self.player_clues: List[str] = []
        self.fear_level: int = 0
        self.vote_results: Dict[str, int] = {}
        self.gift_battle: Dict[str, int] = {"survive": 0, "die": 0}        
        # 回调函数
        self.on_scene_change: Callable = None
        self.on_play_voice: Callable = None
        self.on_show_choices: Callable = None
        self.on_trigger_effect: Callable = None
        
    def load_story(self, story_file: str):
        """加载剧本JSON文件"""
        with open(story_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        for scene_data in data['scenes']:
            choices = None
            if 'choices' in scene_data:
                choices = [Choice(**c) for c in scene_data['choices']]
            
            scene = Scene(
                id=scene_data['id'],
                type=SceneType(scene_data['type']),
                background=scene_data['background'],
                voice_file=scene_data['voice_file'],
                text=scene_data['text'],
                duration=scene_data.get('duration', 10),
                choices=choices,
                vote_time=scene_data.get('vote_time', 30),
                next_scene=scene_data.get('next_scene'),
                effects=scene_data.get('effects', []),
                clue_reward=scene_data.get('clue_reward')
            )
            self.scenes[scene.id] = scene
    
    async def start(self, start_scene: str = "prologue"):
        """开始剧本"""
        self.current_scene = start_scene
        await self._play_scene(self.scenes[start_scene])
    
    async def _play_scene(self, scene: Scene):
        """播放场景"""        # 切换OBS场景/背景
        if self.on_scene_change:
            await self.on_scene_change(scene.background)        
        # 触发特效
        if scene.effects:
            for effect in scene.effects:
                if self.on_trigger_effect:
                    await self.on_trigger_effect(effect)        
        # 播放语音
        if self.on_play_voice:
            await self.on_play_voice(scene.voice_file, scene.text)        
        # 等待语音播放完成
        await asyncio.sleep(scene.duration)        
        # 记录线索
        if scene.clue_reward:
            self.player_clues.append(scene.clue_reward)        
        # 根据场景类型处理后续
        if scene.type == SceneType.NARRATIVE:            # 叙事场景：直接进入下一场景
            if scene.next_scene:
                await self._play_scene(self.scenes[scene.next_scene])
                
        elif scene.type == SceneType.CHOICE:            # 选择场景：等待投票
            await self._handle_choice(scene)
            
        elif scene.type == SceneType.VOTE:            # 投票场景：开启投票
            await self._handle_vote(scene)
            
        elif scene.type == SceneType.GIFT_BATTLE:            # 礼物对决场景
            await self._handle_gift_battle(scene)
    
    async def _handle_choice(self, scene: Scene):
        """处理选择场景"""        # 显示可用选项
        available_choices = []
        for choice in scene.choices:
            if choice.required_clue is None or choice.required_clue in self.player_clues:
                available_choices.append(choice)
        
        if self.on_show_choices:
            await self.on_show_choices(available_choices)        
        # 重置投票
        self.vote_results = {c.keyword: 0 for c in available_choices}        
        # 等待投票时间
        await asyncio.sleep(scene.vote_time)        
        # 统计投票结果
        winner = max(self.vote_results, key=self.vote_results.get)        
        # 找到对应选项
        for choice in available_choices:
            if choice.keyword == winner:
                await self._play_scene(self.scenes[choice.next_scene])
                break
    
    async def _handle_gift_battle(self, scene: Scene):
        """处理礼物对决"""        # 重置礼物统计
        self.gift_battle = {"survive": 0, "die": 0}        
        # 等待对决时间
        await asyncio.sleep(scene.vote_time)        
        # 判断结果
        if self.gift_battle["survive"] >= self.gift_battle["die"]:            # 存活
            await self._play_scene(self.scenes["ending_good"])
        else:            # 死亡
            await self._play_scene(self.scenes["ending_bad"])
    
    def process_danmu(self, content: str, user: str):
        """处理弹幕"""
        content = content.lower().strip()        
        # 检查是否为投票关键词
        if content in self.vote_results:
            self.vote_results[content] += 1
    
    def process_gift(self, gift_name: str, gift_value: int, user: str):
        """处理礼物"""        # 根据礼物类型判断阵营
        survive_gifts = ["玫瑰", "小心心", "加油"]
        die_gifts = ["墓碑", "幽灵", "骷髅"]
        
        if gift_name in survive_gifts:
            self.gift_battle["survive"] += gift_value
        elif gift_name in die_gifts:
            self.gift_battle["die"] += gift_value

3. OBS控制模块

pythonDownloadCopy codeimport obsws_python as obs
import asyncio

class OBSController:
    def __init__(self, host="localhost", port=4455, password=""):
        self.host = host
        self.port = port
        self.password = password
        self.client = None
    
    def connect(self):
        """连接OBS WebSocket"""
        self.client = obs.ReqClient(
            host=self.host,
            port=self.port,
            password=self.password
        )
    
    def disconnect(self):
        """断开连接"""
        if self.client:
            self.client.disconnect()
    
    def switch_scene(self, scene_name: str):
        """切换场景"""
        self.client.set_current_program_scene(scene_name)
    
    def set_source_visibility(self, scene_name: str, source_name: str, visible: bool):
        """设置源可见性"""
        self.client.set_scene_item_enabled(
            scene_name=scene_name,
            item_id=self._get_source_id(scene_name, source_name),
            enabled=visible
        )
    
    def _get_source_id(self, scene_name: str, source_name: str) -> int:
        """获取源ID"""
        items = self.client.get_scene_item_list(scene_name).scene_items
        for item in items:
            if item['sourceName'] == source_name:
                return item['sceneItemId']
        return -1
    
    def set_text(self, source_name: str, text: str):
        """设置文字内容"""
        self.client.set_input_settings(
            source_name,
            {"text": text},
            overlay=True
        )
    
    def play_media(self, source_name: str):
        """播放媒体"""
        self.client.trigger_media_input_action(
            source_name,
            "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART"
        )
    
    def trigger_effect(self, effect_name: str):
        """触发特效"""        # 根据特效类型执行不同操作
        effects = {
            "jumpscare": lambda: self._play_jumpscare(),
            "flicker": lambda: self._trigger_flicker(),
            "mirror_ripple": lambda: self._show_mirror_effect(),
        }
        
        if effect_name in effects:
            effects[effect_name]()
    
    def _play_jumpscare(self):
        """播放惊吓画面"""
        self.set_source_visibility("主场景", "惊吓画面", True)        # 2秒后自动隐藏（通过OBS媒体源设置）
    
    def _trigger_flicker(self):
        """触发闪烁效果"""        # 快速切换图层可见性
        import threading
        def flicker():
            for _ in range(6):
                self.set_source_visibility("主场景", "暗色图层", True)
                import time
                time.sleep(0.1)
                self.set_source_visibility("主场景", "暗色图层", False)
                time.sleep(0.1)
        
        threading.Thread(target=flicker).start()
    
    def _show_mirror_effect(self):
        """显示镜子特效"""
        self.set_source_visibility("浴室场景", "镜子波纹", True)

4. 语音播放模块

pythonDownloadCopy codeimport edge_tts
import asyncio
import pygame
import os

class VoicePlayer:
    def __init__(self, voice_folder: str = "voice"):
        self.voice_folder = voice_folder
        self.current_voice = "zh-CN-XiaoyiNeural"  # 默认女声
        pygame.mixer.init()
    
    async def play_pregenerated(self, filename: str):
        """播放预生成的语音"""
        filepath = os.path.join(self.voice_folder, filename)
        if os.path.exists(filepath):
            pygame.mixer.music.load(filepath)
            pygame.mixer.music.play()
            while pygame.mixer.music.get_busy():
                await asyncio.sleep(0.1)
    
    async def speak_realtime(self, text: str, emotion: str = "normal"):
        """实时生成并播放语音"""        # 根据情感调整语音参数
        voice_params = {
            "normal": {"rate": "-5%", "pitch": "+0Hz"},
            "scary": {"rate": "-15%", "pitch": "-10Hz"},
            "urgent": {"rate": "+10%", "pitch": "+5Hz"},
            "whisper": {"rate": "-20%", "pitch": "-5Hz", "volume": "-20%"}
        }
        
        params = voice_params.get(emotion, voice_params["normal"])        
        # 生成临时文件
        temp_file = "temp_voice.mp3"
        communicate = edge_tts.Communicate(
            text,
            self.current_voice,
            rate=params.get("rate", "+0%"),
            pitch=params.get("pitch", "+0Hz")
        )
        await communicate.save(temp_file)        
        # 播放
        pygame.mixer.music.load(temp_file)
        pygame.mixer.music.play()
        while pygame.mixer.music.get_busy():
            await asyncio.sleep(0.1)        
        # 删除临时文件
        os.remove(temp_file)
    
    def set_voice(self, voice_name: str):
        """切换语音角色"""
        voices = {
            "narrator": "zh-CN-XiaoyiNeural",      # 女性旁白
            "mirror_person": "zh-CN-YunxiNeural",   # 镜中人（男性，略恐怖）
            "system": "zh-CN-XiaochenNeural"        # 系统提示
        }
        self.current_voice = voices.get(voice_name, self.current_voice)
    
    def play_sound_effect(self, effect_name: str):
        """播放音效"""
        effects = {
            "heartbeat": "sfx/heartbeat.mp3",
            "door_creak": "sfx/door_creak.mp3",
            "water_drop": "sfx/water_drop.mp3",
            "jumpscare": "sfx/jumpscare.mp3",
            "whisper": "sfx/whisper.mp3"
        }
        
        if effect_name in effects:
            sound = pygame.mixer.Sound(effects[effect_name])
            sound.play()

5. 主控制程序

pythonDownloadCopy codeimport asyncio
import json
from story_engine import StoryEngine
from obs_controller import OBSController
from voice_player import VoicePlayer
from danmu_handler import DouyinDanmu  # 或 KuaishouDanmuclass LiveController:
    def __init__(self, config_file: str = "config.json"):        # 加载配置
        with open(config_file, 'r', encoding='utf-8') as f:
            self.config = json.load(f)        
        # 初始化各模块
        self.story = StoryEngine()
        self.obs = OBSController(
            host=self.config['obs']['host'],
            port=self.config['obs']['port'],
            password=self.config['obs']['password']
        )
        self.voice = VoicePlayer(self.config['voice_folder'])
        self.danmu = None        
        # 设置回调
        self.story.on_scene_change = self._on_scene_change
        self.story.on_play_voice = self._on_play_voice
        self.story.on_show_choices = self._on_show_choices
        self.story.on_trigger_effect = self._on_trigger_effect
    
    async def start(self):
        """启动直播"""        # 连接OBS
        self.obs.connect()        
        # 加载剧本
        self.story.load_story(self.config['story_file'])        
        # 启动弹幕监听
        self.danmu = DouyinDanmu(
            room_id=self.config['room_id'],
            callback=self._on_danmu
        )        
        # 并行运行
        await asyncio.gather(
            self.danmu.start(),
            self.story.start("prologue")
        )
    
    def _on_danmu(self, data: dict):
        """处理弹幕回调"""
        if data['type'] == 'chat':
            self.story.process_danmu(data['content'], data['user'])
        elif data['type'] == 'gift':
            self.story.process_gift(
                data['gift_name'],
                data['gift_value'],
                data['user']
            )
    
    async def _on_scene_change(self, scene_name: str):
        """场景切换回调"""
        self.obs.switch_scene(scene_name)
    
    async def _on_play_voice(self, voice_file: str, text: str):
        """播放语音回调"""        # 同时显示字幕
        self.obs.set_text("字幕", text)        
        # 播放语音
        await self.voice.play_pregenerated(voice_file)
    
    async def _on_show_choices(self, choices: list):
        """显示选项回调"""        # 构建选项文字
        choice_text = "请发送弹幕选择：\n"
        for c in choices:
            choice_text += f"【{c.keyword}】{c.description}\n"        
        # 显示选项
        self.obs.set_text("选项文字", choice_text)
        self.obs.set_source_visibility("主场景", "选项框", True)        
        # 播放提示音
        await self.voice.speak_realtime(
            f"请发送弹幕选择，投票时间30秒",
            emotion="normal"
        )
    
    async def _on_trigger_effect(self, effect_name: str):
        """触发特效回调"""
        self.obs.trigger_effect(effect_name)        
        # 某些特效需要配合音效
        effect_sounds = {
            "jumpscare": "jumpscare",
            "mirror_ripple": "whisper",
            "flicker": "electricity"
        }
        if effect_name in effect_sounds:
            self.voice.play_sound_effect(effect_sounds[effect_name])# 启动入口if __name__ == "__main__":
    controller = LiveController("config.json")
    asyncio.run(controller.start())

三、配置文件模板

config.json：

jsonDownloadCopy code{
    "obs": {
        "host": "localhost",
        "port": 4455,
        "password": "your_password"
    },
    "room_id": "your_douyin_room_id",
    "platform": "douyin",
    "story_file": "stories/mirror_person.json",
    "voice_folder": "voice",
    "settings": {
        "vote_duration": 30,
        "gift_battle_duration": 60,
        "subtitle_speed": 50
    }
}

stories/mirror_person.json（剧本配置）：

jsonDownloadCopy code{
    "title": "镜中人",
    "author": "Your Name",
    "duration": 60,
    "scenes": [
        {
            "id": "prologue",
            "type": "narrative",
            "background": "走廊场景",
            "voice_file": "narrator/prologue_01.mp3",
            "text": "2024年10月31日，晚上8点...",
            "duration": 15,
            "next_scene": "choice_first"
        },
        {
            "id": "choice_first",
            "type": "choice",
            "background": "房间场景",
            "voice_file": "narrator/choice_01.mp3",
            "text": "你要先做什么？",
            "duration": 5,
            "vote_time": 30,
            "choices": [
                {
                    "keyword": "检查",
                    "description": "先检查房间",
                    "next_scene": "check_room"
                },
                {
                    "keyword": "休息",
                    "description": "直接休息",
                    "next_scene": "rest_first"
                }
            ]
        }        // ... 更多场景
    ]
}

第六部分：部署清单与成本估算

一、硬件需求

设备	最低配置	推荐配置	参考价格
电脑CPU	i5-10400	i7-12700	￥1000-2500
内存	16GB	32GB	￥300-600
显卡	GTX 1060	RTX 3060	￥1500-2500
硬盘	256GB SSD	512GB SSD	￥200-400
网络	50Mbps上行	100Mbps上行	按月付费

二、软件需求

软件	用途	价格
OBS Studio	直播推流	免费
Python 3.10+	运行控制程序	免费
Edge TTS	语音合成	免费
Stable Diffusion	AI绘图	免费（本地部署）
Audacity	音频编辑	免费
DaVinci Resolve	视频编辑	免费版够用

三、API服务（可选）

服务	用途	价格
阿里云语音	高质量TTS	免费额度后按量
Midjourney	AI绘图	$10-30/月
云服务器	24小时运行	￥50-200/月

四、启动检查清单

启动前检查：
□ OBS场景配置完成
□ 所有背景图片就位
□ 语音文件全部生成
□ 音效文件准备完成
□ 剧本JSON配置无误
□ OBS WebSocket已启用
□ 弹幕获取测试通过
□ 网络上行带宽充足
□ 备用方案准备（手动切换热键）

总结

这个方案为你提供了从0到1搭建剧本杀直播的完整路径。建议按以下步骤执行：

第一周：准备素材（背景图、音效、语音）
第二周：配置OBS，测试基础直播
第三周：开发控制程序，实现弹幕互动
第四周：整合测试，优化细节
第五周：正式上线，收集反馈