@sdd330dev/jy-skill 0.3.0 → 0.3.1

package/AGENTS.md

@@ -98,6 +98,8 @@ saveGameState(state)  // 可选
 2. 显示结算（等级、存活周数、银两）
 3. 调用 `restartGame()`（勿只删档不落盘）
 
+**昏迷期间**不可休息、移动、购物或战斗；休息不能复活。
+
 玩家主动「重新开始」时同样使用 `restartGame()`。
 
 ## 叙述要点

package/README.md

@@ -34,7 +34,9 @@
 
 ## 安装
 
-### npm（推荐）
+包已发布至 npm：**[@sdd330dev/jy-skill](https://www.npmjs.com/package/@sdd330dev/jy-skill)**
+
+### 项目内安装（推荐）
 
 在 Cursor 项目根目录执行：
 
@@ -43,32 +45,74 @@ npm install @sdd330dev/jy-skill --save-dev
 npx jy-skill install
 ```
 
-安装到**全局** Cursor skills（所有项目可用）：
+使用 pnpm 或 yarn：
+
+```bash
+pnpm add -D @sdd330dev/jy-skill && pnpm exec jy-skill install
+# 或
+yarn add -D @sdd330dev/jy-skill && yarn jy-skill install
+```
+
+安装完成后，目录结构如下：
+
+```
+你的项目/
+└── .cursor/skills/jy/    ← SKILL.md、assets/、scripts/ 等
+```
+
+在 Cursor 中打开该项目，对话里说 **`jy`** 或 **「开始游戏」** 即可。
+
+### 全局安装（所有项目可用）
 
 ```bash
 npm install -g @sdd330dev/jy-skill
 jy-skill install --global
 ```
 
-CLI 会将 skill 安装到 `.cursor/skills/jy` 或 `~/.cursor/skills/jy`（与 SKILL 名称 `jy` 一致）。已存在时需加 `--force` 覆盖；Windows 下可加 `--copy` 强制复制。
+skill 将安装到 `~/.cursor/skills/jy`，任意 Cursor 项目均可加载。
+
+### CLI 选项
+
+| 选项 | 说明 |
+|------|------|
+| `--global` | 安装到 `~/.cursor/skills/jy` 而非当前项目 |
+| `--force` | 覆盖已存在的 skill 目录 |
+| `--copy` | 强制复制文件（默认优先 symlink；Windows 无权限时自动 fallback） |
+
+示例：`npx jy-skill install --force --copy`
+
+> **注意**：`npm install` 只把包放入 `node_modules`，不会自动写入 `.cursor/`。必须再执行 **`jy-skill install`**（无 postinstall，避免 monorepo/CI 误写配置）。
+
+### 其他安装方式
+
+**GitHub Release（离线 / 无 npm）**
+
+从 [Releases](https://github.com/sdd330/jy-skill/releases) 下载 `jy-skill.zip`，解压后：
+
+```bash
+mkdir -p .cursor/skills
+unzip jy-skill.zip -d .cursor/skills/jy
+```
 
-### 从源码开发
+**从源码开发**
 
-克隆本仓库后在本目录用 pnpm 开发与测试（见下方「开发与测试」）。也可手动复制：
+克隆本仓库，在本目录用 pnpm 开发与测试（见下方「开发与测试」）。本地调试也可手动链接：
 
 ```bash
-mkdir -p .cursor/skills && cp -R /path/to/jy .cursor/skills/jy
+mkdir -p .cursor/skills
+ln -s "$(pwd)" .cursor/skills/jy   # macOS / Linux
+# Windows 或 symlink 失败时：cp -R . .cursor/skills/jy
 ```
 
-### GitHub Release 与 npm
+### 发布与版本
 
-Git tag（`v*`）触发 [Release 工作流](.github/workflows/release.yml)，生成 `jy-skill.zip` 并同步发布到 [npm @sdd330dev/jy-skill](https://www.npmjs.com/package/@sdd330dev/jy-skill)（需配置 `NPM_TOKEN`）。
+Git tag（`v*`）触发 [Release 工作流](.github/workflows/release.yml)，生成 `jy-skill.zip` 并同步发布到 [npm @sdd330dev/jy-skill](https://www.npmjs.com/package/@sdd330dev/jy-skill)（GitHub Secrets 需配置 `NPM_TOKEN`）。
 
-### 维护者：本机发布到 npm
+**维护者：本机发布到 npm**
 
 ```bash
 pnpm run ci
-npm login
+# 使用 Granular Access Token（Publish + Bypass 2FA），或 npm login 后带 OTP：
 npm publish --access public   # 或 pnpm run publish:npm
 ```
 

package/SKILL.md

@@ -5,7 +5,7 @@ description: >-
   Agent 须读 references/agent-handbook.md 掌握完整玩法与 API；玩家说 jy/开始游戏/帮助/金庸群侠传时使用。
 license: MIT
 metadata:
-  version: "0.3.0"
+  version: "0.3.1"
 disable-model-invocation: false
 ---
 

package/assets/templates.json

@@ -52,8 +52,8 @@
     "山贼": { "characterId": 200 },
     "强盗": { "characterId": 201 },
     "武林高手": { "characterId": 202 },
-    "老虎": { "hp": 150, "attack": 35, "defence": 20, "solo": true },
-    "毒蛇": { "hp": 60, "attack": 10, "defence": 5, "solo": true }
+    "老虎": { "hp": 150, "attack": 35, "defence": 20, "solo": true, "onHitHurt": 10 },
+    "毒蛇": { "hp": 60, "attack": 10, "defence": 5, "solo": true, "onHitPoison": 15 }
   },
   "defaultInventory": {
     "silver": 100,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdd330dev/jy-skill",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "金庸群侠传 Cursor Agent Skill — 对话式武侠 RPG，自然语言驱动移动、战斗与存档",
   "type": "module",
   "license": "MIT",

package/references/agent-handbook.md

@@ -113,7 +113,8 @@ getStatus(state) 生成状态栏，附在回复末尾
 - 新角色默认：**基本拳法**（不耗内力）。
 - **`learnSkill`**：武功须存在于 `assets/skills.json`；已学会则失败。
 - **`useSkillInBattle`**：须已学会且内力 ≥ 消耗；消耗公式见 `game-logic.ts`。
-- **已知限制**：战斗中 `skillLevels` 暂不增长（等级恒为 0 索引）。
+- 武功 `skillLevels` 0–9 对应 Lv.1–10；每次战斗使用 +1~3 熟练度，满 100 升一级
+- 死亡后（hp≤0）不可休息、移动、战斗；须 `restartGame()`
 
 ---
 

package/references/player-guide.md

@@ -118,10 +118,11 @@
 
 ## 生存技巧
 
-- **移动**每次消耗 5 点体力，并推进 1 周；规划路线，避免体力耗尽困在途中。
-- **干粮**恢复体力，**金创药**恢复生命，**小还丹**恢复内力；**解毒丸**可解除中毒。生命/内力/体力已满时不会浪费药品。
-- **休息**一次满血满内力满体力，并清除中毒、受伤（在任意地点可用）。
-- 中毒、受伤状态下每移动一周会持续掉血，宜尽快治疗或休息。
+- **移动**消耗体力（轻功越高消耗越低，约 3–7 点），并推进 1 周；体力不足时无法移动。
+- **干粮**恢复体力，**金创药**恢复生命，**小还丹**恢复内力；**解毒丸**可解除中毒。**大力丸**/**疾风丸**临时提升攻击/轻功（移动或休息后失效）。
+- **武功秘籍**（如九阴真经、独孤九剑剑谱）研读后可学会对应武功，需满足资质与经验要求。
+- **休息**一次满血满内力满体力，并清除中毒、受伤与临时增益（在任意地点可用）；**昏迷时无法休息**。
+- 中毒、受伤状态下每移动一周会持续掉血；**毒蛇**等敌人攻击可能使你中毒。
 - 死亡后当前存档清除，需从头开始；重要进度请多探索、少鲁莽涉险。
 
 ---

package/scripts/config-loader.ts

@@ -35,6 +35,13 @@ export interface ItemConfig {
   useAddMp: number;
   useAddStamina: number;
   useDePoison: number;
+  useAddAttack?: number;
+  useAddAgility?: number;
+  useAddDefence?: number;
+  useAddPoison?: number;
+  skillId?: number;
+  needIQ?: number;
+  needExp?: number;
 }
 
 export interface SkillConfig {
@@ -43,6 +50,7 @@ export interface SkillConfig {
   desc: string;
   mpCost: number;
   damageType: number;
+  poison?: number;
   levels: number[][];
 }
 
@@ -67,6 +75,8 @@ export interface EnemyTemplate {
   attack: number;
   defence: number;
   solo?: boolean;
+  onHitPoison?: number;
+  onHitHurt?: number;
 }
 
 export interface GameTemplates {
@@ -114,6 +124,7 @@ const mapsByName = new Map<string, MapInfo>();
 const itemsByName = new Map<string, ItemConfig>();
 const itemsById = new Map<number, ItemConfig>();
 const skillsByName = new Map<string, SkillConfig>();
+const skillsById = new Map<number, SkillConfig>();
 const charactersById = new Map<number, CharacterConfig>();
 const charactersByName = new Map<string, CharacterConfig>();
 const dialogsById = new Map<string, DialogConfig>();
@@ -185,7 +196,7 @@ function buildMapsFromConfig(): void {
             .filter((name): name is string => Boolean(name));
 
     const shops =
-      templateMap && templateMap.shops.length > 0 ? [...templateMap.shops] : [...shopNames];
+      templateMap && templateMap.shops?.length > 0 ? [...templateMap.shops] : [...shopNames];
 
     const encounterConfig = parseEncounters(templateMap?.encounters);
 
@@ -241,6 +252,7 @@ function loadSkills(): void {
   const data = loadJson<{ skills: SkillConfig[] }>('skills.json');
   for (const skill of data.skills) {
     skillsByName.set(skill.name, skill);
+    skillsById.set(skill.id, skill);
   }
 }
 
@@ -277,6 +289,7 @@ export function resetConfigsForTest(): void {
   itemsByName.clear();
   itemsById.clear();
   skillsByName.clear();
+  skillsById.clear();
   charactersById.clear();
   charactersByName.clear();
   dialogsById.clear();
@@ -311,6 +324,27 @@ export function getSkill(name: string): SkillConfig | undefined {
   return skillsByName.get(name);
 }
 
+export function getSkillById(id: number): SkillConfig | undefined {
+  initConfigs();
+  return skillsById.get(id);
+}
+
+/** damageType 数字 → calculateStaminaCost 字符串键 */
+export function mapDamageTypeToStaminaCost(damageType: number): string {
+  switch (damageType) {
+    case 1:
+      return 'absorbMp';
+    case 2:
+      return 'poison';
+    case 3:
+      return 'depoison';
+    case 4:
+      return 'heal';
+    default:
+      return 'normal';
+  }
+}
+
 export function getSkillAttackAtLevel(skillName: string, levelIndex = 0): number {
   const skill = getSkill(skillName);
   if (!skill || !skill.levels.length) return 0;
@@ -344,7 +378,21 @@ export function isArmor(item: ItemConfig): boolean {
 }
 
 export function isConsumable(item: ItemConfig): boolean {
-  return item.useAddHp > 0 || item.useAddMp > 0 || item.useAddStamina > 0 || item.useDePoison > 0;
+  return (
+    item.useAddHp > 0 ||
+    item.useAddMp > 0 ||
+    item.useAddStamina > 0 ||
+    item.useDePoison > 0 ||
+    (item.useAddAttack ?? 0) > 0 ||
+    (item.useAddAgility ?? 0) > 0 ||
+    (item.useAddDefence ?? 0) > 0 ||
+    (item.useAddPoison ?? 0) > 0 ||
+    isSkillBook(item)
+  );
+}
+
+export function isSkillBook(item: ItemConfig): boolean {
+  return item.type === 2 && (item.skillId ?? 0) > 0;
 }
 
 /** 校验 assets 完整性（CLI / CI 用） */

package/scripts/game-engine.ts

@@ -8,11 +8,15 @@ import {
   calculateDamage as calcDamage,
   getExpForLevel,
   calculateMpCost,
+  calculateStaminaCost,
   calculatePoisonDamage,
   calculateHurtDamage,
+  calculateMoveStaminaCost,
   DEFAULT_ATTRIBUTES,
   MAX_STAMINA,
   MAX_LEVEL,
+  MAX_SKILL_LEVEL,
+  MAX_INVENTORY_SIZE,
 } from './game-logic';
 import {
   initConfigs,
@@ -20,12 +24,15 @@ import {
   getMap,
   getItem,
   getSkill,
+  getSkillById,
   getSkillAttackAtLevel,
   getDialog,
   getEnemyTemplate,
   isWeapon,
   isArmor,
   isConsumable,
+  isSkillBook,
+  mapDamageTypeToStaminaCost,
 } from './config-loader';
 import type { GameState, BattleEnemy, Character } from './game-types';
 import {
@@ -46,6 +53,42 @@ function autoSave(state: GameState): void {
   saveGameState(state);
 }
 
+function assertAlive(state: GameState): { ok: true } | { ok: false; message: string } {
+  if (state.character.hp <= 0) {
+    return { ok: false, message: '你已昏迷，无法行动' };
+  }
+  return { ok: true };
+}
+
+function clearBuffs(state: GameState): void {
+  state.character.buffs = {};
+}
+
+function ensureSkillExp(state: GameState): void {
+  if (!state.character.skillExp) {
+    state.character.skillExp = {};
+  }
+}
+
+/** @internal 供单元测试覆盖防御性分支 */
+export function consumeItemStack(state: GameState, itemName: string): void {
+  const inv = state.inventory.items.find((i) => i.name === itemName);
+  if (!inv) return;
+  inv.count--;
+  if (inv.count <= 0) {
+    state.inventory.items = state.inventory.items.filter((i) => i.name !== itemName);
+  }
+}
+
+function resolveEnemyTemplateName(enemyDisplayName: string): string {
+  const templates = getTemplates().enemies;
+  if (templates[enemyDisplayName]) return enemyDisplayName;
+  for (const key of Object.keys(templates)) {
+    if (enemyDisplayName.startsWith(key)) return key;
+  }
+  return enemyDisplayName;
+}
+
 // ============================================================================
 // 初始化
 // ============================================================================
@@ -53,6 +96,7 @@ function autoSave(state: GameState): void {
 function buildCharacter(name: string): Character {
   const tpl = getTemplates();
   const attrs = { ...DEFAULT_ATTRIBUTES };
+  const defaultSkills = tpl.defaultCharacter.skills ?? ['基本拳法'];
   return {
     name,
     level: 1,
@@ -66,10 +110,10 @@ function buildCharacter(name: string): Character {
     hurt: 0,
     attributes: attrs,
     equipment: { weapon: null, armor: null },
-    skills: [...(tpl.defaultCharacter.skills ?? ['基本拳法'])],
-    skillLevels: Object.fromEntries(
-      (tpl.defaultCharacter.skills ?? ['基本拳法']).map((s) => [s, 0]),
-    ),
+    skills: [...defaultSkills],
+    skillLevels: Object.fromEntries(defaultSkills.map((s) => [s, 0])),
+    skillExp: Object.fromEntries(defaultSkills.map((s) => [s, 0])),
+    buffs: {},
   };
 }
 
@@ -123,6 +167,8 @@ export function getStatus(state: GameState): string {
     `❤️ ${c.hp}/${c.maxHp} | 💠 ${c.mp}/${c.maxMp} | ⚡ ${c.stamina}/${MAX_STAMINA}`,
     c.poison > 0 ? `🧪 中毒: ${c.poison}` : null,
     c.hurt > 0 ? `💊 受伤: ${c.hurt}` : null,
+    (c.buffs?.attack ?? 0) > 0 ? `⚔️ 攻加成: +${c.buffs!.attack}` : null,
+    (c.buffs?.agility ?? 0) > 0 ? `💨 轻功加成: +${c.buffs!.agility}` : null,
     `💰 ${state.inventory.silver} | 📍 ${state.location} | 📅 第${state.week}周`,
   ]
     .filter(Boolean)
@@ -160,7 +206,14 @@ export function getInventory(state: GameState): string {
 export function getSkills(state: GameState): string {
   const skills = state.character.skills;
   if (skills.length === 0) return '🥋 还没有学会任何武功';
-  return `🥋 武功:\n${skills.map((s) => `- ${s}`).join('\n')}`;
+  ensureSkillExp(state);
+  return `🥋 武功:\n${skills
+    .map((s) => {
+      const lv = (state.character.skillLevels[s] ?? 0) + 1;
+      const exp = state.character.skillExp![s] ?? 0;
+      return `- ${s} Lv.${lv}（熟练 ${exp}/100）`;
+    })
+    .join('\n')}`;
 }
 
 // ============================================================================
@@ -171,6 +224,9 @@ export function moveTo(
   state: GameState,
   destination: string,
 ): { success: boolean; message: string; encounter?: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   const map = getMap(state.location);
   if (!map) return { success: false, message: '当前位置未知' };
 
@@ -185,9 +241,15 @@ export function moveTo(
     return { success: false, message: `从${state.location}无法直达${destination}` };
   }
 
+  const moveCost = calculateMoveStaminaCost(getEffectiveAgility(state));
+  if (state.character.stamina < moveCost) {
+    return { success: false, message: `体力不足，需要${moveCost}点体力才能前往${destination}` };
+  }
+
   state.location = destination;
-  state.character.stamina = Math.max(0, state.character.stamina - 5);
+  state.character.stamina = Math.max(0, state.character.stamina - moveCost);
   state.week++;
+  clearBuffs(state);
   advanceWeekEffects(state);
 
   if (!state.visitedMaps.includes(destination)) {
@@ -249,6 +311,9 @@ export function talkTo(state: GameState, npcName: string): { success: boolean; m
 // ============================================================================
 
 export function buyItem(state: GameState, itemName: string): { success: boolean; message: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   const item = getItem(itemName);
   if (!item) return { success: false, message: `没有${itemName}出售` };
 
@@ -264,8 +329,13 @@ export function buyItem(state: GameState, itemName: string): { success: boolean;
     };
   }
 
-  state.inventory.silver -= item.price;
+  const totalItems = state.inventory.items.reduce((sum, i) => sum + i.count, 0);
   const existing = state.inventory.items.find((i) => i.name === itemName);
+  if (!existing && totalItems >= MAX_INVENTORY_SIZE) {
+    return { success: false, message: `背包已满（最多${MAX_INVENTORY_SIZE}种物品）` };
+  }
+
+  state.inventory.silver -= item.price;
   if (existing) {
     existing.count++;
   } else {
@@ -285,6 +355,9 @@ export function buyItem(state: GameState, itemName: string): { success: boolean;
 // ============================================================================
 
 export function useItem(state: GameState, itemName: string): { success: boolean; message: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   const inv = state.inventory.items.find((i) => i.name === itemName);
   if (!inv || inv.count <= 0) {
     return { success: false, message: `没有${itemName}` };
@@ -295,12 +368,40 @@ export function useItem(state: GameState, itemName: string): { success: boolean;
     return { success: false, message: `${itemName}无法使用` };
   }
 
+  // 武功秘籍
+  if (isSkillBook(item)) {
+    const skill = getSkillById(item.skillId!);
+    if (!skill) return { success: false, message: `${itemName}内容残缺，无法修习` };
+
+    const c = state.character;
+    if ((item.needIQ ?? 0) > c.attributes.iq) {
+      return { success: false, message: `资质不足，需要${item.needIQ}点资质才能研读${itemName}` };
+    }
+    if ((item.needExp ?? 0) > c.exp) {
+      return { success: false, message: `经验不足，需要${item.needExp}点经验才能研读${itemName}` };
+    }
+    if (c.skills.includes(skill.name)) {
+      return { success: false, message: `已经学会了${skill.name}` };
+    }
+
+    c.skills.push(skill.name);
+    c.skillLevels[skill.name] = 0;
+    ensureSkillExp(state);
+    state.character.skillExp![skill.name] = 0;
+    consumeItemStack(state, itemName);
+    autoSave(state);
+    return { success: true, message: `研读${itemName}，学会了${skill.name}` };
+  }
+
   const c = state.character;
+  if (!c.buffs) c.buffs = {};
   const parts: string[] = [];
   let hpGain = 0;
   let mpGain = 0;
   let staminaGain = 0;
   let poisonReduced = 0;
+  let buffAttack = 0;
+  let buffAgility = 0;
 
   if (item.useAddHp > 0) {
     hpGain = Math.min(item.useAddHp, c.maxHp - c.hp);
@@ -318,8 +419,23 @@ export function useItem(state: GameState, itemName: string): { success: boolean;
     poisonReduced = Math.min(item.useDePoison, c.poison);
     parts.push('解除中毒');
   }
+  if ((item.useAddAttack ?? 0) > 0) {
+    if ((c.buffs.attack ?? 0) > 0) {
+      return { success: false, message: `${itemName}效果仍在，无需重复使用` };
+    }
+    buffAttack = item.useAddAttack!;
+    parts.push(`攻击力临时+${buffAttack}`);
+  }
+  if ((item.useAddAgility ?? 0) > 0) {
+    if ((c.buffs.agility ?? 0) > 0) {
+      return { success: false, message: `${itemName}效果仍在，无需重复使用` };
+    }
+    buffAgility = item.useAddAgility!;
+    parts.push(`轻功临时+${buffAgility}`);
+  }
 
-  if (hpGain + mpGain + staminaGain + poisonReduced === 0) {
+  const totalGain = hpGain + mpGain + staminaGain + poisonReduced + buffAttack + buffAgility;
+  if (totalGain === 0) {
     if (item.useDePoison > 0 && c.poison <= 0) {
       return { success: false, message: '你没有中毒，无需使用解毒丸' };
     }
@@ -330,12 +446,10 @@ export function useItem(state: GameState, itemName: string): { success: boolean;
   c.mp += mpGain;
   c.stamina += staminaGain;
   c.poison -= poisonReduced;
+  if (buffAttack > 0) c.buffs.attack = buffAttack;
+  if (buffAgility > 0) c.buffs.agility = buffAgility;
 
-  inv.count--;
-  if (inv.count <= 0) {
-    state.inventory.items = state.inventory.items.filter((i) => i.name !== itemName);
-  }
-
+  consumeItemStack(state, itemName);
   autoSave(state);
   return { success: true, message: `使用${itemName}，${parts.join('，')}` };
 }
@@ -348,6 +462,9 @@ export function equipItem(
   state: GameState,
   itemName: string,
 ): { success: boolean; message: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   const inv = state.inventory.items.find((i) => i.name === itemName);
   if (!inv || inv.count <= 0) {
     return { success: false, message: `没有${itemName}` };
@@ -379,6 +496,9 @@ export function learnSkill(
   state: GameState,
   skillName: string,
 ): { success: boolean; message: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   if (!getSkill(skillName)) {
     return { success: false, message: `江湖上没有${skillName}这门武功` };
   }
@@ -388,6 +508,8 @@ export function learnSkill(
 
   state.character.skills.push(skillName);
   state.character.skillLevels[skillName] = 0;
+  ensureSkillExp(state);
+  state.character.skillExp![skillName] = 0;
   autoSave(state);
   return { success: true, message: `学会了${skillName}` };
 }
@@ -397,11 +519,15 @@ export function learnSkill(
 // ============================================================================
 
 export function rest(state: GameState): { success: boolean; message: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   state.character.hp = state.character.maxHp;
   state.character.mp = state.character.maxMp;
   state.character.stamina = MAX_STAMINA;
   state.character.poison = 0;
   state.character.hurt = 0;
+  clearBuffs(state);
 
   autoSave(state);
   return { success: true, message: '休息完毕，状态全满' };
@@ -415,6 +541,9 @@ export function startBattle(
   state: GameState,
   enemyName: string,
 ): { success: boolean; message: string; enemies?: BattleEnemy[] } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   const entry = getTemplates().enemies[enemyName];
   const template = getEnemyTemplate(enemyName);
   if (!template) {
@@ -442,11 +571,19 @@ export function attackEnemy(
   enemies: BattleEnemy[],
   targetIndex: number,
 ): { message: string; enemyDefeated: boolean; playerDamage: number } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { message: alive.message, enemyDefeated: false, playerDamage: 0 };
+
   const target = enemies[targetIndex];
   if (!target || target.hp <= 0) {
     return { message: '目标无效', enemyDefeated: false, playerDamage: 0 };
   }
 
+  const staminaCost = calculateStaminaCost('normal');
+  if (state.character.stamina < staminaCost) {
+    return { message: '体力不足，无法攻击', enemyDefeated: false, playerDamage: 0 };
+  }
+
   const damage = calcDamage(
     getEffectiveAttack(state),
     0,
@@ -456,7 +593,7 @@ export function attackEnemy(
   );
 
   target.hp = Math.max(0, target.hp - damage);
-  state.character.stamina = Math.max(0, state.character.stamina - 3);
+  state.character.stamina = Math.max(0, state.character.stamina - staminaCost);
 
   const defeated = target.hp <= 0;
   if (defeated) {
@@ -477,6 +614,9 @@ export function useSkillInBattle(
   skillName: string,
   targetIndex: number,
 ): { success: boolean; message: string } {
+  const alive = assertAlive(state);
+  if (!alive.ok) return { success: false, message: alive.message };
+
   if (!state.character.skills.includes(skillName)) {
     return { success: false, message: `没有学会${skillName}` };
   }
@@ -484,17 +624,52 @@ export function useSkillInBattle(
   const skill = getSkill(skillName);
   if (!skill) return { success: false, message: `未知武功${skillName}` };
 
-  const target = enemies[targetIndex];
-  if (!target || target.hp <= 0) {
-    return { success: false, message: '目标无效' };
-  }
-
   const levelIndex = state.character.skillLevels[skillName] ?? 0;
   const mpCost = calculateMpCost(skill.mpCost, levelIndex);
   if (state.character.mp < mpCost) {
     return { success: false, message: `内力不足，需要${mpCost}点内力` };
   }
 
+  const staminaCost = calculateStaminaCost(mapDamageTypeToStaminaCost(skill.damageType));
+  if (state.character.stamina < staminaCost) {
+    return { success: false, message: `体力不足，无法施展${skillName}` };
+  }
+
+  state.character.mp = Math.max(0, state.character.mp - mpCost);
+  state.character.stamina = Math.max(0, state.character.stamina - staminaCost);
+
+  // 自身目标类武功
+  if (skill.damageType === 3) {
+    const reduced = Math.min(state.character.poison, 50);
+    state.character.poison = Math.max(0, state.character.poison - reduced);
+    grantSkillExp(state, skillName);
+    autoSave(state);
+    return {
+      success: true,
+      message: reduced > 0 ? `使用${skillName}，解除了部分毒素` : `使用${skillName}，你并未中毒`,
+    };
+  }
+
+  if (skill.damageType === 4) {
+    const skillAttack = getSkillAttackAtLevel(skillName, levelIndex);
+    const healAmount = Math.min(skillAttack, state.character.maxHp - state.character.hp);
+    state.character.hp += healAmount;
+    grantSkillExp(state, skillName);
+    autoSave(state);
+    return {
+      success: true,
+      message:
+        healAmount > 0
+          ? `使用${skillName}，恢复${healAmount}点生命`
+          : `使用${skillName}，气血已足，无需治疗`,
+    };
+  }
+
+  const target = enemies[targetIndex];
+  if (!target || target.hp <= 0) {
+    return { success: false, message: '目标无效' };
+  }
+
   const skillAttack = getSkillAttackAtLevel(skillName, levelIndex);
   const damage = calcDamage(
     getEffectiveAttack(state),
@@ -505,18 +680,27 @@ export function useSkillInBattle(
   );
 
   target.hp = Math.max(0, target.hp - damage);
-  state.character.mp = Math.max(0, state.character.mp - mpCost);
-  state.character.stamina = Math.max(0, state.character.stamina - 3);
+
+  let extra = '';
+  if (skill.damageType === 1) {
+    const absorbed = Math.min(Math.floor(damage / 2), state.character.maxMp - state.character.mp);
+    state.character.mp += absorbed;
+    if (absorbed > 0) extra = `，吸取${absorbed}点内力`;
+  }
+  if (skill.damageType === 2) {
+    extra = '，敌人身中剧毒';
+  }
 
   const defeated = target.hp <= 0;
   if (defeated) {
     grantBattleExp(state, target.maxHp);
   }
+  grantSkillExp(state, skillName);
 
   autoSave(state);
   return {
     success: true,
-    message: `使用${skillName}攻击${target.name}，造成${damage}点伤害${defeated ? '，击败！' : ''}`,
+    message: `使用${skillName}攻击${target.name}，造成${damage}点伤害${extra}${defeated ? '，击败！' : ''}`,
   };
 }
 
@@ -524,6 +708,10 @@ export function enemyAttack(
   state: GameState,
   enemies: BattleEnemy[],
 ): { message: string; playerDefeated: boolean } {
+  if (state.character.hp <= 0) {
+    return { message: '', playerDefeated: true };
+  }
+
   const aliveEnemies = enemies.filter((e) => e.hp > 0);
   if (aliveEnemies.length === 0) return { message: '', playerDefeated: false };
 
@@ -532,19 +720,33 @@ export function enemyAttack(
 
   state.character.hp = Math.max(0, state.character.hp - damage);
 
+  const templateName = resolveEnemyTemplateName(enemy.name);
+  const template = getEnemyTemplate(templateName);
+  if (template?.onHitPoison) {
+    state.character.poison += template.onHitPoison;
+  }
+  if (template?.onHitHurt) {
+    state.character.hurt += template.onHitHurt;
+  }
+
+  let debuffMsg = '';
+  if (template?.onHitPoison) debuffMsg += '，你感到一阵麻痹';
+  if (template?.onHitHurt) debuffMsg += '，你受了内伤';
+
   autoSave(state);
   return {
-    message: `${enemy.name}攻击你，造成${damage}点伤害`,
+    message: `${enemy.name}攻击你，造成${damage}点伤害${debuffMsg}`,
     playerDefeated: state.character.hp <= 0,
   };
 }
 
 // ============================================================================
-// 状态辅助（原 game-state.ts 合并）
+// 状态辅助
 // ============================================================================
 
 export function advanceWeek(state: GameState): void {
   state.week++;
+  clearBuffs(state);
   advanceWeekEffects(state);
   autoSave(state);
 }
@@ -568,8 +770,12 @@ export function isDead(state: GameState): boolean {
 // 内部
 // ============================================================================
 
+function getEffectiveAgility(state: GameState): number {
+  return state.character.attributes.agility + (state.character.buffs?.agility ?? 0);
+}
+
 function getEffectiveAttack(state: GameState): number {
-  let attack = state.character.attributes.attack;
+  let attack = state.character.attributes.attack + (state.character.buffs?.attack ?? 0);
   const weapon = state.character.equipment.weapon;
   if (weapon) {
     const item = getItem(weapon);
@@ -589,10 +795,28 @@ function getEffectiveDefence(state: GameState): number {
 }
 
 function grantBattleExp(state: GameState, enemyMaxHp: number): void {
-  state.character.exp += 10 + enemyMaxHp / 10;
+  state.character.exp += Math.floor(10 + enemyMaxHp / 10);
   checkLevelUp(state);
 }
 
+function grantSkillExp(state: GameState, skillName: string): void {
+  ensureSkillExp(state);
+  const levels = state.character.skillLevels;
+  const levelIndex = levels[skillName] ?? 0;
+  if (levelIndex >= MAX_SKILL_LEVEL - 1) return;
+
+  const gain = Math.floor(Math.random() * 3) + 1;
+  state.character.skillExp![skillName] = (state.character.skillExp![skillName] ?? 0) + gain;
+
+  while (
+    state.character.skillExp![skillName] >= 100 &&
+    (levels[skillName] ?? 0) < MAX_SKILL_LEVEL - 1
+  ) {
+    state.character.skillExp![skillName] -= 100;
+    levels[skillName] = (levels[skillName] ?? 0) + 1;
+  }
+}
+
 function checkLevelUp(state: GameState): void {
   const c = state.character;
   let needed = getExpForLevel(c.level + 1);
@@ -605,11 +829,13 @@ function checkLevelUp(state: GameState): void {
     const attrGain = Math.floor(Math.random() * (Math.floor((iq - 10) / 20) + 2)) + 1;
 
     c.maxHp += (c.attributes.hpInc + Math.floor(Math.random() * 4)) * 3;
-    c.maxMp += (9 - attrGain) * 4;
+    c.maxMp += Math.max(0, (9 - attrGain) * 4);
     c.attributes.attack += attrGain;
     c.attributes.agility += attrGain;
     c.attributes.defence += attrGain;
 
+    c.attributes.level = c.level;
+    c.attributes.exp = c.exp;
     c.hp = c.maxHp;
     c.mp = c.maxMp;
     needed = getExpForLevel(c.level + 1);

package/scripts/game-logic.ts

@@ -105,6 +105,11 @@ export function calculateMovePoints(agility: number): number {
   return Math.floor(agility / 15) + 3;
 }
 
+/** 地点移动体力消耗：轻功越高消耗越低，最低 3 */
+export function calculateMoveStaminaCost(agility: number): number {
+  return Math.max(3, 8 - Math.floor(agility / 15));
+}
+
 // ============================================================================
 // 默认属性
 // ============================================================================

package/scripts/game-types.ts

@@ -4,6 +4,11 @@
 
 import type { DEFAULT_ATTRIBUTES } from './game-logic';
 
+export interface CharacterBuffs {
+  attack?: number;
+  agility?: number;
+}
+
 export interface Character {
   name: string;
   level: number;
@@ -19,6 +24,8 @@ export interface Character {
   equipment: { weapon: string | null; armor: string | null };
   skills: string[];
   skillLevels: Record<string, number>;
+  skillExp?: Record<string, number>;
+  buffs?: CharacterBuffs;
 }
 
 export interface Inventory {

package/scripts/persistence.ts

@@ -13,7 +13,7 @@ import {
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { GameState } from './game-types';
-import { DEFAULT_ATTRIBUTES, MAX_STAMINA } from './game-logic';
+import { DEFAULT_ATTRIBUTES, MAX_STAMINA, MAX_LEVEL, MAX_EXP } from './game-logic';
 import { getMap, getTemplates, initConfigs } from './config-loader';
 
 export interface LoadGameResult {
@@ -30,13 +30,20 @@ export function getSavePath(): string {
   return SAVE_FILE;
 }
 
+function isFiniteNumber(n: unknown): n is number {
+  return typeof n === 'number' && Number.isFinite(n);
+}
+
 function isValidGameState(raw: unknown): raw is GameState {
   if (!raw || typeof raw !== 'object') return false;
   const state = raw as GameState;
-  if (!state.character?.name || typeof state.location !== 'string') return false;
-  if (!state.inventory || typeof state.inventory.silver !== 'number') return false;
+  const c = state.character;
+  if (!c?.name || typeof state.location !== 'string') return false;
+  if (!state.inventory || !isFiniteNumber(state.inventory.silver)) return false;
   if (!Array.isArray(state.inventory.items)) return false;
-  if (typeof state.week !== 'number') return false;
+  if (!isFiniteNumber(state.week)) return false;
+  if (!isFiniteNumber(c.hp) || !isFiniteNumber(c.mp)) return false;
+  if (!isFiniteNumber(c.stamina)) return false;
   return true;
 }
 
@@ -44,12 +51,30 @@ function isValidGameState(raw: unknown): raw is GameState {
 function migrateGameState(state: GameState): GameState {
   initConfigs();
 
-  if (!Array.isArray(state.character.skills)) {
+  if (typeof state.character.skills === 'string') {
+    state.character.skills = [state.character.skills];
+  } else if (!Array.isArray(state.character.skills)) {
     state.character.skills = [...(getTemplates().defaultCharacter.skills ?? ['基本拳法'])];
   }
   if (!state.character.skillLevels) {
     state.character.skillLevels = Object.fromEntries(state.character.skills.map((s) => [s, 0]));
   }
+  for (const skill of state.character.skills) {
+    if (state.character.skillLevels[skill] == null) {
+      state.character.skillLevels[skill] = 0;
+    }
+  }
+  if (!state.character.skillExp) {
+    state.character.skillExp = Object.fromEntries(state.character.skills.map((s) => [s, 0]));
+  }
+  for (const skill of state.character.skills) {
+    if (state.character.skillExp![skill] == null) {
+      state.character.skillExp![skill] = 0;
+    }
+  }
+  if (!state.character.buffs) {
+    state.character.buffs = {};
+  }
   if (!state.character.attributes || typeof state.character.attributes !== 'object') {
     state.character.attributes = { ...DEFAULT_ATTRIBUTES };
   } else {
@@ -74,11 +99,21 @@ function migrateGameState(state: GameState): GameState {
   const c = state.character;
   if (typeof c.maxHp !== 'number') c.maxHp = DEFAULT_ATTRIBUTES.maxHp;
   if (typeof c.maxMp !== 'number') c.maxMp = DEFAULT_ATTRIBUTES.maxMp;
+  c.level = Math.max(1, Math.min(MAX_LEVEL, Math.floor(c.level ?? 1)));
+  c.exp = Math.max(0, Math.min(MAX_EXP, Math.floor(c.exp ?? 0)));
   c.hp = Math.max(0, Math.min(c.maxHp, c.hp));
   c.mp = Math.max(0, Math.min(c.maxMp, c.mp));
   c.stamina = Math.max(0, Math.min(MAX_STAMINA, c.stamina));
   c.poison = Math.max(0, c.poison);
   c.hurt = Math.max(0, c.hurt);
+  c.attributes.level = c.level;
+  c.attributes.exp = c.exp;
+
+  state.inventory.silver = Math.max(0, Math.floor(state.inventory.silver));
+  for (const item of state.inventory.items) {
+    item.count = Math.max(0, Math.floor(item.count));
+  }
+  state.inventory.items = state.inventory.items.filter((i) => i.count > 0);
 
   if (!getMap(state.location)) {
     state.location = getTemplates().startLocation ?? '小村';