koishi-plugin-deadcells-burst 0.1.0

package/lib/commands/alchemy.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerAlchemyCommand(ctx: Context, config: Config, busy: Set<string>): void;

package/lib/commands/alchemy.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAlchemyCommand = registerAlchemyCommand;
+const amulets_1 = require("../data/amulets");
+const player_1 = require("../utils/player");
+const image_1 = require("../output/image");
+function craftCount(value) {
+    if (value === undefined || value === null || value === '')
+        return 1;
+    const count = Number(value);
+    return Number.isInteger(count) && count >= 1 && count <= 5 ? count : undefined;
+}
+function registerAlchemyCommand(ctx, config, busy) {
+    ctx.command(`${config.commandAlchemy} [count:number]`)
+        .action(async ({ session }, countInput) => {
+        if (!session?.userId)
+            return '当前消息缺少用户身份，无法炼化护符。';
+        const count = craftCount(countInput);
+        if (!count)
+            return '护符炼化次数必须是 1-5 的整数。';
+        const player = await (0, player_1.getPlayer)(ctx, session.userId);
+        if (!player)
+            return '未找到用户数据哦，请先使用 deadcells 指令来创建角色！';
+        const totalCost = config.alchemyCost * count;
+        if (player.cells < totalCost)
+            return `当前细胞数不足，需要 ${totalCost} 个细胞才能炼化 ${count} 次。`;
+        if (busy.has(player.userId))
+            return '你当前正在进行其他操作，请稍后再试。';
+        busy.add(player.userId);
+        try {
+            await ctx.database.set('deadcells_players', { userId: player.userId }, { cells: player.cells - totalCost });
+            const generated = Array.from({ length: count }, () => (0, amulets_1.rollAmulet)(Math.random));
+            const selected = count === 1 ? generated[0] : undefined;
+            const card = config.enableImages
+                ? selected
+                    ? await (0, image_1.renderAmuletCard)(ctx, player, selected, totalCost)
+                    : await (0, image_1.renderAmuletChoicesCard)(ctx, player, generated, totalCost)
+                : undefined;
+            const text = count === 1
+                ? `【护符炼化】已消耗 ${totalCost} 个细胞！\n新护符词条：${selected.traits.join('、')}\n回复 y 替换当前护符，其他内容或超时则放弃。`
+                : `【护符炼化】已消耗 ${totalCost} 个细胞，生成 ${count} 个护符候选！\n${generated.map((amulet, index) => `${index + 1}. 词条：${amulet.traits.join('、')}`).join('\n')}\n回复 1-${count} 选择护符，其他内容或超时则放弃。`;
+            if (card)
+                await session.send(card);
+            else
+                await session.send(text);
+            const answer = await session.prompt(config.equipmentConfirmTimeout * 1000);
+            const selectedIndex = count === 1 ? 0 : Number.parseInt(answer?.trim() || '', 10) - 1;
+            if (!Number.isInteger(selectedIndex) || selectedIndex < 0 || selectedIndex >= generated.length)
+                return count === 1 ? '已放弃替换，炼化护符消失。' : '未选择有效护符，炼化结果消失。';
+            const selectedAmulet = generated[selectedIndex];
+            if (count > 1) {
+                await session.send(`已选择第 ${selectedIndex + 1} 个护符（词条：${selectedAmulet.traits.join('、')}），回复 y 替换当前护符，其他内容或超时则放弃。`);
+            }
+            const confirmation = count === 1 ? answer : await session.prompt(config.equipmentConfirmTimeout * 1000);
+            if (!confirmation || !['y', 'yes'].includes(confirmation.trim().toLowerCase()))
+                return '已放弃替换，炼化护符消失。';
+            await ctx.database.set('deadcells_players', { userId: player.userId }, {
+                amuletId: selectedAmulet.id,
+                amuletTraits: (0, amulets_1.serializeAmuletTraits)(selectedAmulet.traits),
+            });
+            return '护符已替换成功！';
+        }
+        finally {
+            busy.delete(player.userId);
+        }
+    });
+}

