@sdd330dev/jy-skill 0.3.0 → 0.7.0

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 {
@@ -44,3 +51,145 @@ export interface BattleEnemy {
   attack: number;
   defence: number;
 }
+
+export interface NpcPersonaDetail {
+  archetype?: string;
+  tone?: string;
+  likes?: string[];
+  dislikes?: string[];
+}
+
+export interface NpcTeachCondition {
+  minLevel?: number;
+  minIQ?: number;
+  flag?: string;
+}
+
+export interface NpcCard {
+  name: string;
+  title?: string;
+  persona: string | NpcPersonaDetail;
+  knowledge: string[];
+  canHelp?: string[];
+  isShop?: boolean;
+  canTeach?: string[];
+  canGive?: string[];
+  conditions?: {
+    teach?: NpcTeachCondition;
+    give?: NpcTeachCondition;
+    quest?: NpcTeachCondition;
+  };
+}
+
+export interface DialogChoice {
+  text: string;
+  nextId: string;
+  index: number;
+}
+
+export interface EventResult {
+  type: 'dialog' | 'setFlag' | 'addItem' | 'message' | 'battle' | 'heal';
+  message?: string;
+  dialogId?: string;
+  choices?: DialogChoice[];
+  flag?: string;
+  itemName?: string;
+  enemyName?: string;
+}
+
+export interface ActionOption {
+  id: string;
+  label: string;
+  category: 'talk' | 'move' | 'shop' | 'explore' | 'rest' | 'status' | 'interact';
+  hint?: string;
+}
+
+export interface TalkResult {
+  success: boolean;
+  message: string;
+  npc?: NpcCard;
+  choices?: DialogChoice[];
+  events?: EventResult[];
+  dialogId?: string;
+  context?: NpcContext;
+}
+
+export interface LocationDetail {
+  name: string;
+  description: string;
+  atmosphere: string;
+  dangerLevel: 'safe' | 'cautious' | 'dangerous';
+  connections: string[];
+  npcs: Array<{ name: string; persona?: string }>;
+  shops: string[];
+}
+
+export interface NpcContext {
+  card: NpcCard;
+  playerRelation: {
+    level: number;
+    iq: number;
+    flags: Record<string, boolean | number>;
+    inventory: string[];
+  };
+  availableActions: Array<'teach' | 'give' | 'quest' | 'talk'>;
+  constraints: string[];
+}
+
+export interface ResolveOptionResult {
+  action: string;
+  result:
+    | TalkResult
+    | {
+        success: boolean;
+        message: string;
+        encounter?: string;
+        events?: EventResult[];
+        locationDetail?: LocationDetail;
+      }
+    | { success: boolean; message: string }
+    | string
+    | { events: EventResult[] }
+    | PlayerChoicePrompt;
+}
+
+export interface PlayerChoiceItem {
+  value: string;
+  label: string;
+  description?: string;
+  category?: ActionOption['category'] | 'nav';
+}
+
+export interface PlayerChoicePrompt {
+  type: 'player_choice';
+  message: string;
+  choices: PlayerChoiceItem[];
+  dialogChoices?: DialogChoice[];
+  dialogId?: string;
+  page?: number;
+  hasMore?: boolean;
+  totalPages?: number;
+}
+
+export interface McpElicitationParams {
+  mode: 'form';
+  message: string;
+  requestedSchema: {
+    type: 'object';
+    properties: {
+      action: {
+        type: 'string';
+        title: string;
+        description?: string;
+        oneOf: Array<{ const: string; title: string }>;
+      };
+    };
+    required: ['action'];
+  };
+}
+
+export interface FeishuInteractiveCard {
+  config: { wide_screen_mode: boolean };
+  header?: { title: { tag: 'plain_text'; content: string } };
+  elements: Array<Record<string, unknown>>;
+}

package/scripts/mcp-server.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * 金庸群侠传 MCP Server — 暴露游戏工具与 PlayerChoicePrompt 标准契约
+ *
+ * 用法: npx tsx scripts/mcp-server.ts
+ * Cursor / Claude Desktop 配置 stdio 启动此脚本即可。
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import {
+  loadOrCreateGameForUser,
+  getStatus,
+  getLocationDetail,
+  resolveOption,
+  buildChoicePrompt,
+  toMcpElicitationParams,
+  fromElicitationResponse,
+  setSaveUserId,
+} from './game-engine.js';
+import type { GameState } from './game-types.js';
+
+const sessions = new Map<string, GameState>();
+
+function getSession(playerId: string): GameState {
+  let state = sessions.get(playerId);
+  if (!state) {
+    setSaveUserId(playerId);
+    const { state: loaded } = loadOrCreateGameForUser(playerId, '主角');
+    state = loaded;
+    sessions.set(playerId, state);
+  }
+  return state;
+}
+
+function attachChoiceMeta(result: unknown, state: GameState) {
+  const prompt = buildChoicePrompt(state);
+  return {
+    result,
+    playerChoice: prompt,
+    mcpElicitation: toMcpElicitationParams(prompt),
+    status: getStatus(state),
+  };
+}
+
+const server = new McpServer({
+  name: 'jy-skill',
+  version: '0.6.0',
+});
+
+server.tool(
+  'jy_load_game',
+  '加载或新建金庸群侠传存档',
+  {
+    playerId: z.string().describe('玩家唯一 ID，如飞书 open_id'),
+    name: z.string().optional().describe('新角色名，默认「主角」'),
+  },
+  async ({ playerId, name }) => {
+    setSaveUserId(playerId);
+    const { state, isNewGame } = loadOrCreateGameForUser(playerId, name ?? '主角');
+    sessions.set(playerId, state);
+    const prompt = buildChoicePrompt(state);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              isNewGame,
+              location: state.location,
+              status: getStatus(state),
+              locationDetail: getLocationDetail(state),
+              playerChoice: prompt,
+              mcpElicitation: toMcpElicitationParams(prompt),
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  },
+);
+
+server.tool(
+  'jy_resolve_action',
+  '执行玩家选中的行动（optionId 来自 playerChoice.choices[].value）',
+  {
+    playerId: z.string(),
+    optionId: z.string().describe('PlayerChoicePrompt choices 中的 value'),
+  },
+  async ({ playerId, optionId }) => {
+    const state = getSession(playerId);
+    const resolved = resolveOption(state, optionId);
+    const payload = attachChoiceMeta(resolved, state);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+    };
+  },
+);
+
+server.tool(
+  'jy_get_status',
+  '获取当前状态栏与可选行动',
+  { playerId: z.string() },
+  async ({ playerId }) => {
+    const state = getSession(playerId);
+    const prompt = buildChoicePrompt(state);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              status: getStatus(state),
+              playerChoice: prompt,
+              mcpElicitation: toMcpElicitationParams(prompt),
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  },
+);
+
+server.tool(
+  'jy_from_elicitation',
+  '将 MCP Elicitation 用户响应解析为 optionId 并执行',
+  {
+    playerId: z.string(),
+    elicitationContent: z.record(z.string(), z.unknown()).describe('elicitation 表单回传 JSON'),
+  },
+  async ({ playerId, elicitationContent }) => {
+    const optionId = fromElicitationResponse(elicitationContent);
+    if (!optionId) {
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ error: '无效的 elicitation 响应' }) }],
+        isError: true,
+      };
+    }
+    const state = getSession(playerId);
+    const resolved = resolveOption(state, optionId);
+    const payload = attachChoiceMeta(resolved, state);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+    };
+  },
+);
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/persistence.ts

