koishi-plugin-monetary-bourse 1.1.0 → 1.1.2-Alpha.5

package/lib/index.d.ts

@@ -71,9 +71,6 @@ export interface Config {
     freezeCostPerMinute: number;
     minFreezeTime: number;
     maxFreezeTime: number;
-    enableManualControl: boolean;
-    manualTargetPrice: number;
-    manualDuration: number;
     marketStatus: 'open' | 'close' | 'auto';
 }
 export declare const Config: Schema<Config>;

package/lib/index.js

@@ -51,12 +51,7 @@ var Config = import_koishi.Schema.intersect([
     freezeCostPerMinute: import_koishi.Schema.number().min(1).default(100).description("每多少货币计为1分钟冻结时间"),
     minFreezeTime: import_koishi.Schema.number().min(0).default(10).description("最小冻结时间(分钟)"),
     maxFreezeTime: import_koishi.Schema.number().min(0).default(1440).description("最大交易冻结时间(分钟)")
-  }).description("冻结机制"),
-  import_koishi.Schema.object({
-    enableManualControl: import_koishi.Schema.boolean().default(false).description("开启手动宏观调控(覆盖自动)"),
-    manualTargetPrice: import_koishi.Schema.number().min(0.01).default(1e3).description("手动目标价格"),
-    manualDuration: import_koishi.Schema.number().min(1).default(24).description("手动调控周期(小时)")
-  }).description("手动宏观调控")
+  }).description("冻结机制")
 ]);
 function apply(ctx, config) {
   ctx.model.extend("bourse_holding", {
@@ -106,10 +101,17 @@ function apply(ctx, config) {
     }
   });
   let wasMarketOpen = false;
+  let dailyOpenPrice = null;
+  let macroWaveCount = 7;
+  let macroWeeklyAmplitudeRatio = 0.08;
+  let nextMacroSwitchTime = null;
   ctx.setInterval(async () => {
     const isOpen = await isMarketOpen();
     if (isOpen && !wasMarketOpen) {
       switchKLinePattern("自动开市");
+      dailyOpenPrice = currentPrice;
+      const hours = 6 + Math.floor(Math.random() * 19);
+      nextMacroSwitchTime = new Date(Date.now() + hours * 3600 * 1e3);
     }
     wasMarketOpen = isOpen;
     if (!isOpen) return;
@@ -366,73 +368,57 @@ function apply(ctx, config) {
       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) {
-      if (!state || state.mode !== "manual" || Math.abs(state.targetPrice - config.manualTargetPrice) > 0.01) {
-        const durationHours = config.manualDuration;
-        const targetPrice = config.manualTargetPrice;
-        const endTime = new Date(now.getTime() + durationHours * 3600 * 1e3);
-        const minutes = durationHours * 60;
-        const trendFactor = (targetPrice - currentPrice) / minutes;
-        const newState = {
-          key: "macro_state",
-          lastCycleStart: now,
-          startPrice: currentPrice,
-          targetPrice,
-          trendFactor,
-          mode: "manual",
-          endTime
-        };
-        if (!state) await ctx.database.create("bourse_state", newState);
-        else {
-          const { key, ...updateFields } = newState;
-          await ctx.database.set("bourse_state", { key: "macro_state" }, updateFields);
-        }
-        state = newState;
-      }
-    }
     let needNewState = false;
-    if (!config.enableManualControl) {
-      if (!state) {
-        needNewState = true;
-      } else {
-        const endTime = state.endTime || new Date(state.lastCycleStart.getTime() + 7 * 24 * 3600 * 1e3);
-        if (now > endTime) {
-          needNewState = true;
-        }
-      }
-      if (needNewState) {
-        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);
-        const minutes = durationHours * 60;
-        const trendFactor = (targetPrice - currentPrice) / minutes;
-        const newState = {
-          key: "macro_state",
-          lastCycleStart: now,
-          startPrice: currentPrice,
-          targetPrice,
-          trendFactor,
-          mode: "auto",
-          endTime
-        };
-        if (!state) {
-          await ctx.database.create("bourse_state", newState);
-        } else {
-          const { key, ...updateFields } = newState;
-          await ctx.database.set("bourse_state", { key: "macro_state" }, updateFields);
-        }
-        state = newState;
+    if (!state) {
+      needNewState = true;
+    } else {
+      const endTime = state.endTime || new Date(state.lastCycleStart.getTime() + 7 * 24 * 3600 * 1e3);
+      if (state.mode !== "manual" && now > endTime) needNewState = true;
+    }
+    const createAutoState = /* @__PURE__ */ __name(async () => {
+      const durationHours = 7 * 24;
+      const fluctuation = 0.3;
+      const targetRatio = 1 + (Math.random() * 2 - 1) * fluctuation;
+      let targetPrice = currentPrice * targetRatio;
+      const upperTarget = currentPrice * 1.5;
+      const lowerTarget = currentPrice * 0.5;
+      targetPrice = Math.max(lowerTarget, Math.min(upperTarget, targetPrice));
+      const endTime = new Date(now.getTime() + durationHours * 3600 * 1e3);
+      const minutes = durationHours * 60;
+      const trendFactor = (targetPrice - currentPrice) / minutes;
+      const newState = {
+        key: "macro_state",
+        lastCycleStart: now,
+        startPrice: currentPrice,
+        targetPrice,
+        trendFactor,
+        mode: "auto",
+        endTime
+      };
+      if (!state) await ctx.database.create("bourse_state", newState);
+      else {
+        const { key, ...updateFields } = newState;
+        await ctx.database.set("bourse_state", { key: "macro_state" }, updateFields);
       }
+      state = newState;
+    }, "createAutoState");
+    if (needNewState) {
+      await createAutoState();
+    } else if (state.mode === "auto" && nextMacroSwitchTime && now >= nextMacroSwitchTime) {
+      const hours = 6 + Math.floor(Math.random() * 19);
+      nextMacroSwitchTime = new Date(now.getTime() + hours * 3600 * 1e3);
+      await createAutoState();
     }
     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 * 3e-3 * (Math.random() * 2 - 1);
+    const basePrice = state.startPrice;
+    const totalDuration = state.endTime.getTime() - state.lastCycleStart.getTime();
+    const elapsed = Math.min(totalDuration, now.getTime() - state.lastCycleStart.getTime());
+    const cycleProgress = elapsed / totalDuration;
+    const trendPrice = basePrice + (state.targetPrice - basePrice) * cycleProgress;
     const dayStart = new Date(now);
     dayStart.setHours(config.openHour, 0, 0, 0);
     const dayEnd = new Date(now);
@@ -440,21 +426,22 @@ function apply(ctx, config) {
     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 dailyAmplitude = basePrice * 0.07;
     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 = 7;
-    const weeklyAmplitude = state.startPrice * 0.08;
-    const getWaveValue = /* @__PURE__ */ __name((t) => {
-      const progress = t / totalDuration;
-      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 + patternDelta + waveDelta;
+    const patternOffset = patternFn(dayProgress) * dailyAmplitude;
+    const waveFrequency = macroWaveCount;
+    const weeklyAmplitude = basePrice * macroWeeklyAmplitudeRatio;
+    const waveOffset = weeklyAmplitude * Math.sin(2 * Math.PI * waveFrequency * cycleProgress);
+    const noise = basePrice * 4e-3 * (Math.random() * 2 - 1);
+    let newPrice = trendPrice + patternOffset + waveOffset + noise;
+    const dayBase = dailyOpenPrice ?? basePrice;
+    const weekUpper = basePrice * 1.5;
+    const weekLower = basePrice * 0.5;
+    const dayUpper = dayBase * 1.5;
+    const dayLower = dayBase * 0.5;
+    const upperLimit = Math.min(weekUpper, dayUpper);
+    const lowerLimit = Math.max(weekLower, dayLower);
+    newPrice = Math.max(lowerLimit, Math.min(upperLimit, newPrice));
     if (newPrice < 1) newPrice = 1;
     newPrice = Number(newPrice.toFixed(2));
     currentPrice = newPrice;
@@ -701,12 +688,17 @@ function apply(ctx, config) {
     const now = /* @__PURE__ */ new Date();
     const endTime = new Date(now.getTime() + duration * 3600 * 1e3);
     const minutes = duration * 60;
-    const trendFactor = (price - currentPrice) / minutes;
+    const baseStart = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0]?.startPrice ?? currentPrice;
+    const dayBase = dailyOpenPrice ?? baseStart;
+    const upper = Math.min(baseStart * 1.5, dayBase * 1.5);
+    const lower = Math.max(baseStart * 0.5, dayBase * 0.5);
+    const targetPriceClamped = Math.max(lower, Math.min(upper, price));
+    const trendFactor = (targetPriceClamped - currentPrice) / minutes;
     const newState = {
       key: "macro_state",
       lastCycleStart: now,
       startPrice: currentPrice,
-      targetPrice: price,
+      targetPrice: targetPriceClamped,
       trendFactor,
       mode: "manual",
       endTime
@@ -715,10 +707,12 @@ function apply(ctx, config) {
     if (existing.length === 0) {
       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);
     }
+    const hint = targetPriceClamped !== price ? `（已按±50%限幅从${price}调整为${Number(targetPriceClamped.toFixed(2))}）` : "";
     return `宏观调控已设置：
-目标价格：${price}
+目标价格：${Number(targetPriceClamped.toFixed(2))}${hint}
 期限：${duration}小时
 模式：手动干预
 到期后将自动切回随机调控。`;
@@ -755,6 +749,24 @@ function apply(ctx, config) {
     switchKLinePattern("管理员手动");
     return "已切换K线模型。";
   });
+  ctx.command("bourse.test.price [ticks:number]", "开发测试：推进价格更新若干次并返回当前价格", { authority: 3 }).action(async ({ session }, ticks) => {
+    const n = typeof ticks === "number" && ticks > 0 ? Math.min(ticks, 500) : 1;
+    for (let i = 0; i < n; i++) {
+      await updatePrice();
+    }
+    return `测试完成：推进${n}次；当前价格：${Number(currentPrice.toFixed(2))}`;
+  });
+  ctx.command("bourse.test.clamp <percent:number>", "开发测试：尝试目标涨跌幅并查看限幅结果", { authority: 3 }).action(async ({ session }, percent) => {
+    if (typeof percent !== "number") return "请输入百分比（例如 60 或 -40）";
+    const baseStart = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0]?.startPrice ?? currentPrice;
+    const dayBase = dailyOpenPrice ?? baseStart;
+    const upper = Math.min(baseStart * 1.5, dayBase * 1.5);
+    const lower = Math.max(baseStart * 0.5, dayBase * 0.5);
+    const expected = currentPrice * (1 + percent / 100);
+    const clamped = Math.max(lower, Math.min(upper, expected));
+    const hint = clamped !== expected ? `（已按±50%限幅从${Number(expected.toFixed(2))}调整为${Number(clamped.toFixed(2))}）` : "";
+    return `测试限幅：当前价=${Number(currentPrice.toFixed(2))}；期望=${Number(expected.toFixed(2))}；结果=${Number(clamped.toFixed(2))}${hint}`;
+  });
   async function renderHoldingImage(ctx2, username, holding, pending, currency) {
     const hasCostData = holding && holding.totalCost !== null;
     const isProfit = hasCostData ? holding.profit >= 0 : true;

package/package.json

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

package/readme.md

@@ -14,12 +14,26 @@
   - 结合 **周级波浪** 与 **宏观趋势**，模拟真实市场的多周期叠加效应。
 - **📊 精美 K 线与持仓渲染**：使用 Puppeteer 渲染实时/日/周线图和个人持仓信息，Alpha 2 版本优化了坐标轴标签算法，防止文字重叠，观感更佳。
 - **❄️ 资金冻结机制**：交易采用 T+0 但资金/股票非即时到账模式，根据金额计算冻结时间，增加博弈深度。
-- **🏦 银行联动**：支持与 `koishi-plugin-monetary-bank` 联动，现金不足时自动扣除银行活期存款。
+- **🏦 银行联动**：支持与[ `koishi-plugin-monetary-bank`](https://github.com/BYWled/koishi-plugin-monetary-bank)[![npm](https://img.shields.io/npm/v/koishi-plugin-monetary-bank?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-monetary-bank) 联动，现金不足时自动扣除银行活期存款。
 - **🕹️ 宏观调控**：管理员可手动干预股价目标，或强制切换当天的 K 线剧本。
 
 ## 更新记录
 
-- 1.1.0：
+- **Alpha.5**：
+  - **重写股票走势引擎**：将增量叠加模式改为绝对价格计算模式，彻底解决长期运行后的高频抖动问题。
+    - 修复：走势计算采用绝对值合成（基准价+趋势进度+日内波动+周波浪+噪音），避免累积误差导致的失控。
+    - 修复：增强±50%限幅机制，确保所有场景下（实时/日/周）均严格受限。
+    - 优化：简化宏观调控状态刷新逻辑，移除复杂的delta计算，提升稳定性。
+    - 性能：新引擎更清晰高效，可长期稳定运行，不会出现抖动或限幅失效。
+
+- **1.1.1（Alpha.4）**：
+  - 新增：硬性涨跌幅上限规则（±50%），同时约束日内与周内视角。随机与手动调控的结果均会在应用前进行限幅。
+  - 新增：更随机的自动宏观调控——随机刷新宏观目标（约每 6–24 小时），并随机调整周波浪频率与幅度（波浪段数约 5–10、周幅度约 6%–12%）。
+  - 修复：手动宏观调控命令更新状态时，严格排除主键字段，避免 `TypeError: cannot modify primary key`。
+  - 变更：移除配置项中的手动宏观调控相关字段（`enableManualControl`、`manualTargetPrice`、`manualDuration`），改为仅通过管理员指令进行宏观调控。
+  - 新增：开发测试命令方便快速验证逻辑（`bourse.test.price`、`bourse.test.clamp`），默认注释不启用，若需要请手动修改代码打开调试。
+
+- **1.1.0**：
   - Alpha.3版本转为正式版。
 
 - **Alpha.3**：
@@ -72,9 +86,7 @@
 - **maxFreezeTime**: 最大冻结时间（分钟，默认 `1440` 即24小时）。
 
 ### 宏观调控
-- **enableManualControl**: 是否开启手动强力调控模式（覆盖自动波动）。
-- **manualTargetPrice**: 手动模式下的目标价格。
-- **manualDuration**: 手动调控周期（小时）。
+- 已移除配置项中的手动宏观调控字段；请使用管理员指令进行宏观调控。
 
 ## 🎮 指令说明
 
@@ -103,7 +115,7 @@
 
 - **`stock.control <price> [hours]`**
   - 设置宏观调控目标。
-  - 说明：强行引导股价在指定时间内向目标价格移动。
+  - 说明：强行引导股价在指定时间内向目标价格移动。若目标涨跌超出±50%限幅，会自动调整至限幅边界后再应用。
   - 示例：`stock.control 5000 12` (在12小时内让股价涨/跌到5000)。
 
 - **`stock.pattern`** *(Alpha 2 新增)*
@@ -115,14 +127,44 @@
   - 参数 `status`: `open` (开启), `close` (关闭), `auto` (自动)。
   - 说明：手动开市时会自动重置并切换一个新的日内 K 线形态。
 
+- 【默认不开启】**`bourse.test.price [ticks]`**
+  - 开发测试：推进价格更新若干次并返回当前价格。
+  - 参数 `ticks`: 推进次数，默认 1，最大 500。
+
+- 【默认不开启】**`bourse.test.clamp <percent>`**
+  - 开发测试：尝试目标涨跌幅并查看限幅结果。
+  - 参数 `percent`: 期望涨跌百分比，例如 `60` 或 `-40`。
+
 ## 💡 常见问题
 
+**Q：Alpha版本有什么区别？**
+A：本插件在发布一个稳定版之前会进行测试，但是股票的走向和时间有关，即使通过开发调试，也难以测试出稳定的结果。因此，在新版本开发出来后（尤其是算法上的更新），我不确定是否存在非致命但影响体验的漏洞。
+
+Alpha版本就是在新版本稳定之前的**过渡版**，它们具备了一些没有验证的新功能、更新，但与之一同的是未知的bug。如需使用Alpha版本，请备份数据库和配置文件，防止以外发生。
+
+---
+
 **Q: 为什么买了股票没有立刻到账？**
 A: 本插件设计了基于交易金额的动态冻结机制。交易额越大，冻结时间越长（可配置）。请使用 `stock.my` 查看剩余解冻时间。
 
+---
+
 **Q: 股价是如何波动的？**
-A: 股价由四部分叠加而成：
+A: 股价采用**绝对价格计算模式**，由以下部分合成：
+
+1. **宏观趋势**：周期内从起始价线性向目标价移动的进度价格。
+2. **日内K线形态**：12种剧本叠加在趋势上的波动偏移（约±4%）。
+3. **周内波浪**：正弦曲线叠加的平滑周期波动。
+4. **微小噪音**：随机扰动避免价格过于规律。
+
+新引擎完全避免增量累积误差，长期运行稳定可靠。
+
+在Alpha.5版本以前，股价由四部分叠加而成：
 1. **宏观趋势**：根据自动或手动的目标价格计算的线性趋势。
 2. **周级波浪**：7天为一个大周期的正弦复合波浪。
 3. **日内形态**：每天随机从 12 种剧本中选择多种（如 V 型、倒 V 型、阶梯上涨等）。
 4. **随机噪音**：微小的随机波动。
+
+新旧引擎的效果相同，仅仅是在算法上进行优化与修复。
+
+此外，为保证市场稳定性，应用了**涨跌幅硬性限制**：相对于周周期起始价与当日开盘价的双重基准，股价的涨跌幅不得超过 ±50%。当随机或手动设置的目标超出限幅时，将自动截断至限幅边界。