koishi-plugin-monetary-bourse 1.0.0-alpha.1 → 1.0.0

package/lib/index.js

@@ -103,8 +103,14 @@ function apply(ctx, config) {
       await ctx.database.create("bourse_history", { stockId, price: currentPrice, time: /* @__PURE__ */ new Date() });
     }
   });
+  let wasMarketOpen = false;
   ctx.setInterval(async () => {
-    if (!await isMarketOpen()) return;
+    const isOpen = await isMarketOpen();
+    if (isOpen && !wasMarketOpen) {
+      switchKLinePattern("自动开市");
+    }
+    wasMarketOpen = isOpen;
+    if (!isOpen) return;
     await updatePrice();
     await processPendingTransactions();
     const oneMonthAgo = new Date(Date.now() - 30 * 24 * 3600 * 1e3);
@@ -250,13 +256,111 @@ function apply(ctx, config) {
     return { success: true };
   }
   __name(pay, "pay");
+  const kLinePatterns = {
+    // 1. 早盘冲高回落：开盘上涨，午后回落
+    morningRally: /* @__PURE__ */ __name((p) => {
+      if (p < 0.3) return Math.sin(p / 0.3 * Math.PI / 2) * 1;
+      return Math.cos((p - 0.3) / 0.7 * Math.PI / 2) * 0.6;
+    }, "morningRally"),
+    // 2. 早盘低开高走：开盘下跌，之后持续上涨
+    vShape: /* @__PURE__ */ __name((p) => {
+      if (p < 0.25) return -Math.sin(p / 0.25 * Math.PI / 2) * 0.8;
+      return -0.8 + (p - 0.25) / 0.75 * 1.6;
+    }, "vShape"),
+    // 3. 倒V型：持续上涨后快速下跌
+    invertedV: /* @__PURE__ */ __name((p) => {
+      if (p < 0.6) return Math.sin(p / 0.6 * Math.PI / 2) * 1;
+      return Math.cos((p - 0.6) / 0.4 * Math.PI / 2) * 1;
+    }, "invertedV"),
+    // 4. 震荡整理：小幅波动，无明显方向
+    consolidation: /* @__PURE__ */ __name((p) => {
+      return Math.sin(p * Math.PI * 4) * 0.3 + Math.sin(p * Math.PI * 7) * 0.15;
+    }, "consolidation"),
+    // 5. 阶梯上涨：分段上涨，有回调
+    stairUp: /* @__PURE__ */ __name((p) => {
+      const step = Math.floor(p * 4);
+      const inStep = p * 4 % 1;
+      const base = step * 0.25;
+      const stepMove = inStep < 0.7 ? Math.sin(inStep / 0.7 * Math.PI / 2) * 0.3 : 0.3 - (inStep - 0.7) / 0.3 * 0.1;
+      return base + stepMove;
+    }, "stairUp"),
+    // 6. 阶梯下跌：分段下跌，有反弹
+    stairDown: /* @__PURE__ */ __name((p) => {
+      const step = Math.floor(p * 4);
+      const inStep = p * 4 % 1;
+      const base = -step * 0.25;
+      const stepMove = inStep < 0.7 ? -Math.sin(inStep / 0.7 * Math.PI / 2) * 0.3 : -0.3 + (inStep - 0.7) / 0.3 * 0.1;
+      return base + stepMove;
+    }, "stairDown"),
+    // 7. 尾盘拉升：前期平稳，尾盘快速上涨
+    lateRally: /* @__PURE__ */ __name((p) => {
+      if (p < 0.7) return Math.sin(p / 0.7 * Math.PI * 2) * 0.2;
+      return (p - 0.7) / 0.3 * 1;
+    }, "lateRally"),
+    // 8. 尾盘跳水：前期平稳或上涨，尾盘快速下跌
+    lateDive: /* @__PURE__ */ __name((p) => {
+      if (p < 0.7) return Math.sin(p / 0.7 * Math.PI / 2) * 0.4;
+      return 0.4 - (p - 0.7) / 0.3 * 1.2;
+    }, "lateDive"),
+    // 9. W底：双底形态
+    doubleBottom: /* @__PURE__ */ __name((p) => {
+      if (p < 0.25) return -Math.sin(p / 0.25 * Math.PI / 2) * 0.8;
+      if (p < 0.5) return -0.8 + Math.sin((p - 0.25) / 0.25 * Math.PI / 2) * 0.5;
+      if (p < 0.75) return -0.3 - Math.sin((p - 0.5) / 0.25 * Math.PI / 2) * 0.5;
+      return -0.8 + (p - 0.75) / 0.25 * 1.2;
+    }, "doubleBottom"),
+    // 10. M顶：双顶形态
+    doubleTop: /* @__PURE__ */ __name((p) => {
+      if (p < 0.25) return Math.sin(p / 0.25 * Math.PI / 2) * 0.8;
+      if (p < 0.5) return 0.8 - Math.sin((p - 0.25) / 0.25 * Math.PI / 2) * 0.5;
+      if (p < 0.75) return 0.3 + Math.sin((p - 0.5) / 0.25 * Math.PI / 2) * 0.5;
+      return 0.8 - (p - 0.75) / 0.25 * 1.2;
+    }, "doubleTop"),
+    // 11. 单边上涨
+    bullish: /* @__PURE__ */ __name((p) => {
+      return Math.sin(p * Math.PI / 2) * 0.8 + Math.sin(p * Math.PI * 3) * 0.1;
+    }, "bullish"),
+    // 12. 单边下跌
+    bearish: /* @__PURE__ */ __name((p) => {
+      return -Math.sin(p * Math.PI / 2) * 0.8 + Math.sin(p * Math.PI * 3) * 0.1;
+    }, "bearish")
+  };
+  const patternNames = Object.keys(kLinePatterns);
+  const patternChineseNames = {
+    morningRally: "早盘冲高回落",
+    vShape: "V型反转",
+    invertedV: "倒V型",
+    consolidation: "震荡整理",
+    stairUp: "阶梯上涨",
+    stairDown: "阶梯下跌",
+    lateRally: "尾盘拉升",
+    lateDive: "尾盘跳水",
+    doubleBottom: "W底(双底)",
+    doubleTop: "M顶(双顶)",
+    bullish: "单边上涨",
+    bearish: "单边下跌"
+  };
+  let currentDayPattern = patternNames[Math.floor(Math.random() * patternNames.length)];
+  let lastPatternSwitchTime = /* @__PURE__ */ new Date();
+  let nextPatternSwitchTime = new Date(Date.now() + (1 + Math.random() * 5) * 3600 * 1e3);
+  function switchKLinePattern(reason) {
+    const oldPattern = currentDayPattern;
+    currentDayPattern = patternNames[Math.floor(Math.random() * patternNames.length)];
+    const now = /* @__PURE__ */ new Date();
+    lastPatternSwitchTime = now;
+    const minDuration = 1 * 3600 * 1e3;
+    const randomDuration = Math.random() * 5 * 3600 * 1e3;
+    nextPatternSwitchTime = new Date(now.getTime() + minDuration + randomDuration);
+    logger.info(`${reason}切换K线模型: ${patternChineseNames[oldPattern]}(${oldPattern}) -> ${patternChineseNames[currentDayPattern]}(${currentDayPattern}), 下次随机切换: ${nextPatternSwitchTime.toLocaleString()}`);
+  }
+  __name(switchKLinePattern, "switchKLinePattern");
   async function updatePrice() {
     let state = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0];
     const now = /* @__PURE__ */ new Date();
     if (state) {
-      if (!state.lastCycleStart) state.lastCycleStart = new Date(Date.now() - 24 * 3600 * 1e3);
+      if (!state.lastCycleStart) state.lastCycleStart = new Date(Date.now() - 7 * 24 * 3600 * 1e3);
       if (!(state.lastCycleStart instanceof Date)) state.lastCycleStart = new Date(state.lastCycleStart);
-      if (!state.endTime) state.endTime = new Date(state.lastCycleStart.getTime() + 24 * 3600 * 1e3);
+      if (!state.endTime) state.endTime = new Date(state.lastCycleStart.getTime() + 7 * 24 * 3600 * 1e3);
       if (!(state.endTime instanceof Date)) state.endTime = new Date(state.endTime);
     }
     if (config.enableManualControl) {
@@ -276,7 +380,10 @@ function apply(ctx, config) {
           endTime
         };
         if (!state) await ctx.database.create("bourse_state", newState);
-        else await ctx.database.set("bourse_state", "macro_state", newState);
+        else {
+          const { key, ...updateFields } = newState;
+          await ctx.database.set("bourse_state", { key: "macro_state" }, updateFields);
+        }
         state = newState;
       }
     }
@@ -285,14 +392,14 @@ function apply(ctx, config) {
       if (!state) {
         needNewState = true;
       } else {
-        const endTime = state.endTime || new Date(state.lastCycleStart.getTime() + 24 * 3600 * 1e3);
+        const endTime = state.endTime || new Date(state.lastCycleStart.getTime() + 7 * 24 * 3600 * 1e3);
         if (now > endTime) {
           needNewState = true;
         }
       }
       if (needNewState) {
-        const durationHours = 24;
-        const fluctuation = 0.25;
+        const durationHours = 7 * 24;
+        const fluctuation = 0.3;
         const targetRatio = 1 + (Math.random() * 2 - 1) * fluctuation;
         const targetPrice = currentPrice * targetRatio;
         const endTime = new Date(now.getTime() + durationHours * 3600 * 1e3);
@@ -310,24 +417,41 @@ function apply(ctx, config) {
         if (!state) {
           await ctx.database.create("bourse_state", newState);
         } else {
-          await ctx.database.set("bourse_state", "macro_state", newState);
+          const { key, ...updateFields } = newState;
+          await ctx.database.set("bourse_state", { key: "macro_state" }, updateFields);
         }
         state = newState;
       }
     }
+    const timeSinceLastSwitch = now.getTime() - lastPatternSwitchTime.getTime();
+    const forceSwitchDuration = 30 * 3600 * 1e3;
+    if (now >= nextPatternSwitchTime || timeSinceLastSwitch > forceSwitchDuration) {
+      switchKLinePattern("随机时间");
+    }
     const trend = state.trendFactor * 2;
-    const volatility = currentPrice * 5e-3 * (Math.random() * 2 - 1);
+    const volatility = currentPrice * 3e-3 * (Math.random() * 2 - 1);
+    const dayStart = new Date(now);
+    dayStart.setHours(config.openHour, 0, 0, 0);
+    const dayEnd = new Date(now);
+    dayEnd.setHours(config.closeHour, 0, 0, 0);
+    const dayDuration = dayEnd.getTime() - dayStart.getTime();
+    const dayElapsed = now.getTime() - dayStart.getTime();
+    const dayProgress = Math.max(0, Math.min(1, dayElapsed / dayDuration));
+    const dailyAmplitude = state.startPrice * 0.05;
+    const patternFn = kLinePatterns[currentDayPattern];
+    const prevDayProgress = Math.max(0, (dayElapsed - 2 * 60 * 1e3) / dayDuration);
+    const patternDelta = (patternFn(dayProgress) - patternFn(prevDayProgress)) * dailyAmplitude;
     const totalDuration = state.endTime.getTime() - state.lastCycleStart.getTime();
     const elapsed = now.getTime() - state.lastCycleStart.getTime();
     const prevElapsed = elapsed - 2 * 60 * 1e3;
-    const waveCount = 3;
-    const amplitude = state.startPrice * 0.15;
+    const waveCount = 7;
+    const weeklyAmplitude = state.startPrice * 0.08;
     const getWaveValue = /* @__PURE__ */ __name((t) => {
       const progress = t / totalDuration;
-      return amplitude * Math.sin(2 * Math.PI * waveCount * progress);
+      return weeklyAmplitude * (Math.sin(2 * Math.PI * waveCount * progress) * 0.7 + Math.sin(2 * Math.PI * waveCount * 2.5 * progress) * 0.3);
     }, "getWaveValue");
     const waveDelta = getWaveValue(elapsed) - getWaveValue(prevElapsed);
-    let newPrice = currentPrice + trend + volatility + waveDelta;
+    let newPrice = currentPrice + trend + volatility + patternDelta + waveDelta;
     if (newPrice < 1) newPrice = 1;
     currentPrice = newPrice;
     await ctx.database.create("bourse_history", { stockId, price: newPrice, time: /* @__PURE__ */ new Date() });
@@ -541,6 +665,7 @@ function apply(ctx, config) {
   });
   ctx.command("bourse.admin.market <status>", "设置股市开关状态 (open/close/auto)", { authority: 3 }).action(async ({ session }, status) => {
     if (!["open", "close", "auto"].includes(status)) return "无效状态，请使用 open, close, 或 auto";
+    const wasOpen = await isMarketOpen();
     const key = "macro_state";
     const existing = await ctx.database.get("bourse_state", { key });
     if (existing.length === 0) {
@@ -558,8 +683,18 @@ function apply(ctx, config) {
     } else {
       await ctx.database.set("bourse_state", { key }, { marketOpenStatus: status });
     }
+    if (status === "open" && !wasOpen) {
+      switchKLinePattern("管理员开市");
+      wasMarketOpen = true;
+    } else if (status === "close") {
+      wasMarketOpen = false;
+    }
     return `股市状态已设置为: ${status}`;
   });
+  ctx.command("stock.pattern", "管理员：强制切换K线模型", { authority: 3 }).action(() => {
+    switchKLinePattern("管理员手动");
+    return "已切换K线模型。";
+  });
   async function renderStockImage(ctx2, data, name2, current, high, low) {
     if (data.length < 2) return "数据不足，无法绘制走势图。";
     const startPrice = data[0].price;
@@ -741,17 +876,65 @@ function apply(ctx, config) {
         ctx.fillStyle = '#999';
         ctx.font = '500 18px "Segoe UI", sans-serif';
         
-        const timeStep = Math.ceil(times.length / 5);
+        // 动态计算标签间隔，防止重叠
+        // 使用最长的时间标签来估算宽度
+        let maxLabelWidth = 0;
+        for (let i = 0; i < times.length; i++) {
+            const w = ctx.measureText(times[i]).width;
+            if (w > maxLabelWidth) maxLabelWidth = w;
+        }
+        const labelWidth = maxLabelWidth + 40; // 加40px间距确保不重叠
+        const availableWidth = width - padding.left - padding.right;
+        const maxLabels = Math.max(2, Math.floor(availableWidth / labelWidth));
+        const labelCount = Math.min(maxLabels, 5); // 最多显示5个标签
+        const timeStep = Math.max(1, Math.ceil(times.length / labelCount));
+        
+        // 选取要绘制的标签索引（均匀分布）
+        const labelIndices = [];
         for (let i = 0; i < times.length; i += timeStep) {
+           labelIndices.push(i);
+        }
+        // 确保最后一个点在列表中
+        if (labelIndices[labelIndices.length - 1] !== times.length - 1) {
+           labelIndices.push(times.length - 1);
+        }
+        
+        // 绘制标签，跳过重叠的
+        const drawnLabels = [];
+        for (const i of labelIndices) {
+           const x = getX(timestamps[i]);
+           const textWidth = ctx.measureText(times[i]).width;
+           
+           // 根据textAlign计算实际占用的区域
+           let leftEdge, rightEdge;
+           if (i === 0) {
+               leftEdge = x;
+               rightEdge = x + textWidth;
+           } else if (i === times.length - 1) {
+               leftEdge = x - textWidth;
+               rightEdge = x;
+           } else {
+               leftEdge = x - textWidth / 2;
+               rightEdge = x + textWidth / 2;
+           }
+           
+           // 检查是否与已绘制的标签重叠
+           let overlaps = false;
+           for (const drawn of drawnLabels) {
+               // 两个标签之间至少要有15px间隔
+               if (!(rightEdge + 15 < drawn.left || leftEdge - 15 > drawn.right)) {
+                   overlaps = true;
+                   break;
+               }
+           }
+           if (overlaps) continue;
+           
            if (i === 0) ctx.textAlign = 'left';
-           else if (i >= times.length - 1) ctx.textAlign = 'right';
+           else if (i === times.length - 1) ctx.textAlign = 'right';
            else ctx.textAlign = 'center';
            
-           ctx.fillText(times[i], getX(timestamps[i]), height - 10);
-        }
-        if ((times.length - 1) % timeStep !== 0) {
-             ctx.textAlign = 'right';
-             ctx.fillText(times[times.length-1], getX(timestamps[times.length-1]), height - 10);
+           ctx.fillText(times[i], x, height - 10);
+           drawnLabels.push({ left: leftEdge, right: rightEdge });
         }
 
       </script>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-monetary-bourse",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -2,6 +2,114 @@
 
 [![npm](https://img.shields.io/npm/v/koishi-plugin-monetary-bourse?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-monetary-bourse)
 
-Provide exchange functionality for monetary
+为 Koishi 提供基于 `monetary` 通用货币系统的股票交易所功能。
 
-为monetary货币提供交易所功能
+本插件模拟了一个具备**自动宏观调控**、**丰富日内走势形态**和**资金冻结机制**的拟真股票市场。用户可以使用机器人通用的货币（如信用点）进行股票买卖、炒股理财。
+
+## ✨ 特性 (Alpha 2 更新)
+
+- **📈 拟真 K 线引擎**：
+  - 内置 **12 种日内走势形态**（如：早盘冲高回落、V型反转、尾盘拉升、M顶/W底等）。
+  - 走势不再是单纯的随机波动，每天自动或随机切换不同的操盘剧本，大幅提升观察乐趣。
+  - 结合 **周级波浪** 与 **宏观趋势**，模拟真实市场的多周期叠加效应。
+- **📊 精美 K 线渲染**：使用 Puppeteer 渲染实时/日/周线图，Alpha 2 版本优化了坐标轴标签算法，防止文字重叠，观感更佳。
+- **❄️ 资金冻结机制**：交易采用 T+0 但资金/股票非即时到账模式（根据金额计算冻结时间），增加博弈深度。
+- **🏦 银行联动**：支持与 `koishi-plugin-monetary-bank` 联动，现金不足时自动扣除银行活期存款。
+- **🕹️ 宏观调控**：管理员可手动干预股价目标，或强制切换当天的 K 线剧本。
+
+## 更新记录
+
+- **1.0.0（正式版）**：
+  - 修复：解决长期运行时触发的 `TypeError: cannot modify primary key`（更新 `bourse_state` 时排除主键字段，仅按条件写入非主键字段），提高数据库兼容性与稳定性。
+
+- **Alpha.2 (功能增强 — K 线多样化)**：
+  - 在 Alpha.1 的基础上，扩展并完善了 K 线引擎，新增 12 种日内走势剧本、周级波浪叠加以及坐标轴标签冲突修复等视觉与体验改进。
+  - 该版本引入了更丰富的日内走势（例如早盘冲高回落、V 型反转、尾盘拉升、M 顶/W 底等），并改进了 Puppeteer 渲染逻辑以减少横轴标签重叠。
+  - 致命问题说明：长期运行时可能触发 `TypeError: cannot modify primary key`（根因：更新持久化 `bourse_state` 时不小心将主键字段包含在更新负载中，某些数据库实现会拒绝修改主键），该问题在后续修复版本中已处理，请在生产环境中尽量升级至稳定版本。
+
+- **Alpha.1 (初始 Alpha 版本)**：
+  - 发布基础功能：买卖、资金冻结、挂单、历史行情存储以及 `stock` 家族指令（`stock` / `stock.buy` / `stock.sell` / `stock.my`）。
+  - 支持与 `monetary` 与 `monetary-bank` 的基本联动，提供最小可用的股票交易所模拟能力。
+
+## 📦 依赖
+
+本插件需要以下服务：
+- `database`: 用于存储持仓、历史行情和挂单记录。
+- `puppeteer`: 用于渲染股市行情图。
+- `monetary`: (可选) 用于获取用户货币余额（本插件直接操作数据库表，monetary 插件需安装以建立表结构）。
+
+## 🔧 配置项
+
+可以在控制台插件配置页进行设置：
+
+### 基础设置
+- **currency**: 货币单位名称（默认：`信用点`）。
+- **stockName**: 股票名称（默认：`Koishi股份`）。
+- **initialPrice**: 股票初始价格（默认：`1200`）。
+- **maxHoldings**: 单人最大持仓限制（默认：`100000`）。
+
+### 交易时间
+- **openHour**: 每日开市时间（小时，0-23，默认 `8` 点）。
+- **closeHour**: 每日休市时间（小时，0-23，默认 `23` 点）。
+- **marketStatus**: 股市总开关，可选 `open` (强制开启)、`close` (强制关闭)、`auto` (自动按时间)。
+
+### 冻结机制
+- **freezeCostPerMinute**: 每多少货币金额计为1分钟冻结时间（默认 `100`）。
+- **minFreezeTime**: 最小冻结时间（分钟，默认 `10`）。
+- **maxFreezeTime**: 最大冻结时间（分钟，默认 `1440` 即24小时）。
+
+### 宏观调控
+- **enableManualControl**: 是否开启手动强力调控模式（覆盖自动波动）。
+- **manualTargetPrice**: 手动模式下的目标价格。
+- **manualDuration**: 手动调控周期（小时）。
+
+## 🎮 指令说明
+
+### 用户指令
+
+- **`stock [interval]`**
+  - 查看股市行情。
+  - 参数 `interval`: 可选 `day` (日线)、`week` (周线)，不填默认为实时走势（最近100条）。
+  - 示例：`stock` (查看实时), `stock day` (查看日线)。
+
+- **`stock.buy <amount>`**
+  - 买入股票。
+  - 参数 `amount`: 购买股数（整数）。
+  - 说明：扣除现金（优先）或银行活期，股票将在冻结时间结束后到账。
+
+- **`stock.sell <amount>`**
+  - 卖出股票。
+  - 参数 `amount`: 卖出股数（整数）。
+  - 说明：扣除持仓，获得的资金将在冻结时间结束后到账。
+
+- **`stock.my`**
+  - 查看我的账户。
+  - 显示当前持仓、市值以及正在进行中（冻结中）的买卖订单。
+
+### 管理员指令 (权限等级 3)
+
+- **`stock.control <price> [hours]`**
+  - 设置宏观调控目标。
+  - 说明：强行引导股价在指定时间内向目标价格移动。
+  - 示例：`stock.control 5000 12` (在12小时内让股价涨/跌到5000)。
+
+- **`stock.pattern`** *(Alpha 2 新增)*
+  - 强制切换 K 线模型。
+  - 说明：手动随机切换当前使用的日内走势剧本（如从“单边下跌”切换为“尾盘拉升”）。
+
+- **`bourse.admin.market <status>`**
+  - 设置股市开关状态。
+  - 参数 `status`: `open` (开启), `close` (关闭), `auto` (自动)。
+  - 说明：手动开市时会自动重置并切换一个新的日内 K 线形态。
+
+## 💡 常见问题
+
+**Q: 为什么买了股票没有立刻到账？**
+A: 本插件设计了基于交易金额的动态冻结机制。交易额越大，冻结时间越长（可配置）。请使用 `stock.my` 查看剩余解冻时间。
+
+**Q: 股价是如何波动的？**
+A: 股价由四部分叠加而成：
+1. **宏观趋势**：根据自动或手动的目标价格计算的线性趋势。
+2. **周级波浪**：7天为一个大周期的正弦复合波浪。
+3. **日内形态**：每天随机从 12 种剧本中选择多种（如 V 型、倒 V 型、阶梯上涨等）。
+4. **随机噪音**：微小的随机波动。