package/lib/commands/boss.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerBossCommand(ctx: Context, config: Config, busy: Set<string>): void;

package/lib/commands/boss.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBossCommand = registerBossCommand;
+const boss_1 = require("../core/boss");
+const exploration_dispatch_1 = require("../core/exploration-dispatch");
+const amulets_1 = require("../data/amulets");
+const image_1 = require("../output/image");
+const player_1 = require("../utils/player");
+const DIFFICULTY_NAMES = {
+    normal: '普通',
+    veteran: '历战',
+    'veteran-king': '历战王',
+};
+function choiceIndex(value, length) {
+    const index = Number.parseInt(value?.trim() || '', 10) - 1;
+    return Number.isInteger(index) && index >= 0 && index < length ? index : undefined;
+}
+function rankingForUser(rankings, userId, username, damage) {
+    const existing = rankings.find((item) => item.userId === userId);
+    if (existing) {
+        existing.damage += damage;
+        existing.username = username;
+    }
+    else {
+        rankings.push({ userId, username, damage });
+    }
+    return rankings;
+}
+function bossText(boss) {
+    const hp = Math.max(0, Math.round(boss.currentHp));
+    return `今日 Boss：【${boss.bossName}】（${boss.mapName}，${DIFFICULTY_NAMES[boss.difficulty]}）\nBoss 生命：${hp} / ${boss.maxHp}`;
+}
+async function sendBossCard(ctx, session, player, boss, result, rankings = (0, boss_1.parseBossRankings)(boss.rankings), completed = boss.completed) {
+    const card = await (0, image_1.renderBossRaidCard)(ctx, player, boss, result, rankings, completed);
+    if (card)
+        await session.send(card);
+    else {
+        const log = result?.events?.join('\n');
+        await session.send(`${bossText(boss)}${result ? `\n本次造成伤害：${result.damage}\n${log || ''}` : ''}${completed ? '\nBoss 已被讨伐。' : ''}`);
+    }
+}
+async function settleBossChoice(ctx, config, session, player, state, firstAnswer) {
+    if (state.date !== (0, exploration_dispatch_1.beijingDate)() || Date.now() > state.expiresAt) {
+        await ctx.database.set('deadcells_players', { userId: player.userId }, { bossChoiceState: null });
+        return '词条选择已超时，Boss 最后一击奖励失效。';
+    }
+    const selectedIndex = choiceIndex(firstAnswer, state.choices.length);
+    if (selectedIndex === undefined)
+        return `请选择 1-${state.choices.length} 其中一个词条。`;
+    const selectedTrait = state.choices[selectedIndex];
+    const currentTraits = (0, amulets_1.parseAmuletTraits)(player.amuletTraits);
+    let nextTraits;
+    let amuletId = player.amuletId;
+    if (currentTraits.length >= 2) {
+        await session.send('请选择替换第几个护符词条：\n1. 词条1\n2. 词条2');
+        const slotAnswer = await session.prompt(config.equipmentConfirmTimeout * 1000);
+        if (!slotAnswer) {
+            await ctx.database.set('deadcells_players', { userId: player.userId }, { bossChoiceState: null });
+            return '词条选择已超时，Boss 最后一击奖励失效。';
+        }
+        if (!['1', '2'].includes(slotAnswer.trim()))
+            return '请选择 1 或 2 替换护符词条。';
+        nextTraits = [...currentTraits];
+        nextTraits[Number(slotAnswer.trim()) - 1] = selectedTrait;
+    }
+    else if (currentTraits.length === 1) {
+        nextTraits = [...currentTraits, selectedTrait];
+    }
+    else {
+        amuletId = amuletId === 'prisoner-necklace' ? 'amulet-1' : amuletId;
+        nextTraits = [selectedTrait];
+    }
+    await ctx.database.set('deadcells_players', { userId: player.userId }, {
+        cells: player.cells + state.rewardCells,
+        amuletId,
+        amuletTraits: (0, amulets_1.serializeAmuletTraits)(nextTraits),
+        bossChoiceState: null,
+    });
+    const trait = (0, amulets_1.getAmuletTrait)(selectedTrait);
+    return `已获得 ${state.rewardCells} 个细胞，并装备词条【${trait?.name || selectedTrait}】。${currentTraits.length >= 2 ? '已替换选择的词条槽位。' : currentTraits.length === 1 ? '已装入第二个词条槽位。' : `已获得护符【${(0, amulets_1.getAmulet)(amuletId)?.name || '炼化护符'}】。`}`;
+}
+function registerBossCommand(ctx, config, busy) {
+    const raidLock = '__daily-boss-raid__';
+    const commandName = config.commandBoss || 'boss讨伐';
+    ctx.command(`${commandName} [choice:text]`)
+        .action(async ({ session }, choiceInput) => {
+        if (!session?.userId)
+            return '当前消息缺少用户身份，无法参加 Boss 讨伐。';
+        const player = await (0, player_1.getPlayer)(ctx, session.userId);
+        if (!player)
+            return '未找到用户数据哦，请先使用 deadcells 指令来创建角色！';
+        if (busy.has(player.userId))
+            return '你当前正在进行其他操作，请稍后再试。';
+        const pending = (0, boss_1.parseBossChoiceState)(player.bossChoiceState);
+        if (pending) {
+            busy.add(player.userId);
+            try {
+                let answer = choiceInput?.trim();
+                if (!answer) {
+                    const boss = await (0, boss_1.getOrCreateDailyBoss)(ctx);
+                    const card = config.enableImages ? await (0, image_1.renderBossTraitChoiceCard)(ctx, player, boss, pending.choices, pending.rewardCells, config.equipmentConfirmTimeout) : undefined;
+                    if (card)
+                        await session.send(card);
+                    else
+                        await session.send(`Boss 最后一击奖励：${pending.rewardCells} 个细胞\n${pending.choices.map((id, index) => `${index + 1}. ${(0, amulets_1.getAmuletTrait)(id)?.name || id}：${(0, amulets_1.getAmuletTrait)(id)?.description || ''}`).join('\n')}\n请回复 1-${pending.choices.length} 选择词条。`);
+                    answer = await session.prompt(config.equipmentConfirmTimeout * 1000);
+                }
+                return settleBossChoice(ctx, config, session, player, pending, answer);
+            }
+            finally {
+                busy.delete(player.userId);
+            }
+        }
+        const boss = await (0, boss_1.getOrCreateDailyBoss)(ctx);
+        if (boss.completed) {
+            await sendBossCard(ctx, session, player, boss, undefined, (0, boss_1.parseBossRankings)(boss.rankings), true);
+            return;
+        }
+        if (choiceInput?.trim())
+            return '当前没有待选择的 Boss 词条。';
+        if (Date.now() < player.lastBossRaidAt + config.bossRaidCooldownSeconds * 1000) {
+            const seconds = Math.ceil((player.lastBossRaidAt + config.bossRaidCooldownSeconds * 1000 - Date.now()) / 1000);
+            return `你还在 Boss 讨伐冷却中，请 ${seconds} 秒后再试。`;
+        }
+        if (busy.has(raidLock))
+            return '当前已有其他玩家正在讨伐今日 Boss，请稍后再试。';
+        busy.add(player.userId);
+        busy.add(raidLock);
+        let updatedBoss = boss;
+        try {
+            const result = (0, boss_1.simulateBossRaid)(player, boss, config);
+            const rankings = rankingForUser((0, boss_1.parseBossRankings)(boss.rankings), player.userId, player.username, result.damage);
+            const currentHp = Math.max(0, boss.currentHp - result.damage);
+            const killed = currentHp <= 0;
+            updatedBoss = {
+                ...boss,
+                currentHp,
+                completed: killed,
+                killerId: killed ? player.userId : boss.killerId,
+                killerName: killed ? player.username : boss.killerName,
+                rankings: (0, boss_1.serializeBossRankings)(rankings),
+            };
+            await ctx.database.set('deadcells_daily_bosses', { date: boss.date }, {
+                currentHp: updatedBoss.currentHp,
+                completed: updatedBoss.completed,
+                killerId: updatedBoss.killerId,
+                killerName: updatedBoss.killerName,
+                rankings: updatedBoss.rankings,
+            });
+            await ctx.database.set('deadcells_players', { userId: player.userId }, { lastBossRaidAt: Date.now() });
+            const reward = (0, boss_1.calculateBossReward)(player, result.damage, boss.rewardMultiplier);
+            if (killed) {
+                const state = {
+                    date: boss.date,
+                    choices: (0, boss_1.randomTraitChoices)(Math.random),
+                    rewardCells: reward,
+                    expiresAt: Date.now() + config.equipmentConfirmTimeout * 1000,
+                };
+                await ctx.database.set('deadcells_players', { userId: player.userId }, { bossChoiceState: (0, boss_1.serializeBossChoiceState)(state) });
+                const resultPlayer = { ...player, lastBossRaidAt: Date.now(), bossChoiceState: (0, boss_1.serializeBossChoiceState)(state) };
+                await sendBossCard(ctx, session, resultPlayer, updatedBoss, result, rankings, true);
+                const card = config.enableImages ? await (0, image_1.renderBossTraitChoiceCard)(ctx, resultPlayer, updatedBoss, state.choices, reward, config.equipmentConfirmTimeout) : undefined;
+                if (card)
+                    await session.send(card);
+                else
+                    await session.send(`最后一击奖励：${reward} 个细胞\n${state.choices.map((id, index) => `${index + 1}. ${(0, amulets_1.getAmuletTrait)(id)?.name || id}：${(0, amulets_1.getAmuletTrait)(id)?.description || ''}`).join('\n')}\n请回复 1-${state.choices.length} 选择词条。`);
+                return settleBossChoice(ctx, config, session, resultPlayer, state, await session.prompt(config.equipmentConfirmTimeout * 1000));
+            }
+            await ctx.database.set('deadcells_players', { userId: player.userId }, { cells: player.cells + reward, bossChoiceState: null });
+            const resultPlayer = { ...player, cells: player.cells + reward, lastBossRaidAt: Date.now() };
+            await sendBossCard(ctx, session, resultPlayer, updatedBoss, result, rankings, false);
+            return `本次获得 ${reward} 个细胞。`;
+        }
+        finally {
+            busy.delete(player.userId);
+            busy.delete(raidLock);
+        }
+    });
+}

