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

package/lib/index.js

@@ -377,21 +377,18 @@ function apply(ctx, config) {
     }
     const createAutoState = /* @__PURE__ */ __name(async () => {
       const durationHours = 7 * 24;
-      const fluctuation = 0.3;
+      const fluctuation = 0.25;
       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));
+      let targetPrice2 = currentPrice * targetRatio;
+      targetPrice2 = Math.max(currentPrice * 0.5, Math.min(currentPrice * 1.5, targetPrice2));
       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,
+        targetPrice: targetPrice2,
+        trendFactor: 0,
+        // 不再使用线性趋势因子
         mode: "auto",
         endTime
       };
@@ -415,10 +412,10 @@ function apply(ctx, config) {
       switchKLinePattern("随机时间");
     }
     const basePrice = state.startPrice;
+    const targetPrice = state.targetPrice;
     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 elapsed = now.getTime() - state.lastCycleStart.getTime();
+    const cycleProgress = Math.max(0, Math.min(1, elapsed / totalDuration));
     const dayStart = new Date(now);
     dayStart.setHours(config.openHour, 0, 0, 0);
     const dayEnd = new Date(now);
@@ -426,14 +423,32 @@ 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 = basePrice * 0.07;
+    const expectedPrice = basePrice + (targetPrice - basePrice) * cycleProgress;
+    const deviation = (expectedPrice - currentPrice) / currentPrice;
+    const meanReversionStrength = 0.02;
+    const driftReturn = deviation * meanReversionStrength;
+    const getVolatility = /* @__PURE__ */ __name((progress) => {
+      const morningVol = Math.exp(-8 * progress);
+      const afternoonVol = Math.exp(-8 * (1 - progress));
+      const baseVol = 0.3;
+      return baseVol + morningVol * 0.5 + afternoonVol * 0.4;
+    }, "getVolatility");
+    const volatility = getVolatility(dayProgress);
+    const u1 = Math.random();
+    const u2 = Math.random();
+    const normalRandom = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    const baseVolatilityPerTick = 15e-4;
+    const randomReturn = normalRandom * baseVolatilityPerTick * volatility;
     const patternFn = kLinePatterns[currentDayPattern];
-    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 patternValue = patternFn(dayProgress);
+    const prevPatternValue = patternFn(Math.max(0, dayProgress - 0.01));
+    const patternTrend = (patternValue - prevPatternValue) * 0.5;
+    const patternBias = patternTrend * 3e-3;
+    const wavePhase = 2 * Math.PI * macroWaveCount * cycleProgress;
+    const prevWavePhase = 2 * Math.PI * macroWaveCount * Math.max(0, cycleProgress - 1e-3);
+    const waveTrend = (Math.sin(wavePhase) - Math.sin(prevWavePhase)) * macroWeeklyAmplitudeRatio;
+    const totalReturn = driftReturn + randomReturn + patternBias + waveTrend;
+    let newPrice = currentPrice * (1 + totalReturn);
     const dayBase = dailyOpenPrice ?? basePrice;
     const weekUpper = basePrice * 1.5;
     const weekLower = basePrice * 0.5;
