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

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) {
@@ -285,14 +389,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);
@@ -315,19 +419,35 @@ function apply(ctx, config) {
         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 +661,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 +679,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 +872,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-alpha.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -2,6 +2,90 @@
 
 [![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货币提供交易所功能
+本插件模拟了一个具备自动宏观调控、周期性波动和资金冻结机制的简易股票市场。用户可以使用机器人通用的货币（如信用点）进行股票买卖、炒股理财。
+
+## ✨ 特性
+
+- **拟真股市算法**：包含长期趋势、随机波动和周期性波浪算法，模拟真实的股价走势。
+- **可视化K线图**：使用 Puppeteer 渲染精美的实时、日线、周线走势图。
+- **资金冻结机制**：交易并非即时到账，根据交易金额计算冻结时间，增加博弈乐趣。
+- **宏观调控**：管理员可以手动干预股价走势，设定目标价格，系统将平滑过渡到目标价。
+- **银行联动**：支持与 `koishi-plugin-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)。
+
+- **`bourse.admin.market <status>`**
+  - 设置股市开关状态。
+  - 参数 `status`: `open` (开启), `close` (关闭), `auto` (自动)。
+
+## 💡 常见问题
+
+**Q: 为什么买了股票没有立刻到账？**
+A: 本插件设计了 T+N 机制（基于金额的动态冻结）。使用 `stock.buy` 后，股票会进入“冻结中”状态，使用 `stock.my` 可以看到剩余解冻时间。卖出股票同理，资金需等待解冻。
+
+**Q: 股价是如何波动的？**
+A: 股价由三部分组成：长期趋势（宏观调控决定）、随机波动（模拟市场噪音）和正弦波浪（模拟周期性涨跌）。