koishi-plugin-interactive/lib/general-system.js

多功能互动型QQ机器人插件，支持猜数字、每日签到、幸运抽奖、积分商店、排行榜、成就系统、个人资料、随机互动、将军系统、修仙系统、每日提醒等功能

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GENERAL_RANKS = void 0;
exports.getUserRank = getUserRank;
exports.getSalary = getSalary;
exports.randomInt = randomInt;
exports.randomFloat = randomFloat;
exports.roundNumber = roundNumber;
exports.generateEnemyId = generateEnemyId;
exports.calculatePower = calculatePower;
exports.applyGeneralSystem = applyGeneralSystem;
// 将军系统职位配置
exports.GENERAL_RANKS = [
    { name: '组长', baseSoldiers: 3, maxGroups: 3 },
    { name: '班长', baseSoldiers: 10, maxGroups: 4 },
    { name: '排长', baseSoldiers: 40, maxGroups: 4 },
    { name: '连长', baseSoldiers: 160, maxGroups: 4 },
    { name: '营长', baseSoldiers: 640, maxGroups: 4 },
    { name: '团长', baseSoldiers: 2560, maxGroups: 4 },
    { name: '旅长', baseSoldiers: 10240, maxGroups: 4 },
    { name: '师长', baseSoldiers: 40960, maxGroups: 4 },
    { name: '军长', baseSoldiers: 163840, maxGroups: 4 },
    { name: '司令', baseSoldiers: 655360, maxGroups: 9 },
    { name: '统帅', baseSoldiers: 6553660, maxGroups: 10 }
];
// 获取用户当前职位和组数
function getUserRank(soldiers) {
    for (let i = exports.GENERAL_RANKS.length - 1; i >= 0; i--) {
        const rank = exports.GENERAL_RANKS[i];
        if (soldiers >= rank.baseSoldiers) {
            const group = Math.min(Math.floor(soldiers / rank.baseSoldiers), rank.maxGroups);
            return {
                name: `${group}${rank.name.charAt(0)}`,
                index: i,
                group
            };
        }
    }
    return { name: '无', index: -1, group: 0 };
}
// 获取下一职位信息
function getNextRankInfo(currentIndex, currentGroup) {
    if (currentIndex >= exports.GENERAL_RANKS.length - 1) {
        return { name: '最高职位', soldiersRequired: 0 };
    }
    const currentRank = exports.GENERAL_RANKS[currentIndex];
    const nextRank = exports.GENERAL_RANKS[currentIndex + 1];
    // 如果当前组数未达到最大组数，则下一职位是当前职位的下一组
    if (currentGroup < currentRank.maxGroups) {
        const nextGroup = currentGroup + 1;
        const soldiersRequired = nextGroup * currentRank.baseSoldiers;
        return {
            name: `${nextGroup}${currentRank.name.charAt(0)}`,
            soldiersRequired
        };
    }
    // 如果当前组数已达到最大组数，则下一职位是下一等级的第一组
    return {
        name: `1${nextRank.name.charAt(0)}`,
        soldiersRequired: nextRank.baseSoldiers
    };
}
// 生成等级范围显示格式的辅助函数
function generateRankRangeDisplay(rankIndex) {
    const rank = exports.GENERAL_RANKS[rankIndex];
    // 随机选择相邻的两个组数
    const group1 = randomInt(1, rank.maxGroups - 1);
    const group2 = group1 + 1;
    return `${group1}-${group2}`;
}
// 根据组数范围计算士兵数量范围
function calculateSoldierRange(rankIndex, groupRange) {
    const rank = exports.GENERAL_RANKS[rankIndex];
    const [minGroup, maxGroup] = groupRange.split('-').map(Number);
    return {
        min: minGroup * rank.baseSoldiers,
        max: maxGroup * rank.baseSoldiers
    };
}
// 获取俸禄数量
function getSalary(rankIndex) {
    const salaries = [30, 100, 300, 1000, 3000, 10000, 30000, 100000, 300000, 1000000, 3000000];
    return rankIndex >= 0 && rankIndex < salaries.length ? salaries[rankIndex] : 0;
}
// 生成随机数
function randomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
// 生成随机浮点数
function randomFloat(min, max) {
    return Math.random() * (max - min) + min;
}
// 根据用户等级生成敌人等级，提高遇到相近等级敌人的概率
function generateEnemyRankIndex(userRankIndex, minPossibleRank, maxPossibleRank) {
    // 确保范围在允许的最小和最大等级之间
    const effectiveMin = Math.max(minPossibleRank, 0);
    const effectiveMax = Math.min(maxPossibleRank, exports.GENERAL_RANKS.length - 1);
    // 如果用户等级不在允许范围内，直接随机生成
    if (userRankIndex < effectiveMin || userRankIndex > effectiveMax) {
        return randomInt(effectiveMin, effectiveMax);
    }
    // 生成随机数决定使用哪种概率分布
    const rand = Math.random();
    if (rand < 0.5) {
        // 50%的概率生成与用户等级相同的敌人
        return userRankIndex;
    }
    else if (rand < 0.8) {
        // 30%的概率生成与用户等级相邻的敌人（上下一级）
        const offset = randomInt(0, 1) * 2 - 1; // 生成-1或1
        const adjacentRank = userRankIndex + offset;
        // 确保在允许范围内
        if (adjacentRank >= effectiveMin && adjacentRank <= effectiveMax) {
            return adjacentRank;
        }
        // 如果越界，则使用用户等级
        return userRankIndex;
    }
    else {
        // 20%的概率完全随机
        return randomInt(effectiveMin, effectiveMax);
    }
}
// 取整函数
function roundNumber(num) {
    return Math.floor(num);
}
// 生成敌人ID
function generateEnemyId(length = 6) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
        result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
}
// 计算战力值
function calculatePower(soldiers, weapons, supplies) {
    // 限制武器数量不超过士兵数量
    const effectiveWeapons = Math.min(weapons, soldiers);
    const weaponsContribution = Math.floor(effectiveWeapons * 0.5);
    // 限制物资数量不超过士兵数量的10倍
    const effectiveSupplies = Math.min(supplies, soldiers * 10);
    const suppliesContribution = Math.floor(effectiveSupplies * 0.01);
    return Math.floor(soldiers + weaponsContribution + suppliesContribution);
}
// 检查用户是否初始化了将军系统
function checkGeneralSystemInitialized(user) {
    return !!user.generalSystem;
}
// 确保用户已初始化将军系统，如果未初始化则返回错误消息
function ensureGeneralSystemInitialized(user) {
    if (!checkGeneralSystemInitialized(user)) {
        return '您尚未初始化将军系统';
    }
    return null;
}
// 应用将军系统
function applyGeneralSystem(ctx) {
    // 获取用户数据
    async function getUserData(session) {
        const userId = session.userId;
        const platform = session.platform;
        if (!userId || !platform)
            throw new Error('无法获取用户信息');
        const [user] = await ctx.database.get('interactive_users', {
            id: userId,
            platform
        });
        if (user)
            return user;
        throw new Error('用户数据不存在');
    }
    // 更新用户数据
    async function updateUserData(user) {
        const { id, platform, ...updateData } = user;
        await ctx.database.set('interactive_users', {
            id: user.id,
            platform: user.platform
        }, updateData);
    }
    // 获取今天日期字符串
    function getToday() {
        const now = new Date();
        return `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()}`;
    }
    // 解析数量参数
    function parseAmount(param) {
        const amount = parseInt(param);
        return isNaN(amount) ? null : amount;
    }
    // 检查冷却时间和每日限制
    async function checkCommandLimits(session) {
        const user = await getUserData(session);
        const now = Date.now();
        const today = getToday();
        // 检查是否被监禁
        if (user.jailedUntil > now) {
            const remaining = Math.ceil((user.jailedUntil - now) / 1000 / 60);
            session.send(`⛔ 你正在小黑屋中，${remaining}分钟后才能重获自由！`);
            return false;
        }
        // 重置每日计数器
        if (user.lastCommandDate !== today) {
            user.dailyCommandCount = 0;
            user.lastCommandDate = today;
        }
        // 检查每日限制
        if (user.dailyCommandCount >= 50) {
            session.send(`今日使用次数已达上限（50次），请明天再来吧！`);
            return false;
        }
        // 检查冷却时间
        if (now - user.lastCommandTime < 5000) {
            const remaining = Math.ceil((5000 - (now - user.lastCommandTime)) / 1000);
            session.send(`操作太频繁啦，请 ${remaining} 秒后再试~`);
            return false;
        }
        // 更新计数器
        user.dailyCommandCount += 1;
        user.lastCommandTime = now;
        await updateUserData(user);
        return true;
    }
    // 统一的战斗处理函数
    async function handleBattle(session, user, enemyId, enemyType) {
        const error = ensureGeneralSystemInitialized(user);
        if (error)
            return error;
        const enemy = user.generalSystem.enemies[enemyId];
        if (!enemy || enemy.type !== enemyType) {
            return '未找到指定的敌人，可能已经过期或不存在';
        }
        // 计算双方战力
        const userPower = calculatePower(user.generalSystem.soldiers, user.generalSystem.weapons, user.generalSystem.supplies);
        const enemyPower = calculatePower(enemy.soldiers, enemy.weapons, enemy.supplies);
        // 计算战力差值百分比
        const powerDifference = Math.abs(userPower - enemyPower);
        const powerRatio = Math.min(userPower, enemyPower) / Math.max(userPower, enemyPower);
        // 战斗结果
        let result = `⚔️ 与${enemyType === 'bandit' ? '土匪' : '敌军'}的战斗 ⚔️\n\n`;
        result += `敌方情报:\n`;
        result += `${enemyType === 'bandit' ? '土匪' : '敌军'}等级: ${enemy.groupRange}${enemy.rank.charAt(0)}\n`;
        result += `${enemyType === 'bandit' ? '土匪' : '敌军'}人数: ${enemy.minSoldiers}-${enemy.maxSoldiers}\n`;
        result += `武器数量: ${enemy.weapons}\n`;
        result += `物资数量: ${enemy.supplies}\n\n`;
        // 判断胜负
        if (userPower > enemyPower) {
            // 计算战斗损失和战利品（确保胜利时盈利）
            const deadSoldiers = randomInt(1, Math.max(1, Math.floor(user.generalSystem.soldiers * 0.05)));
            const woundedSoldiers = randomInt(0, Math.max(1, Math.floor(user.generalSystem.soldiers * 0.1)));
            const prisonersCaptured = randomInt(1, Math.max(1, Math.floor(enemy.soldiers * 0.2)));
            const suppliesGained = randomInt(Math.floor(enemy.supplies * 0.1), Math.floor(enemy.supplies * 0.3));
            const weaponsGained = randomInt(Math.floor(enemy.weapons * 0.1), Math.floor(enemy.weapons * 0.3));
            const weaponsLost = randomInt(0, Math.max(1, Math.floor(user.generalSystem.weapons * 0.05)));
            const suppliesLost = randomInt(0, Math.max(1, Math.floor(user.generalSystem.supplies * 0.05)));
            // 计算奖励积分（战力差值越小，奖励越高）
            const basePoints = enemyType === 'bandit'
                ? Math.floor(Math.floor(enemy.soldiers / 5) + Math.floor(enemy.weapons / 3) + Math.floor(enemy.supplies / 10))
                : Math.floor(Math.floor(enemy.soldiers / 3) + Math.floor(enemy.weapons / 1.5) + Math.floor(enemy.supplies / 5));
            // 战力差值越小，奖励越高（最高2.5倍，最低1倍）
            const pointsMultiplier = Math.floor((1 + (1.5 - powerRatio * 1.5)) * 100) / 100;
            const pointsReward = Math.floor(basePoints * pointsMultiplier);
            // 更新用户数据
            user.generalSystem.soldiers -= deadSoldiers;
            user.generalSystem.wounded += woundedSoldiers;
            user.generalSystem.prisoners += prisonersCaptured;
            user.generalSystem.supplies = Math.max(0, user.generalSystem.supplies - suppliesLost + suppliesGained);
            user.generalSystem.weapons = Math.max(0, user.generalSystem.weapons - weaponsLost + weaponsGained);
            user.points += pointsReward;
            // 移除敌人
            delete user.generalSystem.enemies[enemyId];
            await updateUserData(user);
            result += `🎉 战斗胜利！\n\n`;
            result += `战斗损失:\n`;
            result += `阵亡士兵: ${deadSoldiers}\n`;
            result += `受伤士兵: ${woundedSoldiers}\n\n`;
            result += `武器损失: ${weaponsLost}\n`;
            result += `物资损失: ${suppliesLost}\n\n`;
            result += `战利品:\n`;
            result += `俘虏: ${prisonersCaptured}\n`;
            result += `缴获武器: ${weaponsGained}\n`;
            result += `缴获物资: ${suppliesGained}\n`;
            result += `获得积分: ${pointsReward}\n\n`;
            result += `当前状态:\n`;
            result += `士兵: ${user.generalSystem.soldiers}\n`;
            result += `伤员: ${user.generalSystem.wounded}\n`;
            result += `俘虏: ${user.generalSystem.prisoners}\n`;
            result += `武器: ${user.generalSystem.weapons}\n`;
            result += `物资: ${user.generalSystem.supplies}\n`;
            result += `积分: ${user.points}`;
        }
        else {
            // 失败损失
            const deadSoldiers = randomInt(Math.max(1, Math.floor(user.generalSystem.soldiers * 0.1)), Math.max(1, Math.floor(user.generalSystem.soldiers * 0.3)));
            const woundedSoldiers = randomInt(Math.max(1, Math.floor(user.generalSystem.soldiers * 0.1)), Math.max(1, Math.floor(user.generalSystem.soldiers * 0.2)));
            const suppliesLost = randomInt(0, Math.max(1, Math.floor(user.generalSystem.supplies * 0.2)));
            const weaponsLost = randomInt(0, Math.max(1, Math.floor(user.generalSystem.weapons * 0.2)));
            // 更新用户数据
            user.generalSystem.soldiers -= deadSoldiers;
            user.generalSystem.wounded += woundedSoldiers;
            user.generalSystem.supplies = Math.max(0, user.generalSystem.supplies - suppliesLost);
            user.generalSystem.weapons = Math.max(0, user.generalSystem.weapons - weaponsLost);
            // 移除敌人
            delete user.generalSystem.enemies[enemyId];
            await updateUserData(user);
            result += `❌ 战斗失败！\n\n`;
            result += `战斗损失:\n`;
            result += `阵亡士兵: ${deadSoldiers}\n`;
            result += `受伤士兵: ${woundedSoldiers}\n`;
            result += `武器损失: ${weaponsLost}\n`;
            result += `物资损失: ${suppliesLost}\n\n`;
            result += `当前状态:\n`;
            result += `士兵: ${user.generalSystem.soldiers}\n`;
            result += `伤员: ${user.generalSystem.wounded}\n`;
            result += `武器: ${user.generalSystem.weapons}\n`;
            result += `物资: ${user.generalSystem.supplies}`;
        }
        return result;
    }
    // 将军系统主命令
    ctx.command('将军 <action:string> [param:string]', '将军系统')
        .usage('招兵: 将军 招兵 数量\n训练: 将军 训练新兵 数量\n购买: 将军 购买武器/物资 数量\n战斗: 将军 找土匪/敌军\n攻打: 将军 攻打土匪/敌军 代码\n俸禄: 将军 领取俸禄')
        .action(async ({ session }, action, param) => {
        if (!session)
            return '会话异常';
        if (!session.userId)
            return '无法获取用户ID';
        if (!action) {
            return `🎖️ 将军系统 🎖️
        
可用命令:
- 将军 招兵 <数量> - 招募新兵 (10积分/人)
- 将军 训练新兵 <数量> - 训练新兵成为士兵 (消耗武器和物资)
- 将军 购买武器 <数量> - 购买武器 (1积分/个)
- 将军 购买物资 <数量> - 购买物资 (1积分/个)
- 将军 训练俘虏 <数量> - 将俘虏训练为士兵
- 将军 治疗伤员 <数量> - 治疗伤员恢复为士兵
- 将军 找土匪 - 寻找土匪
- 将军 攻打土匪 <代码> - 攻打指定土匪
- 将军 找敌军 - 寻找敌军
- 将军 攻打敌军 <代码> - 攻打指定敌军
- 将军 领取俸禄 - 领取每日俸禄（可获得积分、士兵、武器和物资）
- 将军 状态 - 查看军队状态`;
        }
        if (!await checkCommandLimits(session))
            return;
        const user = await getUserData(session);
        // 处理带数量的命令
        const amountCommands = ['招兵', '训练新兵', '购买武器', '购买物资', '训练俘虏', '治疗伤员'];
        let amount;
        if (amountCommands.includes(action)) {
            const parsedAmount = parseAmount(param);
            if (parsedAmount === null || parsedAmount <= 0) {
                return `请输入正确的${action}数量`;
            }
            amount = parsedAmount;
        }
        // 初始化将军系统数据
        if (!user.generalSystem) {
            user.generalSystem = {
                soldiers: 0,
                newRecruits: 0,
                weapons: 0,
                supplies: 0,
                prisoners: 0,
                wounded: 0,
                lastSalaryDate: '',
                enemies: {}
            };
        }
        // 查看状态
        if (action === '状态') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            const rank = getUserRank(user.generalSystem.soldiers);
            const nextRankInfo = getNextRankInfo(rank.index, rank.group);
            let statusInfo = `🎖️ 军队状态 🎖️\n\n`;
            statusInfo += `当前职位: ${rank.name}\n`;
            statusInfo += `下一职位: ${nextRankInfo.name} (需要${nextRankInfo.soldiersRequired}士兵)\n`;
            statusInfo += `士兵数量: ${user.generalSystem.soldiers}\n`;
            statusInfo += `新兵数量: ${user.generalSystem.newRecruits}\n`;
            statusInfo += `武器数量: ${user.generalSystem.weapons}\n`;
            statusInfo += `物资数量: ${user.generalSystem.supplies}\n`;
            statusInfo += `俘虏数量: ${user.generalSystem.prisoners}\n`;
            statusInfo += `伤员数量: ${user.generalSystem.wounded}\n`;
            statusInfo += `战力值: ${calculatePower(user.generalSystem.soldiers, user.generalSystem.weapons, user.generalSystem.supplies)}\n`;
            statusInfo += `每日俸禄: ${getSalary(rank.index)} 积分，${Math.floor(getSalary(rank.index) * 0.01)} 士兵，${Math.floor(getSalary(rank.index) * 0.03)} 武器，${Math.floor(getSalary(rank.index) * 0.1)} 物资\n`;
            statusInfo += `俸禄状态: ${user.generalSystem.lastSalaryDate === getToday() ? '已领取' : '可领取'}`;
            return statusInfo;
        }
        // 招兵
        if (action === '招兵') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            const cost = amount * 10;
            if (user.points < cost) {
                return `积分不足！招募${amount}名新兵需要${cost}积分，你只有${user.points}积分`;
            }
            if (user.generalSystem.newRecruits > 100000) {
                return `新兵数量不能超过10万，当前新兵数量: ${user.generalSystem.newRecruits}`;
            }
            user.points -= cost;
            user.generalSystem.newRecruits += amount;
            await updateUserData(user);
            return `✅ 成功招募${amount}名新兵！\n` +
                `当前新兵数量: ${user.generalSystem.newRecruits}\n` +
                `剩余积分: ${user.points}`;
        }
        // 训练新兵
        if (action === '训练新兵') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            if (user.generalSystem.newRecruits < amount) {
                return `新兵不足！你只有${user.generalSystem.newRecruits}名新兵`;
            }
            const weaponsNeeded = amount;
            const suppliesNeeded = amount * 10;
            if (user.generalSystem.weapons < weaponsNeeded) {
                return `武器不足！训练${amount}名士兵需要${weaponsNeeded}个武器，你只有${user.generalSystem.weapons}个武器`;
            }
            if (user.generalSystem.supplies < suppliesNeeded) {
                return `物资不足！训练${amount}名士兵需要${suppliesNeeded}个物资，你只有${user.generalSystem.supplies}个物资`;
            }
            user.generalSystem.newRecruits -= amount;
            user.generalSystem.weapons -= weaponsNeeded;
            user.generalSystem.supplies -= suppliesNeeded;
            user.generalSystem.soldiers += amount;
            // 检查是否升职
            const oldRank = getUserRank(user.generalSystem.soldiers - amount);
            const newRank = getUserRank(user.generalSystem.soldiers);
            await updateUserData(user);
            let result = `✅ 成功训练${amount}名新兵成为士兵！\n` +
                `当前士兵数量: ${user.generalSystem.soldiers}\n` +
                `剩余新兵数量: ${user.generalSystem.newRecruits}\n` +
                `剩余武器数量: ${user.generalSystem.weapons}\n` +
                `剩余物资数量: ${user.generalSystem.supplies}`;
            if (newRank.index > oldRank.index || (newRank.index === oldRank.index && newRank.group > oldRank.group)) {
                result += `\n\n🎉 恭喜晋升为${newRank.name}！`;
            }
            return result;
        }
        // 购买武器
        if (action === '购买武器') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            const cost = amount;
            if (user.points < cost) {
                return `积分不足！购买${amount}个武器需要${cost}积分，你只有${user.points}积分`;
            }
            user.points -= cost;
            user.generalSystem.weapons += amount;
            await updateUserData(user);
            return `✅ 成功购买${amount}个武器！\n` +
                `当前武器数量: ${user.generalSystem.weapons}\n` +
                `剩余积分: ${user.points}`;
        }
        // 购买物资
        if (action === '购买物资') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            const cost = amount;
            if (user.points < cost) {
                return `积分不足！购买${amount}个物资需要${cost}积分，你只有${user.points}积分`;
            }
            user.points -= cost;
            user.generalSystem.supplies += amount;
            await updateUserData(user);
            return `✅ 成功购买${amount}个物资！\n` +
                `当前物资数量: ${user.generalSystem.supplies}\n` +
                `剩余积分: ${user.points}`;
        }
        // 训练俘虏
        if (action === '训练俘虏') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            if (user.generalSystem.prisoners < amount) {
                return `俘虏不足！你只有${user.generalSystem.prisoners}名俘虏`;
            }
            // 训练俘虏消耗的物资
            const weaponsNeeded = amount;
            const suppliesNeeded = amount * 10;
            if (user.generalSystem.weapons < weaponsNeeded) {
                return `武器不足！训练${amount}名俘虏需要${weaponsNeeded}个武器，你只有${user.generalSystem.weapons}个武器`;
            }
            if (user.generalSystem.supplies < suppliesNeeded) {
                return `物资不足！训练${amount}名俘虏需要${suppliesNeeded}个物资，你只有${user.generalSystem.supplies}个物资`;
            }
            user.generalSystem.prisoners -= amount;
            user.generalSystem.supplies -= suppliesNeeded;
            user.generalSystem.soldiers += amount;
            // 检查是否升职
            const oldRank = getUserRank(user.generalSystem.soldiers - amount);
            const newRank = getUserRank(user.generalSystem.soldiers);
            await updateUserData(user);
            let result = `✅ 成功训练${amount}名俘虏成为士兵！\n` +
                `当前士兵数量: ${user.generalSystem.soldiers}\n` +
                `剩余俘虏数量: ${user.generalSystem.prisoners}\n` +
                `剩余物资数量: ${user.generalSystem.supplies}`;
            if (newRank.index > oldRank.index || (newRank.index === oldRank.index && newRank.group > oldRank.group)) {
                result += `\n\n🎉 恭喜晋升为${newRank.name}！`;
            }
            return result;
        }
        // 治疗伤员
        if (action === '治疗伤员') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            if (user.generalSystem.wounded < amount) {
                return `伤员不足！你只有${user.generalSystem.wounded}名伤员`;
            }
            // 治疗伤员消耗的物资
            const suppliesNeeded = amount * 10;
            if (user.generalSystem.supplies < suppliesNeeded) {
                return `物资不足！治疗${amount}名伤员需要${suppliesNeeded}个物资，你只有${user.generalSystem.supplies}个物资`;
            }
            user.generalSystem.wounded -= amount;
            user.generalSystem.supplies -= suppliesNeeded;
            user.generalSystem.soldiers += amount;
            await updateUserData(user);
            return `✅ 成功治疗${amount}名伤员！\n` +
                `当前士兵数量: ${user.generalSystem.soldiers}\n` +
                `剩余伤员数量: ${user.generalSystem.wounded}\n` +
                `剩余物资数量: ${user.generalSystem.supplies}`;
        }
        // 找土匪
        if (action === '找土匪') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            // 清除所有敌人信息，重新开始
            user.generalSystem.enemies = {};
            const now = Date.now();
            // 获取用户当前等级
            const userRank = getUserRank(user.generalSystem.soldiers);
            // 生成土匪等级（师长及以下，避免生成军长）
            const maxRankIndex = 7; // 师长
            // 使用新函数生成土匪等级，提高遇到相近等级的概率
            const banditRankIndex = generateEnemyRankIndex(userRank.index, 0, maxRankIndex);
            const banditRank = exports.GENERAL_RANKS[banditRankIndex];
            // 生成组数范围（相邻的两个组数）
            const groupRange = generateRankRangeDisplay(banditRankIndex);
            // 计算士兵数量范围
            const soldierRange = calculateSoldierRange(banditRankIndex, groupRange);
            const soldiers = randomInt(soldierRange.min, soldierRange.max);
            // 生成武器和物资
            const weapons = Math.floor(soldiers * Math.floor(randomFloat(0.5, 1.5) * 100) / 100);
            const supplies = Math.floor(soldiers * Math.floor(randomFloat(5, 15) * 100) / 100);
            // 生成唯一ID
            const banditId = generateEnemyId();
            // 保存土匪信息（1小时有效）
            user.generalSystem.enemies[banditId] = {
                id: banditId,
                type: 'bandit',
                soldiers,
                weapons,
                supplies,
                minSoldiers: soldierRange.min,
                maxSoldiers: soldierRange.max,
                rank: banditRank.name,
                rankIndex: banditRankIndex,
                groupRange: groupRange,
                expireTime: now + 3600000 // 1小时后过期
            };
            await updateUserData(user);
            return `🔍 发现一群土匪！\n\n` +
                `土匪等级: ${groupRange}${banditRank.name.charAt(0)}\n` +
                `预估人数: ${soldierRange.min}-${soldierRange.max}\n` +
                `武器数量: 不详\n` +
                `物资数量: 不详\n\n` +
                `土匪代码: ${banditId}\n` +
                `使用 "将军 攻打土匪 ${banditId}" 来发起进攻`;
        }
        // 找敌军
        if (action === '找敌军') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            // 清除所有敌人信息，重新开始
            user.generalSystem.enemies = {};
            const now = Date.now();
            // 获取用户当前等级
            const userRank = getUserRank(user.generalSystem.soldiers);
            // 生成敌军等级（军长及以上，统帅以下）
            const minRankIndex = 8; // 军长
            const maxRankIndex = 10; // 统帅
            // 使用新函数生成敌军等级，提高遇到相近等级的概率
            const enemyRankIndex = generateEnemyRankIndex(userRank.index, minRankIndex, maxRankIndex);
            const enemyRank = exports.GENERAL_RANKS[enemyRankIndex];
            // 生成组数范围（相邻的两个组数）
            const groupRange = generateRankRangeDisplay(enemyRankIndex);
            // 计算士兵数量范围
            const soldierRange = calculateSoldierRange(enemyRankIndex, groupRange);
            const soldiers = randomInt(soldierRange.min, soldierRange.max);
            // 生成武器和物资
            const weapons = Math.floor(soldiers * Math.floor(randomFloat(0.8, 1.2) * 100) / 100);
            const supplies = Math.floor(soldiers * Math.floor(randomFloat(10, 20) * 100) / 100);
            // 生成唯一ID
            const enemyId = generateEnemyId();
            // 保存敌军信息（1小时有效）
            user.generalSystem.enemies[enemyId] = {
                id: enemyId,
                type: 'enemy',
                soldiers,
                weapons,
                supplies,
                minSoldiers: soldierRange.min,
                maxSoldiers: soldierRange.max,
                rank: enemyRank.name,
                rankIndex: enemyRankIndex,
                groupRange: groupRange,
                expireTime: now + 3600000 // 1小时后过期
            };
            await updateUserData(user);
            return `🔍 发现一支敌军！\n\n` +
                `敌军等级: ${groupRange}${enemyRank.name.charAt(0)}\n` +
                `预估人数: ${soldierRange.min}-${soldierRange.max}\n` +
                `武器数量: 不详\n` +
                `物资数量: 不详\n\n` +
                `敌军代码: ${enemyId}\n` +
                `使用 "将军 攻打敌军 ${enemyId}" 来发起进攻`;
        }
        // 攻打土匪
        if (action === '攻打土匪' && param) {
            return handleBattle(session, user, param, 'bandit');
        }
        // 攻打敌军
        if (action === '攻打敌军' && param) {
            return handleBattle(session, user, param, 'enemy');
        }
        // 领取俸禄
        if (action === '领取俸禄') {
            const error = ensureGeneralSystemInitialized(user);
            if (error)
                return error;
            const today = getToday();
            if (user.generalSystem.lastSalaryDate === today) {
                return '今天已经领取过俸禄了，明天再来吧！';
            }
            const rank = getUserRank(user.generalSystem.soldiers);
            const salary = getSalary(rank.index);
            const soldiers = Math.floor(salary * 0.01); // 获得士兵数量为俸禄的1%
            const weapons = Math.floor(salary * 0.01); // 获得武器数量为俸禄的1%
            const supplies = Math.floor(salary * 0.1); // 获得物资数量为俸禄的10%
            user.points += salary;
            user.generalSystem.soldiers += soldiers;
            user.generalSystem.weapons += weapons;
            user.generalSystem.supplies += supplies;
            user.generalSystem.lastSalaryDate = today;
            await updateUserData(user);
            return `✅ 成功领取今日俸禄！\n\n` +
                `当前职位: ${rank.name}\n` +
                `获得积分: ${salary}\n` +
                `获得士兵: ${soldiers}\n` +
                `获得武器: ${weapons}\n` +
                `获得物资: ${supplies}\n\n` +
                `当前状态:\n` +
                `积分: ${user.points}\n` +
                `士兵: ${user.generalSystem.soldiers}\n` +
                `武器: ${user.generalSystem.weapons}\n` +
                `物资: ${user.generalSystem.supplies}`;
        }
    });
}