@sdd330dev/jy-skill 0.3.1 → 0.7.0

package/scripts/config-loader.ts

@@ -5,14 +5,44 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import type { NpcCard } from './game-types';
 
 const ROOT_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
 const ASSETS_DIR = join(ROOT_DIR, 'assets');
 
+/** 地图名归一化（game-config 与 templates 不一致时） */
+const MAP_ALIASES: Record<string, string> = {
+  终南山全真教: '全真教',
+};
+
+function normalizeMapName(name: string): string {
+  return MAP_ALIASES[name] ?? name;
+}
+
 // ============================================================================
 // 类型
 // ============================================================================
 
+export interface MapEventCondition {
+  type: string;
+  params: Record<string, unknown>;
+}
+
+export interface MapEventAction {
+  type: string;
+  params: Record<string, unknown>;
+}
+
+export interface MapEvent {
+  id: string;
+  triggerType: string;
+  x?: number;
+  y?: number;
+  npcName?: string;
+  conditions: MapEventCondition[];
+  actions: MapEventAction[];
+}
+
 export interface MapInfo {
   npcs: string[];
   shops: string[];
@@ -20,6 +50,11 @@ export interface MapInfo {
   npcDialogs: Record<string, string>;
   encounterRate?: number;
   encounterEnemies?: string[];
+  description?: string;
+  atmosphere?: string;
+  dangerLevel?: 'safe' | 'cautious' | 'dangerous';
+  npcCards?: Record<string, NpcCard>;
+  events?: MapEvent[];
 }
 
 export interface ItemConfig {
@@ -64,10 +99,17 @@ export interface CharacterConfig {
   source: string;
 }
 
+export interface DialogChoiceConfig {
+  text: string;
+  nextId: string;
+  actions?: MapEventAction[];
+}
+
 export interface DialogConfig {
   id: string;
   speaker: string;
   text: string;
+  choices?: DialogChoiceConfig[];
 }
 
 export interface EnemyTemplate {
@@ -79,6 +121,17 @@ export interface EnemyTemplate {
   onHitHurt?: number;
 }
 
+export interface TemplateMapEntry {
+  npcs: string[];
+  shops: string[];
+  connections: string[];
+  encounters?: number | { rate: number; enemies: string[] };
+  description?: string;
+  atmosphere?: string;
+  dangerLevel?: 'safe' | 'cautious' | 'dangerous';
+  npcCards?: Record<string, NpcCard>;
+}
+
 export interface GameTemplates {
   defaultCharacter: {
     name: string;
@@ -90,15 +143,7 @@ export interface GameTemplates {
   };
   startLocation: string;
   enemies: Record<string, EnemyTemplate | { characterId: number }>;
-  maps?: Record<
-    string,
-    {
-      npcs: string[];
-      shops: string[];
-      connections: string[];
-      encounters?: number | { rate: number; enemies: string[] };
-    }
-  >;
+  maps?: Record<string, TemplateMapEntry>;
 }
 
 function parseEncounters(
@@ -111,6 +156,17 @@ function parseEncounters(
   return { encounterRate: encounters.rate, encounterEnemies: [...encounters.enemies] };
 }
 
+function deriveDangerLevel(
+  templateMap: TemplateMapEntry | undefined,
+  encounterConfig: Pick<MapInfo, 'encounterRate' | 'encounterEnemies'>,
+  events: MapEvent[],
+): 'safe' | 'cautious' | 'dangerous' {
+  if (templateMap?.dangerLevel) return templateMap.dangerLevel;
+  if (encounterConfig.encounterRate && encounterConfig.encounterRate > 0) return 'dangerous';
+  if (events.some((e) => e.triggerType === 'interact')) return 'cautious';
+  return 'safe';
+}
+
 // ============================================================================
 // 加载
 // ============================================================================
@@ -147,6 +203,7 @@ function buildMapsFromConfig(): void {
     maps: Array<{
       id: number;
       name: string;
+      desc?: string;
       npcs: Array<{
         roleId: number;
         dialogId: string;
@@ -154,13 +211,14 @@ function buildMapsFromConfig(): void {
         shopItems: number[];
       }>;
       connections: Array<{ targetMapId: number }>;
+      events?: MapEvent[];
     }>;
     dialogs: Record<string, DialogConfig>;
   }>('game-config.json');
 
   const mapIdToName = new Map<number, string>();
   for (const map of gameConfig.maps) {
-    mapIdToName.set(map.id, map.name);
+    mapIdToName.set(map.id, normalizeMapName(map.name));
   }
 
   for (const [id, dialog] of Object.entries(gameConfig.dialogs)) {
@@ -170,7 +228,8 @@ function buildMapsFromConfig(): void {
   const templateMaps = templates.maps ?? {};
 
   for (const map of gameConfig.maps) {
-    const templateMap = templateMaps[map.name as keyof typeof templateMaps];
+    const mapName = normalizeMapName(map.name);
+    const templateMap = templateMaps[mapName as keyof typeof templateMaps];
     const npcDialogs: Record<string, string> = {};
     const npcNames: string[] = [];
     const shopNames = new Set<string>();
@@ -193,18 +252,25 @@ function buildMapsFromConfig(): void {
         ? [...templateMap.connections]
         : map.connections
             .map((c) => mapIdToName.get(c.targetMapId))
-            .filter((name): name is string => Boolean(name));
+            .filter((name): name is string => Boolean(name))
+            .map(normalizeMapName);
 
     const shops =
       templateMap && templateMap.shops?.length > 0 ? [...templateMap.shops] : [...shopNames];
 
     const encounterConfig = parseEncounters(templateMap?.encounters);
+    const events = map.events ?? [];
 
-    mapsByName.set(map.name, {
+    mapsByName.set(mapName, {
       npcs: templateMap?.npcs?.length ? [...templateMap.npcs] : npcNames,
       shops,
       connections,
       npcDialogs,
+      description: templateMap?.description ?? map.desc,
+      atmosphere: templateMap?.atmosphere,
+      dangerLevel: deriveDangerLevel(templateMap, encounterConfig, events),
+      npcCards: templateMap?.npcCards ? { ...templateMap.npcCards } : undefined,
+      events: events.length > 0 ? [...events] : undefined,
       ...encounterConfig,
     });
   }
@@ -218,6 +284,10 @@ function buildMapsFromConfig(): void {
         shops: [...map.shops],
         connections: [...map.connections],
         npcDialogs: {},
+        description: map.description,
+        atmosphere: map.atmosphere,
+        dangerLevel: deriveDangerLevel(map, encounterConfig, []),
+        npcCards: map.npcCards ? { ...map.npcCards } : undefined,
         ...encounterConfig,
       });
     }
@@ -306,7 +376,7 @@ export function getTemplates(): GameTemplates {
 
 export function getMap(name: string): MapInfo | undefined {
   initConfigs();
-  return mapsByName.get(name);
+  return mapsByName.get(normalizeMapName(name));
 }
 
 export function getAllMapNames(): string[] {
@@ -319,6 +389,11 @@ export function getItem(name: string): ItemConfig | undefined {
   return itemsByName.get(name);
 }
 
+export function getItemById(id: number): ItemConfig | undefined {
+  initConfigs();
+  return itemsById.get(id);
+}
+
 export function getSkill(name: string): SkillConfig | undefined {
   initConfigs();
   return skillsByName.get(name);
@@ -362,6 +437,42 @@ export function getDialog(dialogId: string): DialogConfig | undefined {
   return dialogsById.get(dialogId);
 }
 
+export function getMapEvents(mapName: string): MapEvent[] {
+  initConfigs();
+  return getMap(mapName)?.events ?? [];
+}
+
+export function getLocationMeta(mapName: string): {
+  description: string;
+  atmosphere: string;
+  dangerLevel: 'safe' | 'cautious' | 'dangerous';
+} {
+  initConfigs();
+  const map = getMap(mapName);
+  return {
+    description: map?.description ?? `${mapName}，江湖一处所在。`,
+    atmosphere: map?.atmosphere ?? '',
+    dangerLevel: map?.dangerLevel ?? 'safe',
+  };
+}
+
+export function getNpcCard(location: string, npcName: string): NpcCard | undefined {
+  initConfigs();
+  const map = getMap(location);
+  const card = map?.npcCards?.[npcName];
+  if (card) return { ...card, name: card.name ?? npcName };
+
+  const char = getCharacterByName(npcName);
+  if (char) {
+    return {
+      name: char.name,
+      persona: `${char.name}，出自${char.source}。`,
+      knowledge: [],
+    };
+  }
+  return undefined;
+}
+
 export function getEnemyTemplate(enemyName: string): EnemyTemplate | undefined {
   initConfigs();
   const entry = templates.enemies[enemyName];
@@ -437,6 +548,13 @@ export function validateAssets(): string[] {
         errors.push(`Map "${mapName}" connection target unknown: ${conn}`);
       }
     }
+    if (map.npcCards) {
+      for (const npcName of Object.keys(map.npcCards)) {
+        if (!map.npcs.includes(npcName)) {
+          errors.push(`Map "${mapName}" npcCards key "${npcName}" not in npcs list`);
+        }
+      }
+    }
   }
 
   for (const enemyName of Object.keys(templates.enemies)) {

package/scripts/event-engine.ts

@@ -0,0 +1,205 @@
+/**
+ * 事件引擎 — 处理 game-config.json 中的地图事件与对话动作
+ */
+
+import type { GameState, EventResult, DialogChoice } from './game-types';
+import type { MapEvent, MapEventCondition, MapEventAction, DialogConfig } from './config-loader';
+import { getDialog, getItemById, getMapEvents, getMap } from './config-loader';
+
+export interface EventContext {
+  mapName?: string;
+  eventId?: string;
+  npcName?: string;
+}
+
+export function evaluateConditions(state: GameState, conditions: MapEventCondition[]): boolean {
+  if (conditions.length === 0) return true;
+  return conditions.every((c) => evaluateCondition(state, c));
+}
+
+function evaluateCondition(state: GameState, condition: MapEventCondition): boolean {
+  const params = condition.params;
+  switch (condition.type) {
+    case 'flag': {
+      const flag = params.flag as string;
+      const expected = params.value as boolean | number;
+      const actual = state.flags[flag];
+      if (expected === false) return actual === undefined || actual === false;
+      return actual === expected;
+    }
+    case 'level': {
+      const min = (params.min as number) ?? 0;
+      return state.character.level >= min;
+    }
+    case 'item': {
+      const itemId = params.itemId as number;
+      const item = getItemById(itemId);
+      if (!item) return false;
+      const inv = state.inventory.items.find((i) => i.name === item.name);
+      const minCount = (params.count as number) ?? 1;
+      return (inv?.count ?? 0) >= minCount;
+    }
+    case 'quest': {
+      const questId = params.questId as string;
+      return state.completedQuests.includes(questId);
+    }
+    default:
+      return true;
+  }
+}
+
+export function checkEvents(
+  state: GameState,
+  trigger: 'auto' | 'interact' | 'talk',
+  ctx: EventContext = {},
+): MapEvent[] {
+  const mapName = ctx.mapName ?? state.location;
+  const events = getMapEvents(mapName);
+  return events.filter((event) => {
+    if (event.triggerType !== trigger) return false;
+    if (ctx.eventId && event.id !== ctx.eventId) return false;
+    if (trigger === 'talk' && ctx.npcName && event.npcName && event.npcName !== ctx.npcName) {
+      return false;
+    }
+    return evaluateConditions(state, event.conditions);
+  });
+}
+
+function dialogToChoices(dialog: DialogConfig): DialogChoice[] {
+  if (!dialog.choices?.length) return [];
+  return dialog.choices.map((c, index) => ({
+    text: c.text,
+    nextId: c.nextId,
+    index,
+  }));
+}
+
+function dialogToResult(dialog: DialogConfig): EventResult {
+  return {
+    type: 'dialog',
+    message: `${dialog.speaker}：「${dialog.text}」`,
+    dialogId: dialog.id,
+    choices: dialogToChoices(dialog),
+  };
+}
+
+export function processEventAction(state: GameState, action: MapEventAction): EventResult | null {
+  const params = action.params;
+  switch (action.type) {
+    case 'setFlag': {
+      const flag = params.flag as string;
+      state.flags[flag] = params.value as boolean | number;
+      return { type: 'setFlag', flag, message: '' };
+    }
+    case 'dialog': {
+      const dialogId = params.dialogId as string;
+      const dialog = getDialog(dialogId);
+      if (!dialog) return { type: 'message', message: '（对话缺失）' };
+      return dialogToResult(dialog);
+    }
+    case 'addItem': {
+      const itemId = params.itemId as number;
+      const count = (params.count as number) ?? 1;
+      const item = getItemById(itemId);
+      if (!item) return { type: 'message', message: '（物品缺失）' };
+      const existing = state.inventory.items.find((i) => i.name === item.name);
+      if (existing) {
+        existing.count += count;
+      } else {
+        state.inventory.items.push({
+          id: String(item.id),
+          name: item.name,
+          count,
+        });
+      }
+      return { type: 'addItem', itemName: item.name, message: `获得了${item.name}×${count}` };
+    }
+    case 'battle': {
+      const enemyName = (params.enemyName as string) ?? '山贼';
+      return { type: 'battle', enemyName, message: `⚔️ 遭遇${enemyName}！` };
+    }
+    case 'heal': {
+      state.character.hp = state.character.maxHp;
+      state.character.mp = state.character.maxMp;
+      state.character.stamina = 100;
+      state.character.poison = 0;
+      state.character.hurt = 0;
+      return { type: 'heal', message: '休息完毕，状态全满' };
+    }
+    default:
+      return null;
+  }
+}
+
+export function processEvent(state: GameState, event: MapEvent): EventResult[] {
+  const results: EventResult[] = [];
+  for (const action of event.actions) {
+    const result = processEventAction(state, action);
+    if (result) {
+      if (result.message) results.push(result);
+      else if (result.type !== 'setFlag') results.push(result);
+      else results.push(result);
+    }
+  }
+  return results.filter((r) => r.message || r.type === 'dialog' || r.type === 'battle');
+}
+
+export function processDialogChoiceActions(
+  state: GameState,
+  actions: MapEventAction[],
+): EventResult[] {
+  const results: EventResult[] = [];
+  for (const action of actions) {
+    const result = processEventAction(state, action);
+    if (result) results.push(result);
+  }
+  return results;
+}
+
+export function runTriggeredEvents(
+  state: GameState,
+  trigger: 'auto' | 'interact' | 'talk',
+  ctx: EventContext = {},
+): EventResult[] {
+  const matched = checkEvents(state, trigger, ctx);
+  const allResults: EventResult[] = [];
+  for (const event of matched) {
+    allResults.push(...processEvent(state, event));
+  }
+  return allResults;
+}
+
+export function formatEventResults(results: EventResult[]): string {
+  return results
+    .map((r) => r.message)
+    .filter(Boolean)
+    .join('\n');
+}
+
+export function getInteractEventLabel(event: MapEvent): string {
+  for (const action of event.actions) {
+    if (action.type === 'dialog') {
+      const dialogId = action.params.dialogId as string;
+      const dialog = getDialog(dialogId);
+      if (dialog) return dialog.text.slice(0, 20);
+    }
+    if (action.type === 'addItem') return '探索此处';
+  }
+  return '探索';
+}
+
+export function getInteractEventsForMap(mapName: string): MapEvent[] {
+  return getMapEvents(mapName).filter((e) => e.triggerType === 'interact');
+}
+
+export function hasInteractEvents(mapName: string): boolean {
+  return getInteractEventsForMap(mapName).length > 0;
+}
+
+export function getMapDangerHint(mapName: string): string | undefined {
+  const map = getMap(mapName);
+  if (!map) return undefined;
+  if (map.dangerLevel === 'dangerous') return '此地行路需当心，或有歹人埋伏';
+  if (map.dangerLevel === 'cautious') return '此地不宜大意，多加留神';
+  return undefined;
+}