@@ -1,5 +1,5 @@
 /**
- * 游戏存档持久化 — save/game-state.json
+ * 游戏存档持久化 — save/game-state.json 或 save/users/{userId}.json
  */
 
 import {
@@ -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 {
@@ -23,20 +23,48 @@ export interface LoadGameResult {
 
 const ROOT_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
 const SAVE_DIR = join(ROOT_DIR, 'save');
+const USERS_DIR = join(SAVE_DIR, 'users');
 const SAVE_FILE = join(SAVE_DIR, 'game-state.json');
-const SAVE_TMP = join(SAVE_DIR, 'game-state.json.tmp');
 
-export function getSavePath(): string {
-  return SAVE_FILE;
+let currentSaveUserId: string | null = null;
+
+/** 设置当前会话使用的存档用户 ID（null = 默认单用户档） */
+export function setSaveUserId(userId: string | null): void {
+  currentSaveUserId = userId;
+}
+
+export function getSaveUserId(): string | null {
+  return currentSaveUserId;
+}
+
+function sanitizeUserId(userId: string): string {
+  return userId.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+export function getSavePath(userId?: string | null): string {
+  const id = userId === undefined ? currentSaveUserId : userId;
+  if (!id) return SAVE_FILE;
+  return join(USERS_DIR, `${sanitizeUserId(id)}.json`);
+}
+
+function getSaveTmpPath(savePath: string): string {
+  return `${savePath}.tmp`;
+}
+
+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 +72,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 +120,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 ?? '小村';
@@ -87,49 +143,62 @@ function migrateGameState(state: GameState): GameState {
   return state;
 }
 
-/** 读取存档；不存在或损坏时返回 null */
-export function loadGameState(): GameState | null {
-  if (!existsSync(SAVE_FILE)) return null;
-
+function loadGameStateFromPath(path: string): GameState | null {
+  if (!existsSync(path)) return null;
   try {
-    const raw = readFileSync(SAVE_FILE, 'utf-8');
+    const raw = readFileSync(path, 'utf-8');
     const parsed: unknown = JSON.parse(raw);
-    if (!isValidGameState(parsed)) {
-      return null;
-    }
+    if (!isValidGameState(parsed)) return null;
     return migrateGameState(parsed);
   } catch {
     return null;
   }
 }
 
+/** 读取存档；不存在或损坏时返回 null */
+export function loadGameState(userId?: string | null): GameState | null {
+  return loadGameStateFromPath(getSavePath(userId));
+}
+
 /** 写入存档（原子替换，避免写入中断损坏） */
-export function saveGameState(state: GameState): void {
-  if (!existsSync(SAVE_DIR)) {
-    mkdirSync(SAVE_DIR, { recursive: true });
+export function saveGameState(state: GameState, userId?: string | null): void {
+  const path = getSavePath(userId);
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(SAVE_TMP, JSON.stringify(state, null, 2), 'utf-8');
-  renameSync(SAVE_TMP, SAVE_FILE);
+  const tmp = getSaveTmpPath(path);
+  writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf-8');
+  renameSync(tmp, path);
 }
 
 /** 删除存档 */
-export function deleteSave(): void {
-  if (existsSync(SAVE_FILE)) {
-    unlinkSync(SAVE_FILE);
-  }
-  if (existsSync(SAVE_TMP)) {
-    unlinkSync(SAVE_TMP);
-  }
+export function deleteSave(userId?: string | null): void {
+  const path = getSavePath(userId);
+  const tmp = getSaveTmpPath(path);
+  if (existsSync(path)) unlinkSync(path);
+  if (existsSync(tmp)) unlinkSync(tmp);
 }
 
 /** 开始或继续：有存档则加载，否则新建并落盘 */
 export function loadOrCreateGame(
   createNewGame: (name: string) => GameState,
   name = '主角',
+  userId?: string | null,
 ): LoadGameResult {
-  const existing = loadGameState();
+  const existing = loadGameState(userId);
   if (existing) return { state: existing, isNewGame: false };
   const state = createNewGame(name);
-  saveGameState(state);
+  saveGameState(state, userId);
   return { state, isNewGame: true };
 }
+
+/** 多用户场景：按 userId 加载或新建 */
+export function loadOrCreateGameForUser(
+  userId: string,
+  createNewGame: (name: string) => GameState,
+  name = '主角',
+): LoadGameResult {
+  setSaveUserId(userId);
+  return loadOrCreateGame(createNewGame, name, userId);
+}