package/lib/commands/character.d.ts

@@ -0,0 +1,3 @@
+import { type Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerCharacterCommand(ctx: Context, config: Config): void;

package/lib/commands/character.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCharacterCommand = registerCharacterCommand;
+const koishi_1 = require("koishi");
+const text_1 = require("../output/text");
+const image_1 = require("../output/image");
+const player_1 = require("../utils/player");
+function registerCharacterCommand(ctx, config) {
+    ctx.command(config.commandCharacter)
+        .action(async ({ session }) => {
+        if (!session?.userId)
+            return '当前消息缺少用户身份，无法创建角色。';
+        const userId = session.userId;
+        const username = session.username || userId;
+        const { player, created } = await (0, player_1.getOrCreatePlayer)(ctx, userId, username);
+        const prefix = created ? '未检测到数据，将创建角色……\n创建成功！' : '查询数据中……\n查到了！';
+        if (config.enableImages) {
+            const card = await (0, image_1.renderPlayerCard)(ctx, player);
+            if (card) {
+                return (0, koishi_1.h)('message', {}, [
+                    (0, koishi_1.h)('text', { content: `${prefix}\n` }),
+                    card,
+                ]);
+            }
+        }
+        return `${prefix}\n${(0, text_1.playerStatus)(player)}\n${(0, text_1.equipmentDescription)(player)}`;
+    });
+}

package/lib/commands/duel.d.ts

@@ -0,0 +1,3 @@
+import { type Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerDuelCommand(ctx: Context, config: Config, busy: Set<string>): void;

package/lib/commands/duel.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDuelCommand = registerDuelCommand;
+const koishi_1 = require("koishi");
+const equipment_1 = require("../data/equipment");
+const amulets_1 = require("../data/amulets");
+const battle_1 = require("../core/battle");
+const player_1 = require("../utils/player");
+const image_1 = require("../output/image");
+function lockKeys(a, b) {
+    return [a, b].sort();
+}
+function registerDuelCommand(ctx, config, busy) {
+    ctx.command(`${config.commandDuel} <target:text>`)
+        .example(`${config.commandDuel} @用户`)
+        .action(async ({ session }, targetInput) => {
+        if (!session?.userId)
+            return '当前消息缺少用户身份，无法发起对战。';
+        const userId = session.userId;
+        const target = await (0, player_1.parseAtTarget)(session, targetInput || '');
+        if (!target)
+            return '请使用 @用户 指定对战目标。';
+        if (target.userId === userId)
+            return '不可以和自己对战。';
+        const keys = lockKeys(userId, target.userId);
+        if (keys.some((key) => busy.has(key)))
+            return '你或对方正在进行其他操作，请稍后再试。';
+        keys.forEach((key) => busy.add(key));
+        try {
+            const first = await (0, player_1.getPlayer)(ctx, userId);
+            const second = await (0, player_1.getPlayer)(ctx, target.userId);
+            if (!first)
+                return '未找到你的角色数据，请先使用 deadcells 指令创建角色。';
+            if (!second)
+                return `未找到 ${target.username} 的角色数据，对方需要先使用 deadcells 指令。`;
+            const remaining = Math.max((0, player_1.cooldownRemaining)(first.lastBattleAt, config.battleCooldownSeconds), (0, player_1.cooldownRemaining)(second.lastBattleAt, config.battleCooldownSeconds));
+            if (remaining > 0)
+                return `你或对方处于对战冷却中，还需等待 ${Math.ceil(remaining / 1000)} 秒。`;
+            const result = (0, battle_1.simulateBattle)(first, second, config);
+            const now = Date.now();
+            const finalCells = new Map([
+                [result.attacker.userId, result.attacker.cells],
+                [result.defender.userId, result.defender.cells],
+            ]);
+            await ctx.database.set('deadcells_players', { userId: first.userId }, {
+                cells: finalCells.get(first.userId) ?? first.cells,
+                battleCount: first.battleCount + 1,
+                winCount: first.winCount + (result.winnerId === first.userId ? 1 : 0),
+                lastBattleAt: now,
+            });
+            await ctx.database.set('deadcells_players', { userId: second.userId }, {
+                cells: finalCells.get(second.userId) ?? second.cells,
+                battleCount: second.battleCount + 1,
+                winCount: second.winCount + (result.winnerId === second.userId ? 1 : 0),
+                lastBattleAt: now,
+            });
+            const winner = result.winnerId === first.userId ? first : second;
+            const copied = result.droppedEquipment;
+            const equipment = copied && copied.type !== 'amulet'
+                ? (0, equipment_1.getEquipment)(copied.id)
+                : !copied && Math.random() * 100 < config.equipmentDropRate
+                    ? (0, equipment_1.randomEquipment)(Math.random)
+                    : undefined;
+            const copiedAmulet = copied?.type === 'amulet' ? copied : undefined;
+            let currentEquipment;
+            let autoEquipped = false;
+            if (equipment) {
+                const currentId = equipment.type === 'weapon'
+                    ? winner.weaponId
+                    : equipment.type === 'offhand'
+                        ? winner.shieldId
+                        : winner.item1Id || winner.item2Id;
+                currentEquipment = (0, equipment_1.getEquipment)(currentId);
+                const field = equipment.type === 'weapon'
+                    ? 'weaponId'
+                    : equipment.type === 'offhand'
+                        ? 'shieldId'
+                        : !winner.item1Id
+                            ? 'item1Id'
+                            : !winner.item2Id
+                                ? 'item2Id'
+                                : undefined;
+                const canAutoEquip = equipment.type === 'item'
+                    ? !winner.item1Id || !winner.item2Id
+                    : !currentId;
+                if (field && canAutoEquip) {
+                    await ctx.database.set('deadcells_players', { userId: winner.userId }, { [field]: equipment.id });
+                    autoEquipped = true;
+                }
+            }
+            const battleCard = config.enableImages
+                ? await (0, image_1.renderBattleCard)(ctx, first, second, result)
+                : undefined;
+            if (battleCard) {
+                await session.send(battleCard);
+            }
+            else {
+                await session.send(`${result.events.map((event) => event.text).join('\n')}\n【战斗结算】${winner.username} 获胜！获得细胞【${result.cellTransfer}】。`);
+            }
+            if (!equipment && !copiedAmulet)
+                return;
+            if (equipment) {
+                const prompt = equipment.type === 'item' && !autoEquipped
+                    ? '当前两个道具槽均有装备，回复 1 替换道具1，回复 2 替换道具2，其他内容或超时放弃。'
+                    : undefined;
+                const equipmentCard = config.enableImages
+                    ? await (0, image_1.renderEquipmentDropCard)(ctx, winner, equipment, autoEquipped, currentEquipment, prompt)
+                    : undefined;
+                if (equipmentCard) {
+                    await session.send(equipmentCard);
+                }
+                else {
+                    await session.send(`【装备获取】恭喜 ${koishi_1.h.at(winner.userId)} 获得装备【${equipment.name}】！\n${equipment.description}\n${autoEquipped ? '已自动装备。' : prompt || '回复 y 替换当前装备，其他内容或超时放弃。'}`);
+                }
+                if (autoEquipped)
+                    return;
+                let field;
+                if (equipment.type === 'weapon')
+                    field = 'weaponId';
+                else if (equipment.type === 'offhand')
+                    field = 'shieldId';
+                else {
+                    const answer = await new Promise((resolve) => {
+                        let finished = false;
+                        const dispose = ctx.on('message', (incoming) => {
+                            if (incoming.userId !== winner.userId || incoming.channelId !== session.channelId)
+                                return;
+                            const value = incoming.content?.trim();
+                            if (value !== '1' && value !== '2')
+                                return;
+                            finished = true;
+                            dispose();
+                            resolve(value);
+                        });
+                        setTimeout(() => {
+                            if (finished)
+                                return;
+                            dispose();
+                            resolve(undefined);
+                        }, config.equipmentConfirmTimeout * 1000);
+                    });
+                    if (!answer)
+                        return '已放弃替换，掉落装备消失。';
+                    field = answer === '1' ? 'item1Id' : 'item2Id';
+                }
+                const accepted = equipment.type === 'item'
+                    ? true
+                    : await (0, player_1.confirmFromUser)(ctx, session.channelId, winner.userId, config.equipmentConfirmTimeout * 1000);
+                if (!accepted)
+                    return '已放弃替换，掉落装备消失。';
+                await ctx.database.set('deadcells_players', { userId: winner.userId }, { [field]: equipment.id });
+                return `装备已替换为【${equipment.name}】！`;
+            }
+            if (copiedAmulet) {
+                const traits = copiedAmulet.traits || [];
+                const amuletCard = config.enableImages
+                    ? await (0, image_1.renderAmuletDropCard)(ctx, winner, copiedAmulet.id, traits, false)
+                    : undefined;
+                if (amuletCard) {
+                    await session.send(amuletCard);
+                }
+                else {
+                    const amulet = (0, amulets_1.getAmulet)(copiedAmulet.id);
+                    await session.send(`【护符获取】${koishi_1.h.at(winner.userId)} 复制了【${amulet?.name || '炼化护符'}】及完整词条：${traits.join('、') || '无'}\n回复 y 替换当前护符，其他内容或超时放弃。`);
+                }
+                const accepted = await (0, player_1.confirmFromUser)(ctx, session.channelId, winner.userId, config.equipmentConfirmTimeout * 1000);
+                if (!accepted)
+                    return '已放弃替换，复制的护符消失。';
+                await ctx.database.set('deadcells_players', { userId: winner.userId }, {
+                    amuletId: copiedAmulet.id,
+                    amuletTraits: (0, amulets_1.serializeAmuletTraits)(traits),
+                });
+                return '护符及其完整词条已复制并装备！';
+            }
+        }
+        finally {
+            keys.forEach((key) => busy.delete(key));
+        }
+    });
+}

package/lib/commands/explore.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerExploreCommand(ctx: Context, config: Config, busy: Set<string>): void;

package/lib/commands/explore.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerExploreCommand = registerExploreCommand;
+const player_1 = require("../utils/player");
+const exploration_dispatch_1 = require("../core/exploration-dispatch");
+function registerExploreCommand(ctx, config, busy) {
+    ctx.command(config.commandExplore)
+        .action(async ({ session }) => {
+        if (!session?.userId)
+            return '当前消息缺少用户身份，无法进行修炼。';
+        const userId = session.userId;
+        const player = await (0, player_1.getPlayer)(ctx, userId);
+        if (!player)
+            return '未找到用户数据哦，请先使用 deadcells 指令来创建角色！';
+        const status = (0, exploration_dispatch_1.dispatchStatus)(player);
+        if (status)
+            return status;
+        if (!(0, exploration_dispatch_1.dailyExploreAvailable)(player, config))
+            return `今日修炼结算次数已达到上限（${config.dailyExploreLimit}次），请明天再来。`;
+        if (busy.has(player.userId))
+            return '你当前正在进行其他操作，请稍后再试。';
+        busy.add(player.userId);
+        try {
+            await session.send('准备进行探索了！\n想要以什么方式进行探索呢？\n【1】更多细胞\n【2】更深层数');
+            const answer = await session.prompt(config.equipmentConfirmTimeout * 1000);
+            const strategy = answer?.trim() === '2' ? 'depth' : answer?.trim() === '1' ? 'cells' : undefined;
+            if (!strategy)
+                return '已取消探索或策略选择超时。';
+            await (0, exploration_dispatch_1.startExploration)(ctx, config, player, strategy, session.channelId, session.guildId);
+            return `开始探索了！\n当前在【被囚者的牢房】探索！\n当前策略【${strategy === 'cells' ? '更多细胞' : '更深层数'}】生效中！`;
+        }
+        finally {
+            busy.delete(player.userId);
+        }
+    });
+}

package/lib/commands/forge.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerForgeCommand(ctx: Context, config: Config, busy: Set<string>): void;

package/lib/commands/forge.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerForgeCommand = registerForgeCommand;
+const equipment_1 = require("../data/equipment");
+const player_1 = require("../utils/player");
+const image_1 = require("../output/image");
+function choiceIndex(value, length) {
+    const index = Number.parseInt(value?.trim() || '', 10) - 1;
+    return Number.isInteger(index) && index >= 0 && index < length ? index : undefined;
+}
+function craftCount(value) {
+    if (value === undefined || value === null || value === '')
+        return 1;
+    const count = Number(value);
+    return Number.isInteger(count) && count >= 1 && count <= 5 ? count : undefined;
+}
+function registerForgeCommand(ctx, config, busy) {
+    ctx.command(`${config.commandForge} [count:number]`)
+        .action(async ({ session }, countInput) => {
+        if (!session?.userId)
+            return '当前消息缺少用户身份，无法锻造装备。';
+        const count = craftCount(countInput);
+        if (!count)
+            return '装备锻造次数必须是 1-5 的整数。';
+        const player = await (0, player_1.getPlayer)(ctx, session.userId);
+        if (!player)
+            return '未找到用户数据哦，请先使用 deadcells 指令来创建角色！';
+        const totalCost = config.forgeCost * count;
+        if (player.cells < totalCost)
+            return `当前细胞数不足，需要 ${totalCost} 个细胞才能锻造 ${count} 次。`;
+        if (busy.has(player.userId))
+            return '你当前正在进行其他操作，请稍后再试。';
+        busy.add(player.userId);
+        try {
+            await ctx.database.set('deadcells_players', { userId: player.userId }, { cells: player.cells - totalCost });
+            const choices = Array.from({ length: count }, () => (0, equipment_1.randomEquipmentChoices)(Math.random, 3)).flat();
+            const card = config.enableImages ? await (0, image_1.renderForgeCard)(ctx, player, choices, count, totalCost) : undefined;
+            if (card)
+                await session.send(card);
+            else
+                await session.send(`【装备锻造】已消耗 ${totalCost} 个细胞，生成 ${count} 组装备！\n${choices.map((item, index) => `第${Math.floor(index / 3) + 1}组-${index % 3 + 1}（总选项${index + 1}）【${item.name}】（${(0, equipment_1.equipmentTypeText)(item.type)}）${item.description}`).join('\n')}\n回复 1-${choices.length} 选择装备，其他内容放弃。`);
+            const selectedIndex = choiceIndex(await session.prompt(config.equipmentConfirmTimeout * 1000), choices.length);
+            if (selectedIndex === undefined)
+                return '已放弃锻造装备，消耗的细胞不返还。';
+            const selected = choices[selectedIndex];
+            let field;
+            if (selected.type === 'weapon')
+                field = 'weaponId';
+            else if (selected.type === 'offhand')
+                field = 'shieldId';
+            else {
+                if (!player.item1Id || !player.item2Id) {
+                    field = !player.item1Id ? 'item1Id' : 'item2Id';
+                    await ctx.database.set('deadcells_players', { userId: player.userId }, { [field]: selected.id });
+                    return `已选择装备【${selected.name}】，当前存在空道具槽，已自动装备到${field === 'item1Id' ? '道具1' : '道具2'}！`;
+                }
+                await session.send(`已选择装备【${selected.name}】，请选择替换哪一个道具：\n1. 道具1：【${equipmentName(player.item1Id)}】\n2. 道具2：【${equipmentName(player.item2Id)}】\n请回复 1 或 2。`);
+                const slot = await session.prompt(config.equipmentConfirmTimeout * 1000);
+                if (!['1', '2'].includes(slot?.trim() || ''))
+                    return '未选择有效道具槽位，锻造装备放弃。';
+                field = slot.trim() === '1' ? 'item1Id' : 'item2Id';
+            }
+            await ctx.database.set('deadcells_players', { userId: player.userId }, { [field]: selected.id });
+            return `已锻造并装备【${selected.name}】！`;
+        }
+        finally {
+            busy.delete(player.userId);
+        }
+    });
+}
+function equipmentName(id) {
+    return (0, equipment_1.getEquipment)(id)?.name || '无';
+}

package/lib/commands/index.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerCommands(ctx: Context, config: Config): void;

package/lib/commands/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = registerCommands;
+const character_1 = require("./character");
+const explore_1 = require("./explore");
+const upgrade_1 = require("./upgrade");
+const duel_1 = require("./duel");
+const alchemy_1 = require("./alchemy");
+const forge_1 = require("./forge");
+const boss_1 = require("./boss");
+function registerCommands(ctx, config) {
+    const busy = new Set();
+    (0, character_1.registerCharacterCommand)(ctx, config);
+    (0, explore_1.registerExploreCommand)(ctx, config, busy);
+    (0, upgrade_1.registerUpgradeCommand)(ctx, config, busy);
+    (0, duel_1.registerDuelCommand)(ctx, config, busy);
+    (0, alchemy_1.registerAlchemyCommand)(ctx, config, busy);
+    (0, forge_1.registerForgeCommand)(ctx, config, busy);
+    (0, boss_1.registerBossCommand)(ctx, config, busy);
+}

package/lib/commands/upgrade.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare function registerUpgradeCommand(ctx: Context, config: Config, busy: Set<string>): void;