@@ -441,6 +456,14 @@ function apply(ctx, config) {
     const dayLower = dayBase * 0.5;
     const upperLimit = Math.min(weekUpper, dayUpper);
     const lowerLimit = Math.max(weekLower, dayLower);
+    if (newPrice > upperLimit * 0.95) {
+      const overshoot = (newPrice - upperLimit * 0.95) / (upperLimit * 0.05);
+      newPrice = upperLimit * 0.95 + upperLimit * 0.05 * Math.tanh(overshoot);
+    }
+    if (newPrice < lowerLimit * 1.05) {
+      const undershoot = (lowerLimit * 1.05 - newPrice) / (lowerLimit * 0.05);
+      newPrice = lowerLimit * 1.05 - lowerLimit * 0.05 * Math.tanh(undershoot);
+    }
     newPrice = Math.max(lowerLimit, Math.min(upperLimit, newPrice));
     if (newPrice < 1) newPrice = 1;
     newPrice = Number(newPrice.toFixed(2));
@@ -687,24 +710,26 @@ function apply(ctx, config) {
     const duration = hours || 24;
     const now = /* @__PURE__ */ new Date();
     const endTime = new Date(now.getTime() + duration * 3600 * 1e3);
-    const minutes = duration * 60;
-    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 existing = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0];
+    const keepBasePrice = existing?.startPrice ?? currentPrice;
+    const dayBase = dailyOpenPrice ?? keepBasePrice;
+    const upper = Math.min(keepBasePrice * 1.5, dayBase * 1.5);
+    const lower = Math.max(keepBasePrice * 0.5, dayBase * 0.5);
     const targetPriceClamped = Math.max(lower, Math.min(upper, price));
+    const minutes = duration * 60;
     const trendFactor = (targetPriceClamped - currentPrice) / minutes;
     const newState = {
       key: "macro_state",
-      lastCycleStart: now,
-      startPrice: currentPrice,
+      lastCycleStart: existing?.lastCycleStart ?? now,
+      // 保持原周期起点
+      startPrice: keepBasePrice,
+      // 保持原基准价，不重置
       targetPrice: targetPriceClamped,
       trendFactor,
       mode: "manual",
       endTime
     };
-    const existing = await ctx.database.get("bourse_state", { key: "macro_state" });
-    if (existing.length === 0) {
+    if (!existing) {
       await ctx.database.create("bourse_state", newState);
     } else {
       const { key, ...updateFields } = newState;
@@ -749,24 +774,6 @@ 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.2-Alpha.5",
+  "version": "1.1.2-Alpha.7",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -19,6 +19,21 @@
 
 ## 更新记录
 
+- **Alpha.7**：
+  - **采用真实股票模型**：使用几何布朗运动 + 均值回归模型，更贴近真实股票走势。
+  - 新增：均值回归机制——价格会自然向"预期价格"回归，而非硬性跳变。
+  - 新增：动态波动率——开盘和收盘波动大，午盘相对平静（U型波动率曲线）。
+  - 新增：正态分布随机项——使用Box-Muller变换生成更真实的随机波动。
+  - 新增：软着陆限幅——接近涨跌幅限制时逐渐减缓，避免硬切导致的不自然走势。
+  - 优化：K线形态改为提供方向性偏置，而非直接决定价格位置。
+  - 优化：周期波浪改为增量式叠加，更平滑自然。
+
+- **Alpha.6**：
+  - **再次重构**：改用百分比波动模式，所有波动（K线、周波浪、噪音）以百分比形式叠加在趋势价格上，彻底解决振幅失控问题。
+  - 修复：手动宏观调控不再重置周期基准价和起点，保持现有波动机制持续生效。
+  - 优化：K线波动幅度调整为±3%，周波浪和噪音也改为百分比计算，波动更符合真实股票特性。
+  - 性能：新的百分比合成模式更稳定，长期运行不会出现价格失控或波动失效。
+
 - **Alpha.5**：
   - **重写股票走势引擎**：将增量叠加模式改为绝对价格计算模式，彻底解决长期运行后的高频抖动问题。
     - 修复：走势计算采用绝对值合成（基准价+趋势进度+日内波动+周波浪+噪音），避免累积误差导致的失控。
@@ -131,10 +146,6 @@
   - 开发测试：推进价格更新若干次并返回当前价格。
   - 参数 `ticks`: 推进次数，默认 1，最大 500。
 
-- 【默认不开启】**`bourse.test.clamp <percent>`**
-  - 开发测试：尝试目标涨跌幅并查看限幅结果。
-  - 参数 `percent`: 期望涨跌百分比，例如 `60` 或 `-40`。
-
 ## 💡 常见问题
 
 **Q：Alpha版本有什么区别？**
@@ -150,21 +161,28 @@ A: 本插件设计了基于交易金额的动态冻结机制。交易额越大
 ---
 
 **Q: 股价是如何波动的？**
-A: 股价采用**绝对价格计算模式**，由以下部分合成：
+A: 股价采用**几何布朗运动 + 均值回归**模型（Alpha.7），更贴近真实股票：
+
+**核心公式：** `新价格 = 当前价格 × (1 + 总收益率)`
+
+**总收益率由以下部分组成：**
+
+1. **均值回归项（Drift）**：价格会自然向"预期价格"回归
+   - 预期价格 = 周期起始价 → 目标价的线性插值
+   - 偏离越大，回归力越强（每次回归2%的偏差）
 
-1. **宏观趋势**：周期内从起始价线性向目标价移动的进度价格。
-2. **日内K线形态**：12种剧本叠加在趋势上的波动偏移（约±4%）。
-3. **周内波浪**：正弦曲线叠加的平滑周期波动。
-4. **微小噪音**：随机扰动避免价格过于规律。
+2. **随机波动项（Random Walk）**：模拟市场的随机性
+   - 使用正态分布随机数（Box-Muller变换）
+   - 基础波动率约0.15%/tick
 
-新引擎完全避免增量累积误差，长期运行稳定可靠。
+3. **动态波动率**：模拟日内波动率变化
+   - 开盘：波动率高（活跃交易）
+   - 午盘：波动率低（相对平静）
+   - 尾盘：波动率再次升高
 
-在Alpha.5版本以前，股价由四部分叠加而成：
-1. **宏观趋势**：根据自动或手动的目标价格计算的线性趋势。
-2. **周级波浪**：7天为一个大周期的正弦复合波浪。
-3. **日内形态**：每天随机从 12 种剧本中选择多种（如 V 型、倒 V 型、阶梯上涨等）。
-4. **随机噪音**：微小的随机波动。
+4. **K线形态偏置**：12种日内形态提供微小的方向性偏好
+   - 不再直接决定价格位置，而是影响涨跌概率
 
-新旧引擎的效果相同，仅仅是在算法上进行优化与修复。
+5. **周期波浪**：中期波动，模拟市场情绪周期
 
-此外，为保证市场稳定性，应用了**涨跌幅硬性限制**：相对于周周期起始价与当日开盘价的双重基准，股价的涨跌幅不得超过 ±50%。当随机或手动设置的目标超出限幅时，将自动截断至限幅边界。
+**限幅机制：** 相对于周期起始价和日开盘价的±50%，采用软着陆方式避免硬切。