编辑代码

// ==UserScript==
// @name         修仙世界
// @author       莫一&流溪%市面上的各大ai
// @version      1.6.0
// @description  可使用.修仙帮助 查看对应指令，差点写死，有bug的话随缘修，每次安装新版本可能导致正在进行的修仙/打工/双修等被重置，如果出现bug，只需要使用强制结束指令即可恢复
// @timestamp    2025-04-05
// @update       2025-04-09
// @license      MIT
// ==/UserScript==

if (!seal.ext.find('修仙世界')) {
    const ext = seal.ext.new('修仙世界', '莫一&流溪%市面上的各大ai', '1.4.0');
    seal.ext.register(ext);

    // 初始化存储数据（保留此处声明）
    let userData = JSON.parse(ext.storageGet("userData") || "{}");
    let lastActionTime = JSON.parse(ext.storageGet("lastActionTime") || "{}");
    let signInData = JSON.parse(ext.storageGet("signInData") || "{}");
    let userActionStatus = JSON.parse(ext.storageGet("userActionStatus") || "{}"); 
    let earlyEndCount = JSON.parse(ext.storageGet("earlyEndCount") || "{}"); 
    let forcedBreakthroughCount = JSON.parse(ext.storageGet("forcedBreakthroughCount") || "{}");
    let lastActionResult = JSON.parse(ext.storageGet("lastActionResult") || "{}");
    let crimeValue = JSON.parse(ext.storageGet("crimeValue") || "{}");
    let jailTime = JSON.parse(ext.storageGet("jailTime") || "{}");
    let jailCount = JSON.parse(ext.storageGet("jailCount") || "{}");
    let bondData = JSON.parse(ext.storageGet("bondData") || "{}");
    let forceEndUsedDate = JSON.parse(ext.storageGet("forceEndUsedDate") || "{}");
    let forceEndUsedCount = JSON.parse(ext.storageGet("forceEndUsedCount") || "{}");
    const doubleCultivationTimeoutIds = {};
    const invitationTimeoutIds = {};
    const eventDecks = {
        jailRelease: "出狱事件",
        cultivateEnd: "修仙结束事件",
        workEnd: "打工结束事件",
        doubleCultivateEnd: "双修结束事件",
        alchemyEnd: "炼丹结束事件"
      };

      // 添加通用牌堆抽取函数
function drawEventDeck(ctx, msg, deckName) {
    const result = seal.deck.draw(ctx, deckName, true);
    if (result.err) {
      return `\n（未找到 ${deckName} 事件牌堆）`;
    }
    return `\n〖${deckName}〗\n${result.result}`;
  }

    // 境界等级划分
    const realmLevels = [
        { name: "凡人", min: 0, max: 0 },
        { name: "炼气期", min: 1, max: 500 },
        { name: "筑基期", min: 501, max: 1000 },
        { name: "金丹期", min: 1001, max: 1500 },
        { name: "元婴期", min: 1501, max: 2000 },
        { name: "化神期", min: 2001, max: 2500 },
        { name: "炼虚期", min: 2501, max: 3000 },
        { name: "合体期", min: 3001, max: 3500 },
        { name: "渡劫期", min: 3501, max: 4000 },
        { name: "真神", min: 4001, max: Infinity }
    ];

    // 获取羁绊阶段
    function getBondStage(bond) {
        if (bond <= 100) return "只如初见";
        if (bond <= 250) return "却上心头";
        if (bond <= 520) return "朝思暮想";
        if (bond <= 800) return "一往情深";
        if (bond <= 1000) return "花前月下";
        if (bond <= 1314) return "两心相许";
        if (bond <= 2000) return "鸾凤和鸣";
        return "情定三生";
    }

    // 新增获取羁绊值键名函数
    function getBondKey(uid1, uid2) {
        return [uid1, uid2].sort().join('-');
    }

    // 获取当前境界
    function getCurrentRealm(cultivation) {
        return realmLevels.find(level => cultivation >= level.min && cultivation <= level.max);
    }

    // 检查是否在监狱中
    function checkInJail(uid) {
        return jailTime[uid] && Date.now() < jailTime[uid];
    }

    // 检查用户是否已加入修真界
    function checkUserJoined(ctx, msg) {
        const uid = ctx.player.userId.toString();
        if (!userData[uid]) {
            seal.replyToSender(ctx, msg, "船员名单并没有你的名字。请使用【踏上茶壶号】指令上船。");
            return false;
        }
        return true;
    }

    // 获取到午夜的时间
    function getTimeToMidnight() {
        const now = new Date();
        const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 0);
        return midnight - now;
    }

    // 检查是否正在双修
    function checkDoubleCultivating(uid) {
        return userActionStatus[uid] === 'doubleCultivating';
    }

    // 检查并通知出狱
    function checkAndNotifyRelease() {
        const now = Date.now();
        for (const uid in jailTime) {
            if (jailTime[uid] <= now) {
                delete jailTime[uid];
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                // 添加模拟上下文参数
                const mockCtx = {
                    group: {
                        groupId: ctx.group.groupId // 使用当前群组上下文
                    }
                };
                const mockMsg = {
                    messageType: 'group',
                    groupId: ctx.group.groupId
                };
                const userMention = `[CQ:at,qq=${uid.replace("QQ:","")}]`;
                const deckResult = drawEventDeck(mockCtx, mockMsg, eventDecks.jailRelease);
                const message = `${userMention} 已经出狱\n${deckResult}`;
                seal.replyToSender(mockCtx, mockMsg, message);
            }
        }
    }

    // 重置签到数据
    function resetSignInData() {
        for (const uid in signInData) {
            signInData[uid] = null;
        }
        ext.storageSet("signInData", JSON.stringify(signInData));
    }

    // 定时器逻辑
    const timeToMidnight = getTimeToMidnight();
    setTimeout(() => {
        resetSignInData();
        checkAndNotifyRelease(); // 检查是否有用户该出狱
        setInterval(() => {
            resetSignInData();
            checkAndNotifyRelease(); // 每天定时检查
        }, 24 * 60 * 60 * 1000);
    }, timeToMidnight);

    // 加入茶壶号指令
    function solveJoin(ctx, msg) {
        const uid = ctx.player.userId.toString();
        if (!userData[uid]) {
            userData[uid] = {
                name: ctx.player.name,
                cultivation: 0,
                spiritStones: 0,
                realmIndex: 0,
                cultivationDays: 0,
                items: {} 
            };
            signInData[uid] = null;
            ext.storageSet("signInData", JSON.stringify(signInData));
            ext.storageSet("userData", JSON.stringify(userData));
            seal.replyToSender(ctx, msg, `欢迎${ctx.player.name}踏上茶壶号，让海洋与你同在。`);
        } else {
            seal.replyToSender(ctx, msg, "……你不是已经在船上了么。");
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdJoin = seal.ext.newCmdItemInfo();
    cmdJoin.name = "踏入茶壶号";
    cmdJoin.solve = solveJoin;

    // 每日签到指令
    function solveSignIn(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const today = new Date().toDateString();
        if (signInData[uid] === today) {
            seal.replyToSender(ctx, msg, "今日已签到。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const stones = Math.floor(Math.random() * 100) + 1;
        userData[uid].spiritStones += stones;
        userData[uid].cultivationDays++;
        signInData[uid] = today;
        ext.storageSet("userData", JSON.stringify(userData));
        ext.storageSet("signInData", JSON.stringify(signInData));
        seal.replyToSender(ctx, msg, `签到成功了。这是今天的玛门币：共${stones}个，您当前总数：${userData[uid].spiritStones}\n登船天数：${userData[uid].cultivationDays}`);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdSignIn = seal.ext.newCmdItemInfo();
    cmdSignIn.name = "登船每日报道";
    cmdSignIn.solve = solveSignIn;

    // 提前结束指令
    const cultivateTimeoutIds = {};
    const workTimeoutIds = {};

    function solveEarlyEnd(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const now = Date.now();
        // 定义 today 变量
        const today = new Date().toDateString(); 
        if (!userActionStatus[uid]) {
            seal.replyToSender(ctx, msg, "当前没有正在进行的操作，无需提前结束。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (userActionStatus[uid] === 'doubleCultivating') {
            seal.replyToSender(ctx, msg, "游历不可提前结束，请耐心等待。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (lastActionTime[uid] && now - lastActionTime[uid] < 1800000) {
            if (!earlyEndCount[uid]) {
                earlyEndCount[uid] = {};
            }
            if (!earlyEndCount[uid][today]) {
                earlyEndCount[uid][today] = 0;
            }
            if (earlyEndCount[uid][today] >= 3) {
                seal.replyToSender(ctx, msg, "今天已经提前结束过三次了...专心一点好不好？");
                return seal.ext.newCmdExecuteResult(true);
            }
            earlyEndCount[uid][today]++;
            ext.storageSet("earlyEndCount", JSON.stringify(earlyEndCount));
        }
        if (userActionStatus[uid] === 'cultivating') {
            clearTimeout(cultivateTimeoutIds[uid]);
            const diceValue = Math.floor(Math.random() * 100) + 1;
            const SUCCESS_RATE = 50;
            const success = diceValue <= SUCCESS_RATE;
            let increase = 0;
            if (success) {
                increase = Math.floor(Math.random() * 50) + 1;
                userData[uid].cultivation += increase;
            }
            userActionStatus[uid] = null;
            lastActionTime[uid] = null;
            ext.storageSet("userData", JSON.stringify(userData));
            ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
            ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
            lastActionResult[uid] = {
                action: 'cultivating',
                increase: increase
            };
            ext.storageSet("lastActionResult", JSON.stringify(lastActionResult));
            if (success) {
                seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】\n挑灯夜读偶尔也偷个懒，获得了 ${increase} 点知识，当前知识：${userData[uid].cultivation}`);
            } else {
                seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】\n三心二意可不好，很遗憾未获得知识点提升，当前知识：${userData[uid].cultivation}`);
            }
        } else if (userActionStatus[uid] === 'working') {
            clearTimeout(workTimeoutIds[uid]);
            const diceValue = Math.floor(Math.random() * 100) + 1;
            const SUCCESS_RATE = 50;
            const success = diceValue <= SUCCESS_RATE;
            let increase = 0;
            if (success) {
                increase = Math.floor(Math.random() * 50) + 1;
                userData[uid].spiritStones += increase;
            }
            userActionStatus[uid] = null;
            lastActionTime[uid] = null;
            ext.storageSet("userData", JSON.stringify(userData));
            ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
            ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
            lastActionResult[uid] = {
                action: 'working',
                increase: increase
            };
            ext.storageSet("lastActionResult", JSON.stringify(lastActionResult));
            if (success) {
                seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】\n提前结束工作成功，未被船长抓住，获得了 ${increase} 个玛门币，当前玛门币数量：${userData[uid].spiritStones}`);
            } else {
                seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】\n提前结束工作，被船长抓住了，天道好轮回啊，工资也没有咯。当前玛门币数量：${userData[uid].spiritStones}`);
            }
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdEarlyEnd = seal.ext.newCmdItemInfo();
    cmdEarlyEnd.name = "提前结束";
    cmdEarlyEnd.solve = solveEarlyEnd;

    // 开始修仙指令
    function solveCultivate(ctx, msg) {
    if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
    const uid = ctx.player.userId.toString();
    if (checkInJail(uid)) {
        seal.replyToSender(ctx, msg, "被教会的人扣押了……无法开始课业。");
        return seal.ext.newCmdExecuteResult(true);
    }
    if (checkDoubleCultivating(uid)) {
        seal.replyToSender(ctx, msg, "正在外游历中，无法开始课业。");
        return seal.ext.newCmdExecuteResult(true);
    }
    if (userActionStatus[uid] === 'cultivating' || userActionStatus[uid] === 'working' || userActionStatus[uid] === 'alchemy') {
        seal.replyToSender(ctx, msg, "正在进行其他行动，结束后才能开始课业。");
        return seal.ext.newCmdExecuteResult(true);
    }
    const now = Date.now();
    if (lastActionTime[uid] && now - lastActionTime[uid] < 1800000) {
        seal.replyToSender(ctx, msg, "正在进行其他行动，半个小时后再来吧");
        return seal.ext.newCmdExecuteResult(true);
    }
    lastActionTime[uid] = now;
    userActionStatus[uid] = 'cultivating';
    ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
    const timeoutId = setTimeout(() => {
        const increase = Math.floor(Math.random() * 500) + 1;
        userData[uid].cultivation += increase;
        ext.storageSet("userData", JSON.stringify(userData));
        userActionStatus[uid] = null;
        ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
        lastActionResult[uid] = {
            action: 'cultivating',
            increase: increase
        };
        ext.storageSet("lastActionResult", JSON.stringify(lastActionResult));
        const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
        // 修复：定义 deckResult 变量
        const deckResult = drawEventDeck(ctx, msg, eventDecks.cultivateEnd);
        const message = `${userMention} 你的学习已结束。寒窗苦读三年书，金榜题名美人归。这句话在海上也适用吗？获得了 ${increase} 点知识点，当前知识点：${userData[uid].cultivation}\n${deckResult}`;
        seal.replyToSender(ctx, msg, message);
    }, 1800000);
    cultivateTimeoutIds[uid] = timeoutId;
    seal.replyToSender(ctx, msg, `又来读书了么？还真是勤奋，半个小时后即可结束`);
    return seal.ext.newCmdExecuteResult(true);
}

    const cmdCultivate = seal.ext.newCmdItemInfo();
    cmdCultivate.name = "开始学习";
    cmdCultivate.solve = solveCultivate;

    // 开始打工指令
    function solveWork(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        if (checkDoubleCultivating(uid)) {
            seal.replyToSender(ctx, msg, "正在游历中，无法开始工作。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (userActionStatus[uid] === 'working' || userActionStatus[uid] === 'cultivating' || userActionStatus[uid] === 'alchemy') {
            seal.replyToSender(ctx, msg, "正在进行其他行动，结束后才能开始工作。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const now = Date.now();
        if (lastActionTime[uid] && now - lastActionTime[uid] < 1800000) {
            seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，半个小时后再来打工吧");
            return seal.ext.newCmdExecuteResult(true);
        }
        lastActionTime[uid] = now;
        userActionStatus[uid] = 'working';
        ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
        const timeoutId = setTimeout(() => {
            const increase = Math.floor(Math.random() * 500) + 1;
            userData[uid].spiritStones += increase;
            ext.storageSet("userData", JSON.stringify(userData));
            userActionStatus[uid] = null;
            ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
            lastActionResult[uid] = {
                action: 'working',
                increase: increase
            };
            ext.storageSet("lastActionResult", JSON.stringify(lastActionResult));
            const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
            const deckResult = drawEventDeck(ctx, msg, eventDecks.workEnd);
            const message = `${userMention} 您的打工已结束，恭喜您获得了 ${increase} 个灵石，当前灵石数量：${userData[uid].spiritStones}\n${deckResult}`;
            seal.replyToSender(ctx, msg, message);
        }, 1800000);
        workTimeoutIds[uid] = timeoutId;
        seal.replyToSender(ctx, msg, `前辈，又来工作了么？半个小时后记得来领取报酬。`);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdWork = seal.ext.newCmdItemInfo();
    cmdWork.name = "开始打工";
    cmdWork.solve = solveWork;

    // 修仙排行榜指令
    function solveRankCultivation(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const sorted = Object.entries(userData).sort((a, b) => b[1].cultivation - a[1].cultivation);
        let result = "≡ 修真排行榜 ≡\n";
        sorted.slice(0, 10).forEach(([uid, data], i) => {
            const currentRealm = getCurrentRealm(data.cultivation);
            result += `${i + 1}. ${data.name} - ${data.cultivation}修为 - ${currentRealm.name}\n`;
        });
        seal.replyToSender(ctx, msg, result);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdRankCultivation = seal.ext.newCmdItemInfo();
    cmdRankCultivation.name = "修仙排行榜";
    cmdRankCultivation.solve = solveRankCultivation;

    // 灵石排行榜指令
    function solveRankSpiritStones(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const sorted = Object.entries(userData).sort((a, b) => b[1].spiritStones - a[1].spiritStones);
        let result = "≡ 灵石排行榜 ≡\n";
        sorted.slice(0, 10).forEach(([uid, data], i) => {
            result += `${i + 1}. ${data.name} - ${data.spiritStones}灵石\n`;
        });
        seal.replyToSender(ctx, msg, result);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdRankSpiritStones = seal.ext.newCmdItemInfo();
    cmdRankSpiritStones.name = "灵石排行榜";
    cmdRankSpiritStones.solve = solveRankSpiritStones;

    // 改名指令
    function solveChangeName(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const newName = cmdArgs.getArgN(1);
        if (newName) {
            userData[uid].name = newName;
            ext.storageSet("userData", JSON.stringify(userData));
            seal.replyToSender(ctx, msg, `您已成功改名为：${newName}`);
        } else {
            seal.replyToSender(ctx, msg, "请提供新的名字");
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdChangeName = seal.ext.newCmdItemInfo();
    cmdChangeName.name = "改名";
    cmdChangeName.solve = solveChangeName;

    // 查看灵石指令
    function solveCheckStones(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const user = userData[uid];
        if (isNaN(user.spiritStones)) {
            user.spiritStones = 0;
            ext.storageSet("userData", JSON.stringify(userData));
        }
        seal.replyToSender(ctx, msg, `您当前拥有${user.spiritStones}灵石`);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdCheckStones = seal.ext.newCmdItemInfo();
    cmdCheckStones.name = "查看灵石";
    cmdCheckStones.solve = solveCheckStones;

    // 偷灵石指令
    function solveStealStones(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const attacker = ctx.player.userId.toString();
        if (checkDoubleCultivating(attacker) || checkInJail(attacker)) {
            seal.replyToSender(ctx, msg, "前辈，您当前无法偷取灵石。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要偷灵石的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (checkDoubleCultivating(target) || checkInJail(target)) {
            seal.replyToSender(ctx, msg, "目标正在...嗯，总之无法偷取其灵石。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!userData[target]) {
            seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (attacker === target) {
            seal.replyToSender(ctx, msg, "不能偷取自己");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (isNaN(userData[target].spiritStones)) {
            userData[target].spiritStones = 0;
            ext.storageSet("userData", JSON.stringify(userData));
        }
        if (userData[target].spiritStones <= 0) {
            seal.replyToSender(ctx, msg, "目标身无分文，不值得冒险");
            return seal.ext.newCmdExecuteResult(true);
        }
        const diceValue = Math.floor(Math.random() * 100) + 1;
        const SUCCESS_RATE = 50;
        const success = diceValue <= SUCCESS_RATE;
        const amount = Math.floor(Math.random() * userData[target].spiritStones) + 1;
        let resultMessage = "";
        if (success) {
            userData[attacker].spiritStones += amount;
            userData[target].spiritStones = Math.max(userData[target].spiritStones - amount, 0);
            ext.storageSet("userData", JSON.stringify(userData));
            resultMessage = `【骰点 ${diceValue}/${SUCCESS_RATE}】\n幸运，成功偷取${amount}灵石，对方似乎并未察觉。`;
        } else {
            const lost = Math.min(amount, userData[attacker].spiritStones);
            userData[attacker].spiritStones = Math.max(userData[attacker].spiritStones - lost, 0);
            userData[target].spiritStones += lost;
            const originalRealm = getCurrentRealm(userData[attacker].cultivation);
            if (Math.random() < 0.5 && userData[attacker].realmIndex > 0) {
                userData[attacker].realmIndex = Math.max(userData[attacker].realmIndex - 1, 0);
                userData[attacker].cultivation = realmLevels[userData[attacker].realmIndex].min;
                const newRealm = getCurrentRealm(userData[attacker].cultivation);
                ext.storageSet("userData", JSON.stringify(userData));
                resultMessage = `【骰点 ${diceValue}/${SUCCESS_RATE}】\n遗憾，偷取失败，您被对方揍了一顿，赔偿对方${lost}灵石！境界从 ${originalRealm.name} 跌落至 ${newRealm.name}`;
            } else {
                ext.storageSet("userData", JSON.stringify(userData));
                resultMessage = `【骰点 ${diceValue}/${SUCCESS_RATE}】\n遗憾，偷取失败，您被对方揍了一顿，赔偿对方${lost}灵石！`;
            }
        }
        const crimeDiceValue = Math.floor(Math.random() * 100) + 1;
        const CRIME_SUCCESS_RATE = 65;
        const crimeSuccess = crimeDiceValue <= CRIME_SUCCESS_RATE;
        if (crimeSuccess) {
            crimeValue[attacker] = (crimeValue[attacker] || 0) + 1;
            ext.storageSet("crimeValue", JSON.stringify(crimeValue));
            seal.replyToSender(ctx, msg, `【骰点 ${crimeDiceValue}/${CRIME_SUCCESS_RATE}】\n罪恶值增加，当前罪恶值: ${crimeValue[attacker]}`);
            if (crimeValue[attacker] >= 5) {
                const now = Date.now();
                jailTime[attacker] = now + 3600000; // 一小时
                jailCount[attacker] = (jailCount[attacker] || 0) + 1;
                crimeValue[attacker] = 0;
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                ext.storageSet("jailCount", JSON.stringify(jailCount));
                ext.storageSet("crimeValue", JSON.stringify(crimeValue));
                seal.replyToSender(ctx, msg, "您的罪恶值已满，被关进大牢一小时。");
                return seal.ext.newCmdExecuteResult(true);
            }
        } 
        seal.replyToSender(ctx, msg, resultMessage);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdStealStones = seal.ext.newCmdItemInfo();
    cmdStealStones.name = "偷灵石";
    cmdStealStones.allowDelegate = true;
    cmdStealStones.solve = solveStealStones;

    // 抢灵石指令
    function solveRobStones(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const attacker = ctx.player.userId.toString();
        if (checkDoubleCultivating(attacker) || checkInJail(attacker)) {
            seal.replyToSender(ctx, msg, "前辈，您当前无法抢夺灵石。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要抢灵石的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (checkDoubleCultivating(target) || checkInJail(target)) {
            seal.replyToSender(ctx, msg, "目标正在...嗯，总之无法抢夺其灵石。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!userData[target]) {
            seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (attacker === target) {
            seal.replyToSender(ctx, msg, "不能抢自己");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (isNaN(userData[target].spiritStones)) {
            userData[target].spiritStones = 0;
            ext.storageSet("userData", JSON.stringify(userData));
        }
        if (userData[target].spiritStones <= 0) {
            seal.replyToSender(ctx, msg, "目标身无分文，不值得冒险");
            return seal.ext.newCmdExecuteResult(true);
        }
        const diceValue = Math.floor(Math.random() * 100) + 1;
        const SUCCESS_RATE = 50;
        const success = diceValue <= SUCCESS_RATE;
        const amount = Math.floor(Math.random() * userData[target].spiritStones) + 1;
        let resultMessage = "";
        if (success) {
            userData[attacker].spiritStones += amount;
            userData[target].spiritStones = Math.max(userData[target].spiritStones - amount, 0);
            ext.storageSet("userData", JSON.stringify(userData));
            resultMessage = `【骰点 ${diceValue}/${SUCCESS_RATE}】\n好厉害...成功抢得${amount}灵石，对方有些无可奈何。`;
        } else {
            const lost = Math.min(amount, userData[attacker].spiritStones);
            userData[attacker].spiritStones = Math.max(userData[attacker].spiritStones - lost, 0);
            userData[target].spiritStones += lost;
            const originalRealm = getCurrentRealm(userData[attacker].cultivation);
            if (Math.random() < 0.5 && userData[attacker].realmIndex > 0) {
                userData[attacker].realmIndex = Math.max(userData[attacker].realmIndex - 1, 0);
                userData[attacker].cultivation = realmLevels[userData[attacker].realmIndex].min;
                const newRealm = getCurrentRealm(userData[attacker].cultivation);
                ext.storageSet("userData", JSON.stringify(userData));
                resultMessage = `【骰点 ${diceValue}/${SUCCESS_RATE}】\n遗憾，抢劫失败，您被对方揍了一顿，赔偿对方${lost}灵石！境界从 ${originalRealm.name} 跌落至 ${newRealm.name}`;
            } else {
                ext.storageSet("userData", JSON.stringify(userData));
                resultMessage = `【骰点 ${diceValue}/${SUCCESS_RATE}】\n遗憾，抢劫失败，您被对面胖揍一顿，赔偿对方${lost}灵石！`;
            }
        }
        const crimeDiceValue = Math.floor(Math.random() * 100) + 1;
        const CRIME_SUCCESS_RATE = 80;
        const crimeSuccess = crimeDiceValue <= CRIME_SUCCESS_RATE;
        if (crimeSuccess) {
            crimeValue[attacker] = (crimeValue[attacker] || 0) + 1;
            ext.storageSet("crimeValue", JSON.stringify(crimeValue));
            seal.replyToSender(ctx, msg, `【骰点 ${crimeDiceValue}/${CRIME_SUCCESS_RATE}】\n罪恶值增加，当前罪恶值: ${crimeValue[attacker]}`);
            if (crimeValue[attacker] >= 5) {
                const now = Date.now();
                jailTime[attacker] = now + 3600000; // 一小时
                jailCount[attacker] = (jailCount[attacker] || 0) + 1;
                crimeValue[attacker] = 0;
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                ext.storageSet("jailCount", JSON.stringify(jailCount));
                ext.storageSet("crimeValue", JSON.stringify(crimeValue));
                seal.replyToSender(ctx, msg, "您的罪恶值已满，被关进大牢一小时。");
                return seal.ext.newCmdExecuteResult(true);
            }
        } 
        seal.replyToSender(ctx, msg, resultMessage);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdRobStones = seal.ext.newCmdItemInfo();
    cmdRobStones.name = "抢灵石";
    cmdRobStones.allowDelegate = true;
    cmdRobStones.solve = solveRobStones;

    // 插旗指令
    function solveFlag(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        if (checkDoubleCultivating(uid) || checkInJail(uid)) {
            seal.replyToSender(ctx, msg, "前辈，您当前无法插旗对战。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@一位玩家进行插旗。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const targetUid = mctx.player.userId.toString();
        if (checkDoubleCultivating(targetUid) || checkInJail(targetUid)) {
            seal.replyToSender(ctx, msg, "目标正在...嗯，总之无法进行插旗对战。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (uid === targetUid) {
            seal.replyToSender(ctx, msg, "不能和自己插旗对战");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!userData[targetUid]) {
            seal.replyToSender(ctx, msg, "该玩家尚未加入修真界。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const userRealm = getCurrentRealm(userData[uid].cultivation);
        const targetRealm = getCurrentRealm(userData[targetUid].cultivation);
        let successRate;
        let successRateText = "";
        if (userData[uid].realmIndex < userData[targetUid].realmIndex) {
            successRate = 0.4;
            successRateText = "40%";
        } else if (userData[uid].realmIndex === userData[targetUid].realmIndex) {
            successRate = 0.5;
            successRateText = "50%";
        } else {
            successRate = 0.6;
            successRateText = "60%";
        }
        const diceValue = Math.floor(Math.random() * 100) + 1;
        const SUCCESS_RATE = Math.floor(successRate * 100);
        const success = diceValue <= SUCCESS_RATE;
        let resultMsg = `【 插旗 ${diceValue}/${SUCCESS_RATE}】\n`;
        if (success) {
            resultMsg += "插旗成功 你成功战胜了对手，威风凛凛\n";
            const damageRate = 20;
            const damageDice = Math.floor(Math.random() * 100) + 1;
            if (damageDice <= damageRate) {
                const targetDamage = Math.floor(Math.random() * 30) + 1;
                userData[targetUid].cultivation -= targetDamage;
                userData[targetUid].health -= targetDamage; // 输的一方掉血
                if (userData[targetUid].cultivation < 0) userData[targetUid].cultivation = 0;
                if (userData[targetUid].health < 0) userData[targetUid].health = 0;
                resultMsg += `【失控 ${damageDice}/${damageRate}】\n 你未想到会伤对方至此\n`;
                resultMsg += `${userData[targetUid].name} 修为减少 ${targetDamage}\n`;
            } else {
                resultMsg += `【失控 ${damageDice}/${damageRate}】\n你们双方点到为止，未有大伤\n`;
            }
            const newTargetRealm = getCurrentRealm(userData[targetUid].cultivation);
            if (newTargetRealm !== targetRealm) {
                userData[targetUid].realmIndex = Math.max(userData[targetUid].realmIndex - 1, 0);
                userData[targetUid].cultivation = realmLevels[userData[targetUid].realmIndex].min;
                resultMsg += `境界从 ${targetRealm.name} 跌落至 ${newTargetRealm.name}\n`;
            }
        } else {
            resultMsg += "插旗失败 你被对手狠狠压制，显得狼狈\n";
            const backlashRate = 20;
            const backlashDice = Math.floor(Math.random() * 100) + 1;
            if (backlashDice <= backlashRate) {
                const selfDamage = Math.floor(Math.random() * 20) + 1;
                userData[uid].cultivation -= selfDamage;
                userData[uid].health -= selfDamage; // 输的一方掉血
                if (userData[uid].cultivation < 0) userData[uid].cultivation = 0;
                if (userData[uid].health < 0) userData[uid].health = 0;
                resultMsg += `【失控 ${backlashDice}/${backlashRate}】\n对方未想到会伤你至此\n你掉了 ${selfDamage} 修为\n`;
            } else {
                resultMsg += `【失控 ${backlashDice}/${backlashRate}】\n你们双方点到为止，未有大伤\n`;
            }
            const newRealm = getCurrentRealm(userData[uid].cultivation);
            if (newRealm !== userRealm) {
                userData[uid].realmIndex = Math.max(userData[uid].realmIndex - 1, 0);
                userData[uid].cultivation = realmLevels[userData[uid].realmIndex].min;
                resultMsg += `境界从 ${userRealm.name} 跌落至 ${newRealm.name}\n`;
            }
        }
        ext.storageSet("userData", JSON.stringify(userData));
        seal.replyToSender(ctx, msg, resultMsg);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdFlag = seal.ext.newCmdItemInfo();
    cmdFlag.name = "插旗";
    cmdFlag.allowDelegate = true;
    cmdFlag.solve = solveFlag;

    // 查看剩余时间指令
    function solveCheckRemainingTime(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const now = Date.now();
        if (!userActionStatus[uid] && !jailTime[uid]) {
            seal.replyToSender(ctx, msg, "前辈，您当前没有正在进行的操作。");
            return seal.ext.newCmdExecuteResult(true);
        }
        let remainingTime = 0;
        let action = '';
        if (userActionStatus[uid] === 'alchemy') {
            const startTime = lastActionTime[uid];
            if (typeof startTime === 'number' && startTime > 0) {
                const elapsedTime = now - startTime;
                remainingTime = 1800000 - elapsedTime; // 炼丹时间为半小时
                action = '炼丹';
            }
        } else if (jailTime[uid]) {
            remainingTime = jailTime[uid] - now;
            action = '大牢服刑';
            if (remainingTime <= 0) {
                delete jailTime[uid];
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                // 使用当前真实上下文替代mock对象
                const userMention = `[CQ:at,qq=${uid.replace("QQ:","")}]`;
                const deckResult = drawEventDeck(ctx, msg, eventDecks.jailRelease); // 使用真实ctx和msg
                const message = `${userMention} 已经出狱，好好改造\n${deckResult}`;
                seal.replyToSender(ctx, msg, message);
            }
        } else if (userActionStatus[uid] === 'begging') {  // 新增乞讨状态判断
            const startTime = lastActionTime[uid];
            if (typeof startTime === 'number' && startTime > 0) {
                const elapsedTime = now - startTime;
                remainingTime = 600000 - elapsedTime;  // 乞讨持续10分钟（600000毫秒）
                action = '乞讨';
            }
        } else {
            const startTime = lastActionTime[uid];
            if (typeof startTime === 'number' && startTime > 0) {
                const elapsedTime = now - startTime;
                remainingTime = 1800000 - elapsedTime;
                if (userActionStatus[uid] === 'doubleCultivating') {
                    remainingTime = 1800000 - elapsedTime; // 双修时间为半小时
                }
                if (userActionStatus[uid] === 'begging') {
                    action = '乞讨';
                } else if  (userActionStatus[uid] === 'cultivating') {
                    action = '修仙';
                } else if (userActionStatus[uid] === 'working') {
                    action = '打工';
                } else if (userActionStatus[uid] === 'doubleCultivating') {
                    action = '双修';
                }
            }
        }
        remainingTime = Math.max(remainingTime, 0); // 确保非负
        const minutes = Math.floor(remainingTime / 60000);
        const seconds = Math.floor((remainingTime % 60000) / 1000);
        if (action) {
            seal.replyToSender(ctx, msg, `前辈，您正在${action}中，还剩 ${minutes} 分 ${seconds} 秒结束。`);
        } else {
            seal.replyToSender(ctx, msg, "状态异常：未找到有效的剩余时间记录。");
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdCheckRemainingTime = seal.ext.newCmdItemInfo();
    cmdCheckRemainingTime.name = "查看剩余时间";
    cmdCheckRemainingTime.solve = solveCheckRemainingTime;

    // 修仙帮助指令
    function solveHelp(ctx, msg) {
        const helpTextPart1 = `
[图:data/images/修仙帮助.png]
        `.trim();
        seal.replyToSender(ctx, msg, helpTextPart1);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdHelp = seal.ext.newCmdItemInfo();
    cmdHelp.name = "修仙帮助";
    cmdHelp.solve = solveHelp;

    // 查看修为指令
    function solveCheckCultivation(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const user = userData[uid];
        const currentRealm = getCurrentRealm(user.cultivation);
        const nextRealmIndex = user.realmIndex + 1;
        const nextRealm = realmLevels[nextRealmIndex];
        let msgText = `当前修为：${user.cultivation}\n当前境界：${currentRealm.name}`;
        seal.replyToSender(ctx, msg, msgText);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdCheckCultivation = seal.ext.newCmdItemInfo();
    cmdCheckCultivation.name = "查看修为";
    cmdCheckCultivation.solve = solveCheckCultivation;

    function solveCheckBond(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要查看羁绊的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (!userData[target]) {
            seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
            return seal.ext.newCmdExecuteResult(true);
        }
        const bondKey = getBondKey(uid, target);
        const bond = bondData[bondKey] || 0;
        const bondStage = getBondStage(bond);
        let msgText = `您与 ${userData[target].name} 的羁绊值为：${bond}，羁绊阶段为：${bondStage}`;
        const bondStagesThresholds = [100, 250, 520, 800, 1000, 1314, 2000];
        let nextStageIndex = -1;
        for (let i = 0; i < bondStagesThresholds.length; i++) {
            if (bond < bondStagesThresholds[i]) {
                nextStageIndex = i;
                break;
            }
        }
        if (nextStageIndex !== -1) {
            const nextStageName = getBondStage(bondStagesThresholds[nextStageIndex]);
            const difference = bondStagesThresholds[nextStageIndex] - bond;
            msgText += `\n下一羁绊阶段：${nextStageName}（需${bondStagesThresholds[nextStageIndex]}羁绊值，还差${difference}）`;
        } else {
            msgText += "\n已是最高羁绊阶段";
        }
        seal.replyToSender(ctx, msg, msgText);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdCheckBond = seal.ext.newCmdItemInfo();
    cmdCheckBond.name = "查看羁绊";
    cmdCheckBond.allowDelegate = true;
    cmdCheckBond.solve = solveCheckBond;

    // 查看报道天数指令
    function solveCheckSignInDays(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const user = userData[uid];
        seal.replyToSender(ctx, msg, `您的修仙报道天数为：${user.cultivationDays} 天`);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdCheckSignInDays = seal.ext.newCmdItemInfo();
    cmdCheckSignInDays.name = "查看报道天数";
    cmdCheckSignInDays.solve = solveCheckSignInDays;

    // 羁绊排行榜指令
    function solveRankBond(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const sorted = [];
        for (const [key, value] of Object.entries(bondData)) {
            const [user1, user2] = key.split('-');
            sorted.push({
                users: [userData[user1].name, userData[user2].name],
                bond: value
            });
        }
        sorted.sort((a, b) => b.bond - a.bond);
        let result = "≡ 羁绊值排行榜 ≡\n";
        sorted.slice(0, 10).forEach((data, i) => {
            const bondStage = getBondStage(data.bond);
            result += `${i + 1}. ${data.users.join(" & ")} - ${data.bond}羁绊值 - ${bondStage}\n`;
        });
        seal.replyToSender(ctx, msg, result);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdRankBond = seal.ext.newCmdItemInfo();
    cmdRankBond.name = "羁绊排行榜";
    cmdRankBond.solve = solveRankBond;

    // 开始双修指令
    function solveDoubleCultivation(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        
        // 修改参数校验顺序，先尝试获取@目标
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请使用格式：.开始双修 @对方\n请确保正确@目标用户");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要邀请的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!userData[target]) {
            seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (target === uid) {
            seal.replyToSender(ctx, msg, "不能邀请自己进行双修哦。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (checkDoubleCultivating(uid) || checkInJail(uid)) {
            seal.replyToSender(ctx, msg, "前辈，您正在...嗯，总之无法发起双修。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (userActionStatus[uid] === 'cultivating' || userActionStatus[uid] === 'working' || userActionStatus[uid] === 'alchemy') {
            seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，结束后才能发起双修。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const now = Date.now();
        if (lastActionTime[uid] && now - lastActionTime[uid] < 1800000) {
            seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，半小时后再来发起双修吧");
            return seal.ext.newCmdExecuteResult(true);
        }
   // 记录邀请信息
   userActionStatus[uid] = 'waitingForDoubleCultivation';
   userActionStatus[target] = 'invitedForDoubleCultivation';
   lastActionTime[uid] = now;
   lastActionTime[target] = now;
   ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
   ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));

   // ======== 新增超时处理逻辑 ========
   // 设置1分钟超时定时器
   const timeoutId = setTimeout(() => {
       // 检查是否仍然处于邀请状态
       if (userActionStatus[uid] === 'waitingForDoubleCultivation' && 
           userActionStatus[target] === 'invitedForDoubleCultivation') {
           
           // 清除双方状态
           userActionStatus[uid] = null;
           userActionStatus[target] = null;
           lastActionTime[uid] = null;
           lastActionTime[target] = null;
           
           // 持久化存储
           ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
           ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
           
           // 发送超时通知
           const timeoutMsg = `双修邀请已超时（1分钟未响应），自动取消邀请`;
           seal.replyToSender(ctx, msg, timeoutMsg);
           
           // 清理定时器记录
           delete invitationTimeoutIds[uid];
           delete invitationTimeoutIds[target];
       }
   }, 60000); // 1分钟定时器

   // 存储定时器ID（双方都存储以便后续清理）
   invitationTimeoutIds[uid] = timeoutId;
   invitationTimeoutIds[target] = timeoutId;
        const targetMention = `[CQ:at,qq=${target.replace("QQ:","")}]`;
        const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
        seal.replyToSender(ctx, msg, `${targetMention}，${userMention} 邀请您进行双修，您是否同意？（回复“确认同意”或“拒绝双修”）`);
        return seal.ext.newCmdExecuteResult(true);
    }
    
    const cmdDoubleCultivation = seal.ext.newCmdItemInfo();
    cmdDoubleCultivation.name = "开始双修";
    cmdDoubleCultivation.allowDelegate = true;
    cmdDoubleCultivation.solve = solveDoubleCultivation;

    // 确认同意|拒绝双修指令
    function solveDoubleCultivationReply(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const subCommand = cmdArgs.command;
        if (subCommand === "确认同意") {
            const invitee = Object.keys(userActionStatus).find(key => userActionStatus[key] === 'waitingForDoubleCultivation');
            if (!invitee) {
                seal.replyToSender(ctx, msg, "没有正在等待的双修邀请。");
                return seal.ext.newCmdExecuteResult(true);
            }
            if (userActionStatus[uid] !== 'invitedForDoubleCultivation') {
                seal.replyToSender(ctx, msg, "不可以替他人确认同意。");
                return seal.ext.newCmdExecuteResult(true);
            }
            // 开始双修逻辑
            userActionStatus[uid] = 'doubleCultivating';
            userActionStatus[invitee] = 'doubleCultivating';
            lastActionTime[uid] = Date.now();
            lastActionTime[invitee] = Date.now();
            ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
            ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
            const inviteeMention = `[CQ:at,qq=${invitee.replace("QQ:","")}]`;
            const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
            seal.replyToSender(ctx, msg, `${userMention} 和 ${inviteeMention} 开始双修啦！`);
            // 可以在这里添加双修的具体逻辑，如定时器等
            const timeoutId = setTimeout(() => {
                // 重置用户状态和时间记录
                userActionStatus[uid] = null;
                userActionStatus[invitee] = null;
                lastActionTime[uid] = null;
                lastActionTime[invitee] = null;
                ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
                ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
            
                // 计算双修带来的修为和羁绊值提升
                const bondIncrease = Math.floor(Math.random() * 100) + 1;
                const cultivationIncrease = Math.floor(Math.random() * 200) + 1;
                userData[uid].cultivation += cultivationIncrease;
                userData[invitee].cultivation += cultivationIncrease;
                const bondKey = getBondKey(uid, invitee);
                bondData[bondKey] = (bondData[bondKey] || 0) + bondIncrease;
                ext.storageSet("userData", JSON.stringify(userData));
                ext.storageSet("bondData", JSON.stringify(bondData));
            
                // 生成并发送给发起者的消息
                const userMention = `[CQ:at,qq=${uid.replace("QQ:","")}]`;
                const deckResult = drawEventDeck(ctx, msg, eventDecks.doubleCultivateEnd);
                const message = `${userMention} 双修结束，双方各获得了 ${cultivationIncrease} 点修为，羁绊值增加了 ${bondIncrease} 点。\n${deckResult}`;
                seal.replyToSender(ctx, msg, message);
            }, 1800000);
            
            doubleCultivationTimeoutIds[uid] = timeoutId;
            doubleCultivationTimeoutIds[invitee] = timeoutId;
        } else if (subCommand === "拒绝双修") {
            const invitee = Object.keys(userActionStatus).find(key => userActionStatus[key] === 'waitingForDoubleCultivation');
            if (!invitee) {
                seal.replyToSender(ctx, msg, "没有正在等待的双修邀请。");
                return seal.ext.newCmdExecuteResult(true);
            }
            if (userActionStatus[uid] !== 'invitedForDoubleCultivation') {
                seal.replyToSender(ctx, msg, "不可以替他人拒绝邀请。");
                return seal.ext.newCmdExecuteResult(true);
            }
            userActionStatus[uid] = null;
            userActionStatus[invitee] = null;
            lastActionTime[uid] = null;
            lastActionTime[invitee] = null;
            ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
            ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
            const inviteeMention = `[CQ:at,qq=${invitee.replace("QQ:","")}]`;
            const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
            seal.replyToSender(ctx, msg, `${userMention} 拒绝了 ${inviteeMention} 的双修邀请。`);
        }
        return seal.ext.newCmdExecuteResult(true);
    }
    
    const cmdDoubleCultivationReply1 = seal.ext.newCmdItemInfo();
    cmdDoubleCultivationReply1.name = "确认同意";
    cmdDoubleCultivationReply1.solve = solveDoubleCultivationReply;

    const cmdDoubleCultivationReply2 = seal.ext.newCmdItemInfo();
    cmdDoubleCultivationReply2.name = "拒绝双修";
    cmdDoubleCultivationReply2.solve = solveDoubleCultivationReply;

    function isDiceMaster(ctx) {
    return ctx.privilegeLevel === 100;
}

    // 强制结束指令
    const alchemyTimeoutIds = {};

function solveForceEnd(ctx, msg, cmdArgs) {
    if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
    const uid = ctx.player.userId.toString();
    const today = new Date().toDateString();
    const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        let targetUid = uid;
        let isTargetSelf = true;
        if (mctx) {
            targetUid = mctx.player.userId.toString();
            isTargetSelf = targetUid === uid;
        }
    const isDiceMasterDefined = typeof isDiceMaster === 'function';
    // 修改判断逻辑：仅当不是骰主操作他人时才检查限制
    if (!isDiceMaster(ctx) && isTargetSelf) {
        if (forceEndUsedDate[targetUid] === today && (forceEndUsedCount[targetUid] || 0) >= 1) {
            seal.replyToSender(ctx, msg, "前辈，您今天已经使用过一次强制结束指令，无法再次使用。\n如果遇到bug，可以使用【提前结束】指令尝试\n如果还是不行，可以使用【send】指令反馈给骰主前来解决。\n如：.send 骰主救命");
            return seal.ext.newCmdExecuteResult(true);
        }
    }
        if (!isTargetSelf && (isDiceMasterDefined &&!isDiceMaster(ctx))) {
            seal.replyToSender(ctx, msg, "只有骰主可以强制结束他人的进程。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!userActionStatus[targetUid] && (!lastActionTime[targetUid] || Date.now() - lastActionTime[targetUid] >= 3600000) && !jailTime[targetUid]) {
            if (isTargetSelf) {
                seal.replyToSender(ctx, msg, "前辈，您当前没有正在进行的操作，无需强制结束。");
            } else {
                seal.replyToSender(ctx, msg, `前辈，${userData[targetUid].name} 当前没有正在进行的操作，无需强制结束。`);
            }
            return seal.ext.newCmdExecuteResult(true);
        }
        const actionTypes = ['cultivating', 'working', 'doubleCultivating', 'alchemy'];
        actionTypes.forEach(action => {
            if (userActionStatus[targetUid] === action) {
                const timeoutIds = {
                    cultivating: cultivateTimeoutIds,
                    working: workTimeoutIds,
                    doubleCultivating: doubleCultivationTimeoutIds,
                    alchemy: alchemyTimeoutIds
                };
                if (timeoutIds[action][targetUid]) {
                    clearTimeout(timeoutIds[action][targetUid]);
                    delete timeoutIds[action][targetUid];
                }
                if (action === 'doubleCultivating') {
                    for (const [key, id] of Object.entries(doubleCultivationTimeoutIds)) {
                        if (id === doubleCultivationTimeoutIds[targetUid]) {
                            clearTimeout(id);
                            delete doubleCultivationTimeoutIds[key];
                            userActionStatus[key] = null;
                            lastActionTime[key] = null;
                        }
                    }
                }
            }
        });
        userActionStatus[targetUid] = null;
        lastActionTime[targetUid] = null;
        if (jailTime[targetUid]) {
            delete jailTime[targetUid];
            ext.storageSet("jailTime", JSON.stringify(jailTime));
        }
        ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
        ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
        userData[targetUid].lastActionTime = null;
    if (isTargetSelf && !isDiceMaster(ctx)) {
        forceEndUsedDate[targetUid] = today;
        forceEndUsedCount[targetUid] = (forceEndUsedCount[targetUid] || 0) + 1; 
        ext.storageSet("forceEndUsedDate", JSON.stringify(forceEndUsedDate));
        ext.storageSet("forceEndUsedCount", JSON.stringify(forceEndUsedCount));
    }
        if (isTargetSelf) {
            seal.replyToSender(ctx, msg, "前辈，您的所有操作已被强制结束，状态已重置。");
        } else {
            seal.replyToSender(ctx, msg, `前辈，已成功强制结束 ${userData[targetUid].name} 的所有操作，状态已重置。`);
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdForceEnd = seal.ext.newCmdItemInfo();
    cmdForceEnd.name = "强制结束";
    cmdForceEnd.allowDelegate = true;
    cmdForceEnd.solve = solveForceEnd;

    // 开始炼丹指令
    const pillData = {
        common: { name: "普通丹药", cultivation: 50, price: 50, chance: 0.5 },
        medium: { name: "中品丹药", cultivation: 100, price: 100, chance: 0.25 },
        high: { name: "高等丹药", cultivation: 150, price: 150, chance: 0.1 },
        top: { name: "极品丹药", cultivation: 200, price: 200, chance: 0.05 },
        waste: { name: "废丹", cultivation: null, price: null, chance: 0.05 }
    };

    const itemData = {
        "强制掠夺": {
            name: "强制掠夺",
            description: "65％概率掠夺对方100灵石，50％将使用者关进大牢"
        },
        "vip房卡": {
            name: "vip房卡",
            description: "使用后一分钟内开启双修不扣灵石"
        },
        "监狱vip上房贵客卡": {
            name: "监狱vip上房贵客卡",
            description: "65％指定目标进入监狱，反之使用者进监狱"
        },
        "保释卡": {
            name: "保释卡",
            description: "目标进监狱后，可以使用保释卡@对方保释出狱"
        },
        "成神丹": {
            name: "成神丹",
            description: "10％的概率的概率直接境界到达真神最低修为，无副作用"
        }
    };
    
    // 修改 solveAlchemy 函数
    function solveAlchemy(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        if (checkDoubleCultivating(uid) || checkInJail(uid)) {
            seal.replyToSender(ctx, msg, "前辈，您正在...嗯，总之无法开始炼丹。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (userActionStatus[uid] === 'cultivating' || userActionStatus[uid] === 'working' || userActionStatus[uid] === 'alchemy') {
            seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，结束后才能开始炼丹。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const now = Date.now();
        if (lastActionTime[uid] && now - lastActionTime[uid] < 1800000) {
            seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，半小时后再来炼丹吧");
            return seal.ext.newCmdExecuteResult(true);
        }
        lastActionTime[uid] = now;
        userActionStatus[uid] = 'alchemy';
        ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
        const timeoutId = setTimeout(() => {
            const pillCount = Math.floor(Math.random() * 5) + 1;
            const pills = [];
            for (let i = 0; i < pillCount; i++) {
                const rand = Math.random();
                if (rand < 0.5) {
                    pills.push("普通丹药");
                } else if (rand < 0.75) {
                    pills.push("中品丹药");
                } else if (rand < 0.85) {
                    pills.push("高等丹药");
                } else if (rand < 0.95) {
                    pills.push("极品丹药");
                } else {
                    pills.push("废丹");
                }
            }
            
            // 初始化物品对象
            userData[uid] = userData[uid] || {};
            userData[uid].items = userData[uid].items || {};
            
            // 统一使用name作为键逐个添加
            pills.forEach(pillName => {
                userData[uid].items[pillName] = (userData[uid].items[pillName] || 0) + 1;
            });
    
            let resultMessage = `前辈，炼丹结束，您获得了：\n`;
            const uniquePills = [...new Set(pills)];
            uniquePills.forEach(pill => {
                const count = pills.filter(p => p === pill).length;
                resultMessage += `${count} 个 ${pill}\n`;
            });
    
            // 50％概率出一个小道具
            if (Math.random() < 0.5) {
                const rand = Math.random();
                let itemName;
                if (rand < 0.5) {
                    itemName = "vip房卡";
                } else if (rand < 0.7) {
                    itemName = "强制掠夺";
                } else if (rand < 0.85) {
                    itemName = "保释卡";
                } else if (rand < 0.95) {
                    itemName = "监狱vip上房贵客卡";
                } else {
                    itemName = "成神丹";
                }
                userData[uid].items = userData[uid].items || {};
                userData[uid].items[itemName] = (userData[uid].items[itemName] || 0) + 1;
                resultMessage += `还额外获得了一个 ${itemName}！\n`;
            }
    
            ext.storageSet("userData", JSON.stringify(userData));
            userActionStatus[uid] = null;
            lastActionTime[uid] = null;
            ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
            ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
            
            const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
            const deckResult = drawEventDeck(ctx, msg, eventDecks.alchemyEnd);
            seal.replyToSender(ctx, msg, `${userMention} ${resultMessage}\n${deckResult}`);
        }, 1800000);
        alchemyTimeoutIds[uid] = timeoutId;
        seal.replyToSender(ctx, msg, `前辈，开始炼丹了，半小时后记得来取丹药。`);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdAlchemy = seal.ext.newCmdItemInfo();
    cmdAlchemy.name = "开始炼丹";
    cmdAlchemy.solve = solveAlchemy;

    // 去商城指令
    const flowerData = {
        rose: { name: "玫瑰", cultivation: null, price: 20, chance: null, type: 'flower' },
        lily: { name: "百合", cultivation: null, price: 20, chance: null, type: 'flower' },
        carnation: { name: "康乃馨", cultivation: null, price: 20, chance: null, type: 'flower' },
        hyacinth: { name: "风信子", cultivation: null, price: 20, chance: null, type: 'flower' },
        violet: { name: "紫罗兰", cultivation: null, price: 20, chance: null, type: 'flower' },
        sunflower: { name: "向日葵", cultivation: null, price: 20, chance: null, type: 'flower' },
        "baby's-breath": { name: "满天星", cultivation: null, price: 20, chance: null, type: 'flower' },
        "forget-me-not": { name: "勿忘我", cultivation: null, price: 20, chance: null, type: 'flower' }
    };

    function solveShop(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const subCommand = cmdArgs.getArgN(1);
        const itemName = cmdArgs.getArgN(2);
        const amount = parseInt(cmdArgs.getArgN(3));
        if (!subCommand) {
            let shopMessage = "≡ 商城列表 ≡\n";
            for (const [type, data] of Object.entries(pillData)) {
                if (data.price) {
                    shopMessage += `${data.name} - 价格: ${data.price} 灵石，使用后增加 ${data.cultivation} 修为\n`;
                }
            }
            for (const [type, data] of Object.entries(flowerData)) {
                shopMessage += `${data.name} - 价格: ${data.price} 灵石，可用于赠送增加羁绊值\n`;
            }
            seal.replyToSender(ctx, msg, shopMessage);
            return seal.ext.newCmdExecuteResult(true);
        }
        if (subCommand === "购买") {
            // 校验逻辑
            if (!itemName || isNaN(amount) || amount <= 0) {
                seal.replyToSender(ctx, msg, "请指定正确的物品名称和购买数量。");
                return seal.ext.newCmdExecuteResult(true);
            }
            
            // 查找物品
            const item = Object.values({ ...pillData, ...flowerData }).find(p => p.name === itemName);
            if (!item || !item.price) {
                seal.replyToSender(ctx, msg, "该物品不可购买。");
                return seal.ext.newCmdExecuteResult(true);
            }

            // 灵石校验
            const totalPrice = item.price * amount;
            if (userData[uid].spiritStones < totalPrice) {
                seal.replyToSender(ctx, msg, `前辈，您的灵石不足，需要 ${totalPrice} 灵石，当前仅有 ${userData[uid].spiritStones} 灵石。`);
                return seal.ext.newCmdExecuteResult(true);
            }

            // 执行购买
            userData[uid].spiritStones -= totalPrice;
            userData[uid].items = userData[uid].items || {}; // 确保items对象存在
            userData[uid].items[itemName] = (userData[uid].items[itemName] || 0) + amount;
            
            ext.storageSet("userData", JSON.stringify(userData));
            seal.replyToSender(ctx, msg, `前辈，您成功购买了 ${amount} 个 ${itemName}，花费了 ${totalPrice} 灵石。`);

         } else if (subCommand === "出售") {
        // 校验逻辑
        if (!itemName || isNaN(amount) || amount <= 0) {
            seal.replyToSender(ctx, msg, "请指定正确的物品名称和出售数量。");
            return seal.ext.newCmdExecuteResult(true);
        }

        // 查找丹药
        const pill = Object.values(pillData).find(p => p.name === itemName);
        // 新增道具过滤
        const isItem = Object.values(itemData).some(i => i.name === itemName);
        if (isItem) {
            seal.replyToSender(ctx, msg, "特殊道具不可出售");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!pill || !pill.price) {
            seal.replyToSender(ctx, msg, "该物品不可出售。");
            return seal.ext.newCmdExecuteResult(true);
        }

        // 检查物品数量
        const currentCount = userData[uid].items[itemName] || 0;
        if (currentCount < amount) {
            seal.replyToSender(ctx, msg, "前辈，您没有足够的物品可以出售。");
            return seal.ext.newCmdExecuteResult(true);
        }

        // 执行出售
        const totalIncome = pill.price * amount;
        userData[uid].spiritStones += totalIncome;
        userData[uid].items[itemName] -= amount;

        // 清理空物品
        if (userData[uid].items[itemName] <= 0) {
            delete userData[uid].items[itemName];
        }

        ext.storageSet("userData", JSON.stringify(userData));
        seal.replyToSender(ctx, msg, `前辈，您成功出售了 ${amount} 个 ${itemName}，获得了 ${totalIncome} 灵石。`);
    }
    return seal.ext.newCmdExecuteResult(true);
}

    const cmdShop = seal.ext.newCmdItemInfo();
    cmdShop.name = "去商城";
    cmdShop.solve = solveShop;

    // 赠送鲜花指令
    function solveGiveFlower(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要赠送鲜花的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (!userData[target]) {
            seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (target === uid) {
            seal.replyToSender(ctx, msg, "不能给自己赠送鲜花哦。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const flowerName = cmdArgs.getArgN(1);
        // 获取数量参数，如果未提供则默认为1
        const amount = parseInt(cmdArgs.getArgN(2)) || 1; 
    
        if (!flowerName) {
            seal.replyToSender(ctx, msg, "请指定要赠送的鲜花名称。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const flower = Object.values(flowerData).find(f => f.name === flowerName);
        if (!flower) {
            seal.replyToSender(ctx, msg, "未知的鲜花名称。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (!userData[uid].items || !userData[uid].items[flowerName] || userData[uid].items[flowerName] < amount) {
            seal.replyToSender(ctx, msg, `您的背包中没有足够的 ${flowerName}。`);
            return seal.ext.newCmdExecuteResult(true);
        }
        userData[uid].items[flowerName] -= amount;
        if (userData[uid].items[flowerName] === 0) {
            delete userData[uid].items[flowerName];
        }
        ext.storageSet("userData", JSON.stringify(userData));
        let totalBondIncrease = 0;
        for (let i = 0; i < amount; i++) {
            const bondIncrease = Math.floor(Math.random() * 80) + 1;
            totalBondIncrease += bondIncrease;
        }
        const bondKey = getBondKey(uid, target);
        bondData[bondKey] = (bondData[bondKey] || 0) + totalBondIncrease;
        ext.storageSet("bondData", JSON.stringify(bondData));
        const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
        const targetMention = `[CQ:at,qq=${target.replace("QQ:","")}]`;
        const message = `${userMention} 给 ${targetMention} 赠送了 ${amount} 个 ${flowerName}，羁绊值增加了 ${totalBondIncrease} 点。`;
        seal.replyToSender(ctx, msg, message);
        return seal.ext.newCmdExecuteResult(true);
    }
    
    const cmdGiveFlower = seal.ext.newCmdItemInfo();
    cmdGiveFlower.name = "赠送";
    cmdGiveFlower.allowDelegate = true;
    cmdGiveFlower.solve = solveGiveFlower;

    // 查看背包指令
    function solveCheckBag(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const user = userData[uid];
        const items = user.items || {};
        let bagMessage = "≡ 背包 ≡\n";
        for (const [item, count] of Object.entries(items)) {
            bagMessage += `${count} 个 ${item}\n`;
        }
        if (Object.keys(items).length === 0) {
            bagMessage += "背包为空。";
        }
        seal.replyToSender(ctx, msg, bagMessage);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdCheckBag = seal.ext.newCmdItemInfo();
    cmdCheckBag.name = "查看背包";
    cmdCheckBag.solve = solveCheckBag;

    // 使用丹药指令
    function solveUsePill(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const uid = ctx.player.userId.toString();
        const pillName = cmdArgs.getArgN(1);
        const amount = parseInt(cmdArgs.getArgN(2)) || 1; 
    
        if (!pillName) {
            seal.replyToSender(ctx, msg, "请指定要使用的丹药名称。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const user = userData[uid];
        const items = user.items || {};
        if (!items[pillName] || items[pillName] < amount) {
            seal.replyToSender(ctx, msg, `您的背包中没有足够的 ${pillName}。`);
            return seal.ext.newCmdExecuteResult(true);
        }
        const pill = Object.values(pillData).find(p => p.name === pillName);
        if (!pill) {
            seal.replyToSender(ctx, msg, "未知的丹药名称。");
            return seal.ext.newCmdExecuteResult(true);
        }
        let totalCultivationIncrease = 0;
        for (let i = 0; i < amount; i++) {
            let cultivationIncrease = 0;
            if (pillName === "废丹") {
                if (Math.random() < 0.5) {
                    cultivationIncrease = Math.floor(Math.random() * 100) + 1;
                } else {
                    cultivationIncrease = -(Math.floor(Math.random() * 50) + 1);
                }
            } else {
                cultivationIncrease = pill.cultivation;
                
                // 将中毒判定移到循环内部
                let poisoningRate = 0;
                if (pillName === "普通丹药") {
                    poisoningRate = 0.3;
                } else if (pillName === "中品丹药") {
                    poisoningRate = 0.25;
                } else if (pillName === "高等丹药") {
                    poisoningRate = 0.2;
                } else if (pillName === "极品丹药") {
                    poisoningRate = 0.1;
                }
    
                // 立即进行中毒判定
                if (Math.random() < poisoningRate) {
                    if (user.realmIndex > 0) {
                        user.realmIndex = Math.max(user.realmIndex - 1, 0);
                        user.cultivation = realmLevels[user.realmIndex].min;
                        seal.replyToSender(ctx, msg, `【中毒警告】使用 ${pillName} 时中毒，境界跌落至 ${realmLevels[user.realmIndex].name}。`);
                        ext.storageSet("userData", JSON.stringify(userData)); // 立即保存中毒状态
                    }
                }
            }
            totalCultivationIncrease += cultivationIncrease;
        }
        user.cultivation += totalCultivationIncrease;
        items[pillName] -= amount;
        if (items[pillName] === 0) {
            delete items[pillName];
        }
        ext.storageSet("userData", JSON.stringify(userData));
        const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
        const message = `${userMention} 使用了 ${amount} 个 ${pillName}，总修为 ${totalCultivationIncrease > 0 ? '增加' : '减少'} 了 ${Math.abs(totalCultivationIncrease)} 点。`;
        seal.replyToSender(ctx, msg, message);
        return seal.ext.newCmdExecuteResult(true);
    }
    
    const cmdUsePill = seal.ext.newCmdItemInfo();
    cmdUsePill.name = "服用";
    cmdUsePill.solve = solveUsePill;

    // 劫狱指令
    function solveBreakout(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const rescuer = ctx.player.userId.toString();
        if (checkDoubleCultivating(rescuer) || checkInJail(rescuer)) {
            seal.replyToSender(ctx, msg, "前辈，您当前无法进行劫狱。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要劫狱的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (!checkInJail(target)) {
            seal.replyToSender(ctx, msg, "目标不在大牢中。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const success = Math.random() < 0.5;
        if (success) {
            delete jailTime[target];
            ext.storageSet("jailTime", JSON.stringify(jailTime));
            seal.replyToSender(ctx, msg, "劫狱成功，目标已被救出。");
        } else {
            if (Math.random() < 0.5) {
                const now = Date.now();
                jailTime[rescuer] = now + 3600000; // 一小时
                jailCount[rescuer] = (jailCount[rescuer] || 0) + 1;
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                ext.storageSet("jailCount", JSON.stringify(jailCount));
                seal.replyToSender(ctx, msg, "劫狱失败，您也被关进大牢一小时。");
            } else {
                seal.replyToSender(ctx, msg, "劫狱失败，您幸运地逃脱了。");
            }
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdBreakout = seal.ext.newCmdItemInfo();
    cmdBreakout.name = "劫狱";
    cmdBreakout.allowDelegate = true;
    cmdBreakout.solve = solveBreakout;

    // 赎人指令
    function solveRansom(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const rescuer = ctx.player.userId.toString();
        if (checkInJail(rescuer)) {
            seal.replyToSender(ctx, msg, "前辈，您当前无法进行赎人。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
        if (!mctx) {
            seal.replyToSender(ctx, msg, "请@要赎人的目标");
            return seal.ext.newCmdExecuteResult(true);
        }
        const target = mctx.player.userId.toString();
        if (!checkInJail(target)) {
            seal.replyToSender(ctx, msg, "目标不在大牢中。");
            return seal.ext.newCmdExecuteResult(true);
        }
        if (userData[rescuer].spiritStones < 100) {
            seal.replyToSender(ctx, msg, "前辈，您的灵石不足100，无法赎人。");
            return seal.ext.newCmdExecuteResult(true);
        }
        userData[rescuer].spiritStones -= 100;
        delete jailTime[target];
        ext.storageSet("userData", JSON.stringify(userData));
        ext.storageSet("jailTime", JSON.stringify(jailTime));
        seal.replyToSender(ctx, msg, "赎人成功，目标已被救出。");
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdRansom = seal.ext.newCmdItemInfo();
    cmdRansom.name = "赎人";
    cmdRansom.allowDelegate = true;
    cmdRansom.solve = solveRansom;

    // 入狱排行榜指令
    function solveRankJail(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const sorted = Object.entries(jailCount).sort((a, b) => b[1] - a[1]);
        let result = "≡ 入狱排行榜 ≡\n";
        sorted.slice(0, 10).forEach(([uid, count], i) => {
            const user = userData[uid];
            if (user) {
                result += `${i + 1}. ${user.name} - 入狱次数: ${count}\n`;
            }
        });
        seal.replyToSender(ctx, msg, result);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdRankJail = seal.ext.newCmdItemInfo();
    cmdRankJail.name = "入狱排行榜";
    cmdRankJail.solve = solveRankJail;

    // 骰主强制结束指令
    function solveDiceMasterForceEnd(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        if (ctx.privilegeLevel != 100) {
            seal.replyToSender(ctx, msg, "只有骰主可以使用此指令。");
            return seal.ext.newCmdExecuteResult(true);
        }
        const uid = ctx.player.userId.toString();
        const actionTypes = ['cultivating', 'working', 'doubleCultivating', 'alchemy'];
        actionTypes.forEach(action => {
            if (userActionStatus[uid] === action) {
                const timeoutIds = {
                    cultivating: cultivateTimeoutIds,
                    working: workTimeoutIds,
                    doubleCultivating: doubleCultivationTimeoutIds,
                    alchemy: alchemyTimeoutIds
                };
                if (timeoutIds[action][uid]) {
                    clearTimeout(timeoutIds[action][uid]);
                    delete timeoutIds[action][uid];
                }
                if (action === 'doubleCultivating') {
                    for (const [key, id] of Object.entries(doubleCultivationTimeoutIds)) {
                        if (id === doubleCultivationTimeoutIds[uid]) {
                            clearTimeout(id);
                            delete doubleCultivationTimeoutIds[key];
                            userActionStatus[key] = null;
                            lastActionTime[key] = null;
                        }
                    }
                }
            }
        });
        userActionStatus[uid] = null;
        lastActionTime[uid] = null;
        if (jailTime[uid]) {
            delete jailTime[uid];
            ext.storageSet("jailTime", JSON.stringify(jailTime));
        }
        ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
        ext.storageSet("lastActionTime", JSON.stringify(lastActionTime));
        seal.replyToSender(ctx, msg, "骰主特权：所有操作已强制结束，状态已重置。");
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdDiceMasterForceEnd = seal.ext.newCmdItemInfo();
    cmdDiceMasterForceEnd.name = "骰主强制结束";
    cmdDiceMasterForceEnd.solve = solveDiceMasterForceEnd;

    function solveWorldReset(ctx, msg) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        if (ctx.privilegeLevel != 100) {
            seal.replyToSender(ctx, msg, "只有骰主可以使用此指令。");
            return seal.ext.newCmdExecuteResult(true);
        }
        
        // 更新存储数据而不是直接赋值
        ext.storageSet("userData", "{}");
        ext.storageSet("lastActionTime", "{}");
        ext.storageSet("signInData", "{}");
        ext.storageSet("userActionStatus", "{}"); 
        ext.storageSet("earlyEndCount", "{}");
        ext.storageSet("forcedBreakthroughCount", "{}");
        ext.storageSet("lastActionResult", "{}");
        ext.storageSet("crimeValue", "{}");
        ext.storageSet("jailTime", "{}");
        ext.storageSet("jailCount", "{}");
        ext.storageSet("bondData", "{}");
        ext.storageSet("forceEndUsedDate", "{}");
        ext.storageSet("forceEndUsedCount", "{}");
    
        // 重新加载内存数据
        userData = JSON.parse(ext.storageGet("userData") || "{}");
        lastActionTime = JSON.parse(ext.storageGet("lastActionTime") || "{}");
        
    // 清空所有定时器
    for (const uid in cultivateTimeoutIds) clearTimeout(cultivateTimeoutIds[uid]);
    for (const uid in workTimeoutIds) clearTimeout(workTimeoutIds[uid]);
    for (const uid in doubleCultivationTimeoutIds) clearTimeout(doubleCultivationTimeoutIds[uid]);
    for (const uid in alchemyTimeoutIds) clearTimeout(alchemyTimeoutIds[uid]);

    seal.replyToSender(ctx, msg, "世界线已重置，所有用户数据已清零。");
    return seal.ext.newCmdExecuteResult(true);
    }  

const cmdWorldReset = seal.ext.newCmdItemInfo();
cmdWorldReset.name = "世界线重置";
cmdWorldReset.solve = solveWorldReset;
const beggingTimeoutIds = {};

function solveBegging(ctx, msg) {
    if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
    const uid = ctx.player.userId.toString();
    if (checkInJail(uid)) {
        seal.replyToSender(ctx, msg, "前辈，您正在大牢中，无法乞讨。");
        return seal.ext.newCmdExecuteResult(true);
    }
    if (checkDoubleCultivating(uid)) {
        seal.replyToSender(ctx, msg, "前辈，您正在双修中，无法乞讨。");
        return seal.ext.newCmdExecuteResult(true);
    }
    if (userActionStatus[uid] === 'cultivating' || userActionStatus[uid] === 'working' || userActionStatus[uid] === 'alchemy' || userActionStatus[uid] === 'begging') {
        seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，结束后才能开始乞讨。");
        return seal.ext.newCmdExecuteResult(true);
    }
    const now = Date.now();
    if (lastActionTime[uid] && now - lastActionTime[uid] < 600000) { // 10分钟 = 600000毫秒
        seal.replyToSender(ctx, msg, "前辈，您正在进行其他行动，10分钟后再来乞讨吧");
        return seal.ext.newCmdExecuteResult(true);
    }

    // 10%概率被赶走
    const isDrivenAway = Math.random() < 0.1;
    if (isDrivenAway) {
        seal.replyToSender(ctx, msg, "前辈，您因扰乱市场风貌被赶走，无法开始乞讨。");
        return seal.ext.newCmdExecuteResult(true);
    }

    // 50%概率被抓进大牢
    const isArrested = Math.random() < 0.05;
    if (isArrested) {
        const now = Date.now();
        jailTime[uid] = now + 1800000; // 一小时
        jailCount[uid] = (jailCount[uid] || 0) + 1;
        ext.storageSet("jailTime", JSON.stringify(jailTime));
        ext.storageSet("jailCount", JSON.stringify(jailCount));
        seal.replyToSender(ctx, msg, "前辈，您因扰乱市场风貌被关进大牢了...一小时。");
        return seal.ext.newCmdExecuteResult(true);
    }

    lastActionTime[uid] = now;
    userActionStatus[uid] = 'begging';
    ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
    const timeoutId = setTimeout(() => {
        const increase = Math.floor(Math.random() * 50) + 1; // d50灵石
        userData[uid].spiritStones += increase;
        ext.storageSet("userData", JSON.stringify(userData));
        userActionStatus[uid] = null;
        ext.storageSet("userActionStatus", JSON.stringify(userActionStatus));
        lastActionResult[uid] = {
            action: 'begging',
            increase: increase
        };
        ext.storageSet("lastActionResult", JSON.stringify(lastActionResult));
        const userMention = `[CQ:at,qq=${ctx.player.userId.replace("QQ:","")}]`;
        const message = `${userMention} 您的乞讨已结束，恭喜，有人为您打赏 ${increase} 个灵石，当前灵石数量：${userData[uid].spiritStones}`;
        seal.replyToSender(ctx, msg, message);
    }, 600000);
    beggingTimeoutIds[uid] = timeoutId;
    seal.replyToSender(ctx, msg, `前辈，有手有脚的...开始乞讨了，去那边试试10分钟吧，别被抓了。`);
    return seal.ext.newCmdExecuteResult(true);
}

function checkAndNotifyRelease() {
    const now = Date.now();
    for (const uid in jailTime) {
        if (jailTime[uid] <= now) {
            delete jailTime[uid];
            ext.storageSet("jailTime", JSON.stringify(jailTime));
            // 添加模拟上下文参数
            const mockCtx = {
                group: {
                    groupId: ctx.group.groupId // 使用当前群组上下文
                }
            };
            const mockMsg = {
                messageType: 'group',
                groupId: ctx.group.groupId
            };
            const userMention = `[CQ:at,qq=${uid.replace("QQ:","")}]`;
            const deckResult = drawEventDeck(mockCtx, mockMsg, eventDecks.jailRelease);
            const message = `${userMention} 已经出狱\n${deckResult}`;
            seal.replyToSender(mockCtx, mockMsg, message);
        }
    }
}

const cmdBegging = seal.ext.newCmdItemInfo();
cmdBegging.name = "乞讨";
cmdBegging.solve = solveBegging;

// 丢鸡蛋指令
function solveThrowEgg(ctx, msg, cmdArgs) {
    // 检查用户是否已加入修真界
    if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
    const attacker = ctx.player.userId.toString();

    // 检查攻击者是否在大牢或双修中，若在则无法丢鸡蛋
    if (checkInJail(attacker) || checkDoubleCultivating(attacker)) {
        seal.replyToSender(ctx, msg, "前辈，您当前无法丢鸡蛋。");
        return seal.ext.newCmdExecuteResult(true);
    }

    // 获取被攻击的目标用户上下文
    const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
    if (!mctx) {
        seal.replyToSender(ctx, msg, "请@要丢鸡蛋的目标");
        return seal.ext.newCmdExecuteResult(true);
    }
    const target = mctx.player.userId.toString();

    // 检查目标是否在大牢中
    if (!checkInJail(target)) {
        const diceValue = Math.floor(Math.random() * 100) + 1;
        const SUCCESS_RATE = 50;
        const success = diceValue <= SUCCESS_RATE;

        if (success) {
            const amount = Math.floor(Math.random() * 50) + 1; // d50 灵石
            if (userData[attacker].spiritStones < amount) {
                amount = userData[attacker].spiritStones;
            }
            userData[attacker].spiritStones -= amount;
            userData[target].spiritStones += amount;
            ext.storageSet("userData", JSON.stringify(userData));
            seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】丢鸡蛋未砸中目标，您被要求赔偿 ${amount} 个灵石。`);
        } else {
            seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】丢鸡蛋未砸中目标，对方没有追究。`);
        }
        return seal.ext.newCmdExecuteResult(true);
    }

    // 目标在大牢中，进行砸中判断
    const diceValue = Math.floor(Math.random() * 100) + 1;
    const SUCCESS_RATE = 50;
    const success = diceValue <= SUCCESS_RATE;

    if (success) {
        const increase = Math.floor(Math.random() * 10) + 1; // d10 分钟
        jailTime[target] += increase * 60 * 1000; // 转换为毫秒
        ext.storageSet("jailTime", JSON.stringify(jailTime));
        seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】丢鸡蛋成功，目标监禁时间增加了 ${increase} 分钟。`);
    } else {
        seal.replyToSender(ctx, msg, `【幸运 ${diceValue}/${SUCCESS_RATE}】丢鸡蛋失败，目标安然无恙。`);
    }
    return seal.ext.newCmdExecuteResult(true);
}

const cmdThrowEgg = seal.ext.newCmdItemInfo();
cmdThrowEgg.name = "丢鸡蛋";
cmdThrowEgg.allowDelegate = true;
cmdThrowEgg.solve = solveThrowEgg;

// 使用道具指令
function solveUseItem(ctx, msg, cmdArgs) {
    if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
    const uid = ctx.player.userId.toString();
    const itemName = cmdArgs.getArgN(1);
    const amount = parseInt(cmdArgs.getArgN(2)) || 1; 

    if (!itemName) {
        seal.replyToSender(ctx, msg, "请指定要使用的道具名称。");
        return seal.ext.newCmdExecuteResult(true);
    }
    const user = userData[uid];
    const items = user.items || {};
    if (!items[itemName] || items[itemName] < amount) {
        seal.replyToSender(ctx, msg, `您的背包中没有足够的 ${itemName}。`);
        return seal.ext.newCmdExecuteResult(true);
    }

    switch (itemName) {
        case "强制掠夺": {
            const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
            if (!mctx) {
                seal.replyToSender(ctx, msg, "请@要掠夺的目标");
                return seal.ext.newCmdExecuteResult(true);
            }
            const target = mctx.player.userId.toString();
            if (!userData[target]) {
                seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
                return seal.ext.newCmdExecuteResult(true);
            }
            // 添加概率显示
            const successDice = Math.floor(Math.random() * 100) + 1;
            const SUCCESS_RATE = 65;
            const success = successDice <= SUCCESS_RATE;
            
            if (success) {
                if (userData[target].spiritStones >= 100) {
                    userData[uid].spiritStones += 100;
                    userData[target].spiritStones -= 100;
                    ext.storageSet("userData", JSON.stringify(userData));
                    seal.replyToSender(ctx, msg, `【掠夺 ${successDice}/${SUCCESS_RATE}】成功掠夺 ${userData[target].name} 100 灵石！`);
                } else {
                    seal.replyToSender(ctx, msg, `目标灵石不足，无法掠夺。`);
                }
            } else {
                // 添加监狱概率显示
                const jailDice = Math.floor(Math.random() * 100) + 1;
                const JAIL_RATE = 50;
                if (jailDice <= JAIL_RATE) {
                    const now = Date.now();
                    jailTime[uid] = now + 3600000;
                    jailCount[uid] = (jailCount[uid] || 0) + 1;
                    ext.storageSet("jailTime", JSON.stringify(jailTime));
                    ext.storageSet("jailCount", JSON.stringify(jailCount));
                    seal.replyToSender(ctx, msg, `【掠夺 ${successDice}/${SUCCESS_RATE}】失败，【监狱判定 ${jailDice}/${JAIL_RATE}】您被关进大牢一小时。`);
                } else {
                    seal.replyToSender(ctx, msg, `【掠夺 ${successDice}/${SUCCESS_RATE}】失败，幸运逃脱惩罚`);
                }
            }
            break;
        }
        case "vip房卡": {
            const vipStartTime = Date.now();
            const vipEndTime = vipStartTime + 60000; // 一分钟
            userData[uid].vipEndTime = vipEndTime;
            ext.storageSet("userData", JSON.stringify(userData));
            seal.replyToSender(ctx, msg, "您已使用 vip 房卡，一分钟内开启双修不扣灵石。");
            break;
        }
        case "监狱vip上房贵客卡": {
            const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
            if (!mctx) {
                seal.replyToSender(ctx, msg, "请@要指定的目标");
                return seal.ext.newCmdExecuteResult(true);
            }
            const target = mctx.player.userId.toString();
            if (!userData[target]) {
                seal.replyToSender(ctx, msg, "目标不存在或未加入修真界");
                return seal.ext.newCmdExecuteResult(true);
            }
            const success = Math.random() < 0.65;
            if (success) {
                const now = Date.now();
                jailTime[target] = now + 3600000; // 一小时
                jailCount[target] = (jailCount[target] || 0) + 1;
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                ext.storageSet("jailCount", JSON.stringify(jailCount));
                seal.replyToSender(ctx, msg, `成功将 ${userData[target].name} 关进大牢一小时。`);
            } else {
                const now = Date.now();
                jailTime[uid] = now + 3600000; // 一小时
                jailCount[uid] = (jailCount[uid] || 0) + 1;
                ext.storageSet("jailTime", JSON.stringify(jailTime));
                ext.storageSet("jailCount", JSON.stringify(jailCount));
                seal.replyToSender(ctx, msg, "指定失败，您被关进大牢一小时，害人终害已。");
            }
            break;
        }
        case "保释卡": {
            const mctx = seal.getCtxProxyFirst(ctx, cmdArgs);
            if (!mctx) {
                seal.replyToSender(ctx, msg, "请@要保释的目标");
                return seal.ext.newCmdExecuteResult(true);
            }
            const target = mctx.player.userId.toString();
            if (!checkInJail(target)) {
                seal.replyToSender(ctx, msg, "目标不在大牢中。");
                return seal.ext.newCmdExecuteResult(true);
            }
            delete jailTime[target];
            ext.storageSet("jailTime", JSON.stringify(jailTime));
            seal.replyToSender(ctx, msg, `成功保释 ${userData[target].name} 出狱，请好好改造。`);
            break;
        }
        case "成神丹": {
            const trueGodLevel = realmLevels.find(level => level.name === "真神");
            if (!trueGodLevel) {
                seal.replyToSender(ctx, msg, "当前世界线未开放真神境界");
                return seal.ext.newCmdExecuteResult(true);
            }
            // 获取用户当前境界索引
            const currentRealm = getCurrentRealm(userData[uid].cultivation);
            const currentIndex = realmLevels.indexOf(currentRealm);
            
            if (currentIndex >= realmLevels.indexOf(trueGodLevel)) {
                seal.replyToSender(ctx, msg, `您当前已是【${currentRealm.name}】，无法使用成神丹。`);
                return seal.ext.newCmdExecuteResult(true);
            }
            
            const success = Math.random() < 0.1;
            if (success) {
                userData[uid].cultivation = trueGodLevel.min;
                userData[uid].realmIndex = realmLevels.indexOf(trueGodLevel);
                ext.storageSet("userData", JSON.stringify(userData));
                seal.replyToSender(ctx, msg, "【天地异象】恭喜您突破桎梏，成功晋升真神境界！");
            } else {
                seal.replyToSender(ctx, msg, "磅礴药力在体内横冲直撞...最终未能突破瓶颈");
            }
            break;
        }  // 添加缺失的闭合括号
    }  // 闭合 switch 语句

    // 扣除道具数量（现在位于正确位置）
    items[itemName] -= amount;
    if (items[itemName] === 0) {
        delete items[itemName];
    }
    ext.storageSet("userData", JSON.stringify(userData));
    return seal.ext.newCmdExecuteResult(true);
}

const cmdUseItem = seal.ext.newCmdItemInfo();
cmdUseItem.name = "使用道具";
cmdUseItem.allowDelegate = true;
cmdUseItem.solve = solveUseItem;

    // 道具帮助指令
    function solveItemHelp(ctx, msg, cmdArgs) {
        if (!checkUserJoined(ctx, msg)) return seal.ext.newCmdExecuteResult(true);
        const itemName = cmdArgs.getArgN(1);
        
        if (!itemName) {
            seal.replyToSender(ctx, msg, "请指定要查询的道具名称，格式：.道具帮助 [道具名称]");
            return seal.ext.newCmdExecuteResult(true);
        }
        
        const item = itemData[itemName];
        if (!item) {
            seal.replyToSender(ctx, msg, `未找到名为【${itemName}】的道具信息`);
            return seal.ext.newCmdExecuteResult(true);
        }
        
        const helpText = `≡ ${item.name} ≡\n描述：${item.description}`;
        seal.replyToSender(ctx, msg, helpText);
        return seal.ext.newCmdExecuteResult(true);
    }

    const cmdItemHelp = seal.ext.newCmdItemInfo();
    cmdItemHelp.name = "道具帮助";
    cmdItemHelp.solve = solveItemHelp;

// 注册新指令
ext.cmdMap["使用道具"] = cmdUseItem;
    ext.cmdMap["赠送"] = cmdGiveFlower;
    ext.cmdMap["劫狱"] = cmdBreakout;
    ext.cmdMap["赎人"] = cmdRansom;
    ext.cmdMap["入狱排行榜"] = cmdRankJail;
    ext.cmdMap["开始炼丹"] = cmdAlchemy;
    ext.cmdMap["去商城"] = cmdShop;
    ext.cmdMap["查看背包"] = cmdCheckBag;
    ext.cmdMap["服用"] = cmdUsePill;
    ext.cmdMap["加入修真界"] = cmdJoin;
    ext.cmdMap["修仙报道"] = cmdSignIn;
    ext.cmdMap["开始修仙"] = cmdCultivate;
    ext.cmdMap["开始打工"] = cmdWork;
    ext.cmdMap["修仙排行榜"] = cmdRankCultivation;
    ext.cmdMap["灵石排行榜"] = cmdRankSpiritStones;
    ext.cmdMap["改名"] = cmdChangeName;
    ext.cmdMap["查看灵石"] = cmdCheckStones;
    ext.cmdMap["偷灵石"] = cmdStealStones;
    ext.cmdMap["抢灵石"] = cmdRobStones;
    ext.cmdMap["查看剩余时间"] = cmdCheckRemainingTime;
    ext.cmdMap["提前结束"] = cmdEarlyEnd;
    ext.cmdMap["查看修为"] = cmdCheckCultivation;
    ext.cmdMap["修仙帮助"] = cmdHelp; 
    ext.cmdMap["插旗"] = cmdFlag; 
    ext.cmdMap["查看报道天数"] = cmdCheckSignInDays; 
    ext.cmdMap["开始双修"] = cmdDoubleCultivation;
    ext.cmdMap["确认同意"] = cmdDoubleCultivationReply1;
    ext.cmdMap["拒绝双修"] = cmdDoubleCultivationReply2;
    ext.cmdMap["羁绊排行榜"] = cmdRankBond;
    ext.cmdMap["查看羁绊"] = cmdCheckBond;
    ext.cmdMap["强制结束"] = cmdForceEnd;
    ext.cmdMap["骰主强制结束"] = cmdDiceMasterForceEnd; 
    ext.cmdMap["世界线重置"] = cmdWorldReset; 
    ext.cmdMap["乞讨"] = cmdBegging;
    ext.cmdMap["丢鸡蛋"] = cmdThrowEgg;
    ext.cmdMap["道具帮助"] = cmdItemHelp;
}