steps;
-
- private BigDecimal totalWin;
-
- private Long recordId;
- private Long boxRecordId;
-
- /** 身份维度 common/anchor/robot/white，白号隔离依据 */
- private String audience;
- /** 是否白号：白号不注水/不扣水/不受水位约束 */
- private boolean blankAccount;
-
- @Data
- public static class CachedStep implements Serializable {
- private int freeSpinId;
- private int cascadeSeq;
- private String gridState;
- private String multiplierDetail;
- private String symbolLinks; // 本旋累积连线（含 tumble）
- private BigDecimal winAmount; // 本旋累计（该旋末帧 = 这一旋的总额）
- private BigDecimal spinWin; // 本局累计（末帧 = totalWin）
- /** 本步后炸弹累计倍数（FS 跨旋传递）；断线重连时前端靠它恢复累计倍数 */
- private BigDecimal accumulatorAfter;
- private int winCapped;
- private String bigwinLevel;
- private int isFinal;
- private String retriggerInfo;
- private String dropData;
- private String fillData;
- private String scatterTrigger;
- }
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/model/cache/OlympusRewardPoolCache.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/model/cache/OlympusRewardPoolCache.java
deleted file mode 100644
index ed791b9..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/model/cache/OlympusRewardPoolCache.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.ruoyi.game.olympus.model.cache;
-
-import lombok.Data;
-
-import java.math.BigDecimal;
-
-/**
- * Olympus 按箱奖池（水位）缓存。
- * 水位 = totalBet - totalWin + adjust（人工注水/抽水），仅真实玩家（白号隔离）。
- */
-@Data
-public class OlympusRewardPoolCache {
- private BigDecimal totalBet;
- private BigDecimal totalWin;
- private BigDecimal adjust;
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusCacheRepository.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusCacheRepository.java
deleted file mode 100644
index c8b151c..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusCacheRepository.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package com.ruoyi.game.olympus.repository;
-
-import com.ruoyi.common.core.redis.RedisCache;
-import com.ruoyi.game.olympus.model.cache.OlympusGameCache;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-import java.util.concurrent.TimeUnit;
-
-import static com.ruoyi.admin.config.RedisConstants.OLYMPUS_GAME_CACHE;
-
-/** 单局进行中缓存（Redis，TTL 30 分钟） */
-@Component
-public class OlympusCacheRepository {
-
- @Autowired
- private RedisCache redisCache;
-
- public OlympusGameCache getCache(Long userId) {
- return redisCache.getCacheObject(OLYMPUS_GAME_CACHE + userId);
- }
-
- public void setCache(Long userId, OlympusGameCache cache) {
- redisCache.setCacheObject(OLYMPUS_GAME_CACHE + userId, cache, 30, TimeUnit.MINUTES);
- }
-
- public void clearCache(Long userId) {
- redisCache.deleteObject(OLYMPUS_GAME_CACHE + userId);
- }
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusCycleRepository.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusCycleRepository.java
deleted file mode 100644
index bf96b9a..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusCycleRepository.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package com.ruoyi.game.olympus.repository;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.stereotype.Component;
-
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.util.concurrent.TimeUnit;
-
-import static com.ruoyi.admin.config.RedisConstants.OLYMPUS_GAME_CYCLE;
-
-/**
- * 一轮内 RTP 动态收敛账本，按 (boxId, audience) 隔离。
- * Hash key = ruoyi:olympus:cycle:{boxId}:{audience}，字段 drawn/mulSum/conv:{ornamentId}。
- * 白号(audience=white)也有独立账本，与其他身份完全隔离。
- */
-@Component
-public class OlympusCycleRepository {
-
- @Autowired
- public RedisTemplate redisTemplate;
-
- private static final String F_DRAWN = "drawn";
- private static final String F_MUL_SUM = "mulSum";
- private static final String F_CONV_PREFIX = "conv:";
- private static final long TTL_DAYS = 30;
-
- private String key(Long boxId, String audience) {
- return OLYMPUS_GAME_CYCLE + boxId + ":" + audience;
- }
-
- public long drawn(Long boxId, String audience) {
- Object v = redisTemplate.opsForHash().get(key(boxId, audience), F_DRAWN);
- return v == null ? 0L : toLong(v);
- }
-
- public double mulSum(Long boxId, String audience) {
- Object v = redisTemplate.opsForHash().get(key(boxId, audience), F_MUL_SUM);
- return v == null ? 0d : toDouble(v);
- }
-
- /** 记一抽：drawn+1、mulSum+actualMul；收敛阶段额外 conv:{ornamentId}+1。 */
- public void recordDraw(Long boxId, String audience, Integer ornamentId, BigDecimal actualMul, boolean converge) {
- String k = key(boxId, audience);
- redisTemplate.opsForHash().increment(k, F_DRAWN, 1L);
- double mul = actualMul != null ? actualMul.doubleValue() : 0d;
- if (mul != 0d) redisTemplate.opsForHash().increment(k, F_MUL_SUM, mul);
- if (converge && ornamentId != null) {
- redisTemplate.opsForHash().increment(k, F_CONV_PREFIX + ornamentId, 1L);
- }
- redisTemplate.expire(k, TTL_DAYS, TimeUnit.DAYS);
- }
-
- public void resetCycle(Long boxId, String audience) {
- redisTemplate.delete(key(boxId, audience));
- }
-
- public long convergeCount(Long boxId, String audience, Integer ornamentId) {
- Object v = redisTemplate.opsForHash().get(key(boxId, audience), F_CONV_PREFIX + ornamentId);
- return v == null ? 0L : toLong(v);
- }
-
- /** 本轮实时 RTP(%) = mulSum / drawn / cm × 100（common 身份口径，供后台展示）。 */
- public BigDecimal realtimeRtp(Long boxId, String audience, double cm) {
- long d = drawn(boxId, audience);
- if (d <= 0 || cm <= 0) return null;
- double rtp = mulSum(boxId, audience) / d / cm * 100;
- return BigDecimal.valueOf(rtp).setScale(2, RoundingMode.HALF_UP);
- }
-
- private static long toLong(Object v) {
- if (v instanceof Number) return ((Number) v).longValue();
- try { return Long.parseLong(v.toString().trim()); } catch (Exception e) { return 0L; }
- }
-
- private static double toDouble(Object v) {
- if (v instanceof Number) return ((Number) v).doubleValue();
- try { return Double.parseDouble(v.toString().trim()); } catch (Exception e) { return 0d; }
- }
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusRewardPoolCacheRepository.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusRewardPoolCacheRepository.java
deleted file mode 100644
index 6aa960c..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/repository/OlympusRewardPoolCacheRepository.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package com.ruoyi.game.olympus.repository;
-
-import com.ruoyi.game.olympus.model.cache.OlympusRewardPoolCache;
-import com.ruoyi.game.olympus.mapper.OlympusRecordMapper;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.stereotype.Component;
-
-import java.math.BigDecimal;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import static com.ruoyi.admin.config.RedisConstants.OLYMPUS_GAME_REWARD_POOL_CACHE;
-
-/**
- * Olympus 按【箱子 × 身份】奖池（水位）仓储 —— 对齐荒野争锋 bullet 的按箱水位模型，再按身份(audience)拆池。
- * 每箱每身份独立键：:box:{boxId}:{audience}:dbbet / :dbwin / :adjust；全局 adjust 也按身份一份。
- * 水位 = box:bet − box:win + box:adjust（可能为负）。
- *
- * 记账口径（方案B''）：bet/win **由 DB 已结算记录按身份派生**（game_olympus_record + tt_user），
- * Redis 仅做短缓存供 payoutCap/展示快速读取；adjust 为管理员人工注水/抽水（Redis）。
- * 因 record 与发奖同一事务提交，池值恒等于已提交的真实账，无"提交后记账崩溃窗口"。
- */
-@Component
-public class OlympusRewardPoolCacheRepository {
-
- @Autowired
- public RedisTemplate redisTemplate;
-
- @Autowired
- private OlympusRecordMapper recordMapper;
-
- private static final String KEY_BOX_PREFIX = OLYMPUS_GAME_REWARD_POOL_CACHE + ":box:";
- /** 全局人工调整累计（各箱 adjust 之和，仅展示），按身份一份 */
- private static final String KEY_ADJUST = OLYMPUS_GAME_REWARD_POOL_CACHE + ":adjust:";
-
- private static final String KEY_DB_BET = ":dbbet";
- private static final String KEY_DB_WIN = ":dbwin";
- /** ponytail: DB 派生结果短缓存；DB 为真相，TTL 内只是短暂滞后、自愈，无永久漂移 */
- private static final long DB_CACHE_TTL_SECONDS = 5;
-
- private static String boxKey(Long boxId, String audience, String suffix) {
- return KEY_BOX_PREFIX + boxId + ":" + audience + suffix;
- }
-
- private static String adjustKey(String audience) {
- return KEY_ADJUST + audience;
- }
-
- /** 管理员逐箱注水/抽水：delta 为正注水、为负抽水；同时累加该身份的全局 adjust 键 */
- public void adjustBox(Long boxId, String audience, BigDecimal delta) {
- if (boxId == null || delta == null || delta.signum() == 0) return;
- redisTemplate.opsForValue().increment(boxKey(boxId, audience, ":adjust"), delta.doubleValue());
- redisTemplate.opsForValue().increment(adjustKey(audience), delta.doubleValue());
- }
-
- /** 仅调整全局 adjust 键（重置已删除箱子遗留残余），不动箱子键 */
- public void adjustGlobal(String audience, BigDecimal delta) {
- if (delta == null || delta.signum() == 0) return;
- redisTemplate.opsForValue().increment(adjustKey(audience), delta.doubleValue());
- }
-
- public BigDecimal getGlobalAdjust(String audience) {
- return readValue(adjustKey(audience));
- }
-
- public OlympusRewardPoolCache getBoxCache(Long boxId, String audience) {
- OlympusRewardPoolCache cache = new OlympusRewardPoolCache();
- cache.setTotalBet(dbPoolTotal(boxId, audience, KEY_DB_BET));
- cache.setTotalWin(dbPoolTotal(boxId, audience, KEY_DB_WIN));
- cache.setAdjust(readValue(boxKey(boxId, audience, ":adjust")));
- return cache;
- }
-
- public BigDecimal getBoxAdjust(Long boxId, String audience) {
- return readValue(boxKey(boxId, audience, ":adjust"));
- }
-
- /** 箱子×身份水位 = 该身份箱内累计投注 − 累计返奖 + 人工调整（可能为负） */
- public BigDecimal getBoxBalance(Long boxId, String audience) {
- OlympusRewardPoolCache c = getBoxCache(boxId, audience);
- return c.getTotalBet().subtract(c.getTotalWin()).add(c.getAdjust())
- .setScale(2, java.math.RoundingMode.HALF_UP);
- }
-
- /** 读取某箱某身份 bet/win 的 DB 派生值（短缓存；缓存缺失时按 record 聚合重算） */
- private BigDecimal dbPoolTotal(Long boxId, String audience, String suffix) {
- String key = boxKey(boxId, audience, suffix);
- Object v = redisTemplate.opsForValue().get(key);
- if (v != null) return toBd(v);
- refreshDbPool(boxId, audience);
- return toBd(redisTemplate.opsForValue().get(key));
- }
-
- private void refreshDbPool(Long boxId, String audience) {
- Map row = boxId != null ? recordMapper.sumPool(boxId, audience) : null;
- BigDecimal bet = toBd(row != null ? row.get("totalBet") : null);
- BigDecimal win = toBd(row != null ? row.get("totalWin") : null);
- redisTemplate.opsForValue().set(boxKey(boxId, audience, KEY_DB_BET), bet.doubleValue(), DB_CACHE_TTL_SECONDS, TimeUnit.SECONDS);
- redisTemplate.opsForValue().set(boxKey(boxId, audience, KEY_DB_WIN), win.doubleValue(), DB_CACHE_TTL_SECONDS, TimeUnit.SECONDS);
- }
-
- private BigDecimal readValue(String key) {
- return toBd(redisTemplate.opsForValue().get(key));
- }
-
- private static BigDecimal toBd(Object v) {
- if (v == null) return BigDecimal.ZERO;
- try {
- return new BigDecimal(v.toString());
- } catch (Exception e) {
- return BigDecimal.ZERO;
- }
- }
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusDistributionService.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusDistributionService.java
deleted file mode 100644
index 464ac0b..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusDistributionService.java
+++ /dev/null
@@ -1,354 +0,0 @@
-package com.ruoyi.game.olympus.service;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.ruoyi.game.olympus.domain.OlympusBox;
-import com.ruoyi.game.olympus.domain.OlympusBoxOrnament;
-import com.ruoyi.game.olympus.domain.OlympusBoxTemplate;
-import com.ruoyi.game.olympus.domain.OlympusOrnament;
-import com.ruoyi.game.olympus.enums.OlympusModeType;
-import com.ruoyi.game.olympus.mapper.OlympusBoxMapper;
-import com.ruoyi.game.olympus.mapper.OlympusBoxOrnamentMapper;
-import com.ruoyi.game.olympus.mapper.OlympusBoxTemplateMapper;
-import com.ruoyi.game.olympus.mapper.OlympusOrnamentMapper;
-import com.ruoyi.game.olympus.mapper.OlympusRoundMapper;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.*;
-
-/**
- * Olympus 饰品桶分布计算 / 重置服务（按身份 audience）。
- * 算法移植自 sweet：目标 RTP → 幂律权重二分 → 单调约束 → 微调逼近；
- * 差异：expect_mul 从 game_olympus_ornament 读，基础权重按模式桶区间通用生成(30×0.6^k)。
- */
-@Service
-public class OlympusDistributionService {
-
- private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
- @Autowired private OlympusBoxMapper boxMapper;
- @Autowired private OlympusBoxOrnamentMapper boxOrnamentMapper;
- @Autowired private OlympusBoxTemplateMapper boxTemplateMapper;
- @Autowired private OlympusOrnamentMapper ornamentMapper;
- @Autowired private OlympusRoundMapper roundMapper;
-
- /**
- * 桶"实际发出期望"覆盖：桶 17 展示 1000x（区间 630~1370），但单局封顶 1000，
- * 真正发出去的是 min(原始分, 1000)。理论值（原始分均匀分布）E[min(x,1000)] = 907.5；
- * 实测（buy_fs 10 箱 × 桶17 全部回合 = 200 个）均值 834.6、中位 821.3、27.5% 触顶，
- * 因为生成端种的大奖目标集中在 1000 附近而不是均匀分布。
- * 配比计算（calcRounds）与后台「目标RTP」都按"实际会发出去多少钱"算，所以用实测值：
- * 用名义 1000 会把 RTP 高估约 0.5~1.6 个百分点。
- * 注：抽回合时的 payoutCap 过滤（OlympusRoundPicker）仍读 DB 的名义 expect_mul，偏保守、保留安全余量。
- */
- private static final Map PAYOUT_EXPECT_OVERRIDE = Map.of(17, 835.0);
-
- /** 饰品桶 ID → 实际发出期望（受封顶影响的桶用覆盖值，其余用 DB 的 expect_mul）。 */
- public Map loadOrnamentMul() {
- Map m = new HashMap<>();
- for (OlympusOrnament o : ornamentMapper.selectList(null)) {
- if (o.getId() == null) continue;
- int id = o.getId().intValue();
- Double override = PAYOUT_EXPECT_OVERRIDE.get(id);
- if (override != null) { m.put(id, override); continue; }
- m.put(id, o.getExpectMul() != null ? o.getExpectMul().doubleValue() : 0.0);
- }
- return m;
- }
-
- /** 该桶池子里一条回合都没有时才回退名义期望：只要池子有回合，它的均值就是这个箱子的真实期望 */
- private static final int MIN_POOL_SAMPLE = 1;
-
- /**
- * 桶 → **这个箱子的池子实际会赔出去多少钱**的期望（AVG(actual_mul)，按 boxId 统计）。
- *
- * 为什么不用名义 expect_mul：桶内实际均值与区间中点有偏差（实测 -18% ~ +11%，桶 17 还受 1000x 封顶
- * 影响只有 ~835），用名义值算配比 → 「设 80% 实际赔 81.8%」这种系统性偏差；而且每个箱子的池子是
- * 独立生成的一批回合，只有按它自己的池内均值算，算出来的配比才真的等于该箱的期望赔付。
- * 样本不足的桶回退名义值（池子还没生成时也能算）。
- */
- public Map loadPoolExpect(Long boxId) {
- Map expect = new HashMap<>(loadOrnamentMul());
- if (boxId == null) return expect;
- try {
- for (Map row : roundMapper.avgMulByOrnament(boxId)) {
- Object idObj = row.get("ornamentId");
- Object nObj = row.get("sampleCount");
- Object avgObj = row.get("avgMul");
- if (idObj == null || avgObj == null) continue;
- int id = ((Number) idObj).intValue();
- long n = nObj instanceof Number ? ((Number) nObj).longValue() : 0L;
- double avg = ((Number) avgObj).doubleValue();
- if (!expect.containsKey(id)) continue;
- if (n < MIN_POOL_SAMPLE || avg <= 0) continue;
- expect.put(id, avg);
- }
- } catch (Exception ignore) {
- // 池子还没生成/查询异常 → 用名义值兜底
- }
- return expect;
- }
-
- /**
- * 按目标 RTP 动态计算各饰品桶回合数（幂律 power 二分搜索 + 单调 + 微调）。
- * 期望值用 {@link #loadPoolExpect}（**该箱**池内实际均值），所以算出来的配比实际赔付就等于 targetRtp。
- * @param mode 模式 @param boxId 箱子（决定用哪个池子的实际均值） @param totalRounds 固定池回合数 @param targetRtp 目标 RTP(如 0.8)
- */
- public Map calcRounds(OlympusModeType mode, Long boxId, int totalRounds, double targetRtp) {
- double cm = mode.getCostMultiplier();
- double targetAvg = targetRtp * cm;
- Map ornMul = loadPoolExpect(boxId);
-
- // 基础权重：模式桶区间 [lo,hi] 内 30×0.6^k 等比递减
- int[] range = mode.getOrnamentRange();
- int lo = range[0], hi = range[1];
- int n = Math.max(1, hi - lo + 1);
- double[][] baseWeights = new double[n][2];
- for (int i = 0; i < n; i++) {
- baseWeights[i][0] = lo + i;
- baseWeights[i][1] = 30.0 * Math.pow(0.6, i);
- }
-
- int nOrns = baseWeights.length;
- // 回合数不足：每桶至少 1，均摊
- if (totalRounds <= nOrns) {
- Map flat = new LinkedHashMap<>();
- for (double[] w : baseWeights) flat.put((int) w[0], 1);
- return flat;
- }
- int remainingRounds = totalRounds - nOrns;
-
- double guaranteedMulSum = 0;
- for (double[] w : baseWeights) guaranteedMulSum += ornMul.getOrDefault((int) w[0], 0.0);
- double targetTotalMul = targetAvg * totalRounds;
- double remainingTargetMul = targetTotalMul - guaranteedMulSum;
- double remainingTargetAvg = remainingTargetMul / remainingRounds;
-
- // 二分 power
- double power = 1.0, plo = 0.2, phi = 10.0;
- for (int iter = 0; iter < 30; iter++) {
- double sumW = 0, sumWMul = 0;
- for (double[] w : baseWeights) {
- double weight = Math.pow(w[1], power);
- sumW += weight;
- sumWMul += weight * ornMul.getOrDefault((int) w[0], 0.0);
- }
- double avg = sumW > 0 ? sumWMul / sumW : 0;
- if (Math.abs(avg - remainingTargetAvg) < Math.max(remainingTargetAvg * 0.01, 0.001)) break;
- if (avg < remainingTargetAvg) phi = power; else plo = power;
- power = (plo + phi) / 2;
- }
-
- Map result = new LinkedHashMap<>();
- for (double[] w : baseWeights) result.put((int) w[0], 1);
- double totalW = 0;
- Map adjWeights = new LinkedHashMap<>();
- for (double[] w : baseWeights) {
- double weight = Math.pow(w[1], power);
- adjWeights.put((int) w[0], weight);
- totalW += weight;
- }
- int rem = remainingRounds;
- for (double[] w : baseWeights) {
- int ornId = (int) w[0];
- int extra = totalW > 0 ? (int) Math.round(adjWeights.get(ornId) / totalW * remainingRounds) : 0;
- int put = Math.min(extra, rem);
- if (put > 0) { result.put(ornId, result.get(ornId) + put); rem -= put; }
- }
- if (rem > 0) { int first = (int) baseWeights[0][0]; result.put(first, result.get(first) + rem); }
-
- // 单调：count[i] >= count[i+1]
- List sortedIds = new ArrayList<>(result.keySet());
- sortedIds.sort(Integer::compareTo);
- for (int i = sortedIds.size() - 2; i >= 0; i--) {
- int cur = sortedIds.get(i), next = sortedIds.get(i + 1);
- if (result.get(cur) < result.get(next)) result.put(cur, result.get(next));
- }
- int curTotal = result.values().stream().mapToInt(Integer::intValue).sum();
- int diff = totalRounds - curTotal;
- if (diff != 0) { int first = sortedIds.get(0); result.put(first, result.get(first) + diff); }
-
- // 微调：任取两个桶搬 1 个（保持单调），只要更接近目标
- // （原来只在"最大的 3 个桶"之间搬，池内均值口径下根本走不到目标，会差 0.5~1 个百分点）
- for (int iter = 0; iter < 400; iter++) {
- double currentMul = 0;
- for (Map.Entry e : result.entrySet())
- currentMul += e.getValue() * ornMul.getOrDefault(e.getKey(), 0.0);
- double deltaMul = targetAvg * totalRounds - currentMul;
- if (Math.abs(deltaMul) < 0.01) break;
- int bestLo = -1, bestHi = -1;
- double bestDiff = Math.abs(deltaMul);
- for (int loId : sortedIds) {
- if (result.get(loId) <= 1) continue;
- for (int hiId : sortedIds) {
- if (loId == hiId) continue;
- double change = ornMul.getOrDefault(hiId, 0.0) - ornMul.getOrDefault(loId, 0.0);
- if (Math.abs(change) < 0.001) continue;
- double nd = Math.abs(deltaMul - change);
- if (nd < bestDiff) {
- boolean ok = true;
- int ca = result.get(loId) - 1, idxLo = sortedIds.indexOf(loId);
- if (idxLo < sortedIds.size() - 1 && ca < result.get(sortedIds.get(idxLo + 1))) ok = false;
- int ca2 = result.get(hiId) + 1, idxHi = sortedIds.indexOf(hiId);
- if (idxHi > 0 && ca2 > result.get(sortedIds.get(idxHi - 1))) ok = false;
- if (sortedIds.indexOf(loId) < sortedIds.indexOf(hiId) && ca < ca2) ok = false;
- if (ok) { bestDiff = nd; bestLo = loId; bestHi = hiId; }
- }
- }
- }
- if (bestLo < 0) break;
- result.put(bestLo, result.get(bestLo) - 1);
- result.put(bestHi, result.get(bestHi) + 1);
- }
- return result;
- }
-
- /** 模拟 payoutCap 约束下的实际 RTP(%)：桶的赔付期望按该箱池内实际均值算。 */
- public double simulateActualRtp(Map distribution, Long boxId, double rtp, int simRounds) {
- if (distribution == null || distribution.isEmpty() || simRounds <= 0) return 0;
- Map ornMul = loadPoolExpect(boxId);
- double cm = 1.0;
- if (boxId != null) {
- OlympusBox box = boxMapper.selectById(boxId);
- if (box != null) cm = OlympusModeType.fromBoxType(box.getBoxType()).getCostMultiplier();
- }
- if (cm <= 0) return 0;
- List mulList = new ArrayList<>();
- for (Map.Entry e : distribution.entrySet()) {
- if (e.getValue() == null || e.getValue() <= 0) continue;
- double mul = ornMul.getOrDefault(e.getKey(), 0.0);
- for (int i = 0; i < e.getValue(); i++) mulList.add(mul);
- }
- if (mulList.isEmpty()) return 0;
- Random rnd = new Random();
- double totalRtpSum = 0;
- for (int round = 0; round < simRounds; round++) {
- Collections.shuffle(mulList, rnd);
- double balance = 0, totalPayout = 0, totalCost = 0;
- for (double mul : mulList) {
- double payoutCap = Math.max(0, balance + cm) * rtp;
- double actualMul = (mul <= payoutCap) ? mul : 0;
- balance += cm - actualMul;
- totalPayout += actualMul;
- totalCost += cm;
- }
- totalRtpSum += totalCost > 0 ? totalPayout / totalCost : 0;
- }
- return (totalRtpSum / simRounds) * 100;
- }
-
- /** 由固定池回合数反推总回合 N = round(fixed/(1-cr))。 */
- public static int deriveTotalRounds(int fixedRounds, double convergeRatio) {
- double cr = convergeRatio < 0 ? 0 : (convergeRatio > 0.9 ? 0.9 : convergeRatio);
- return (int) Math.round(fixedRounds / (1.0 - cr));
- }
-
- /** 由总回合 N 算固定池回合数 fixed = round(N*(1-cr))。 */
- public static int deriveFixedRounds(int totalRounds, double convergeRatio) {
- double cr = convergeRatio < 0 ? 0 : (convergeRatio > 0.9 ? 0.9 : convergeRatio);
- return (int) Math.round(totalRounds * (1.0 - cr));
- }
-
- private static double convergeRatioOf(OlympusBox box) {
- double cr = (box != null && box.getRtpConvergeRatio() != null) ? box.getRtpConvergeRatio().doubleValue() : 0.15;
- if (cr < 0) cr = 0;
- if (cr > 0.9) cr = 0.9;
- return cr;
- }
-
- /** 重算某箱某身份分布：按目标 RTP 分配固定池 count，used 归 0。 */
- @Transactional(rollbackFor = Exception.class)
- public void reset(Long boxId, String audience) {
- OlympusBox box = boxMapper.selectById(boxId);
- if (box == null) return;
- OlympusModeType mode = OlympusModeType.fromBoxType(box.getBoxType());
- int totalRounds = box.getTotalOrnaments() != null ? box.getTotalOrnaments() : 200;
- double targetRtp = box.getRtp() != null ? box.getRtp().doubleValue() : 0.8;
- int fixedRounds = deriveFixedRounds(totalRounds, convergeRatioOf(box));
- if (fixedRounds < 1) fixedRounds = totalRounds;
- Map dist = calcRounds(mode, boxId, fixedRounds, targetRtp);
- List list = new ArrayList<>();
- for (Map.Entry e : dist.entrySet()) {
- if (e.getValue() == null || e.getValue() <= 0) continue;
- OlympusBoxOrnament bo = new OlympusBoxOrnament();
- bo.setBoxId(boxId);
- bo.setOrnamentId(e.getKey());
- bo.setAudience(audience);
- bo.setCount(e.getValue());
- bo.setUsed(0);
- list.add(bo);
- }
- boxOrnamentMapper.deleteByBoxIdAndAudience(boxId, audience);
- if (!list.isEmpty()) boxOrnamentMapper.batchInsert(list);
- }
-
- /** 应用模板分布到某箱某身份（count 取模板、used 归 0），并按固定池反推回写总回合。 */
- @Transactional(rollbackFor = Exception.class)
- public void writeDistribution(Long boxId, String audience, List> items) {
- boxOrnamentMapper.deleteByBoxIdAndAudience(boxId, audience);
- int total = 0;
- List list = new ArrayList<>();
- if (items != null) {
- for (Map item : items) {
- Integer ornamentId = toInt(item.get("ornamentId"));
- Integer count = toInt(item.get("count"));
- if (ornamentId == null || count == null || count <= 0) continue;
- OlympusBoxOrnament bo = new OlympusBoxOrnament();
- bo.setBoxId(boxId);
- bo.setOrnamentId(ornamentId);
- bo.setAudience(audience);
- bo.setCount(count);
- bo.setUsed(0);
- list.add(bo);
- total += count;
- }
- }
- if (!list.isEmpty()) boxOrnamentMapper.batchInsert(list);
- OlympusBox box = boxMapper.selectById(boxId);
- if (box != null) {
- box.setTotalOrnaments(deriveTotalRounds(total, convergeRatioOf(box)));
- boxMapper.updateById(box);
- }
- }
-
- /** 某箱某身份抽干补桶：优先按该身份生效模板重写；否则仅 used 归 0。 */
- @Transactional(rollbackFor = Exception.class)
- public void refillFromConfig(Long boxId, String audience) {
- OlympusBoxTemplate active = boxTemplateMapper.selectOne(
- new LambdaQueryWrapper()
- .eq(OlympusBoxTemplate::getBoxId, boxId)
- .eq(OlympusBoxTemplate::getAudience, audience)
- .eq(OlympusBoxTemplate::getIsActive, 1)
- .orderByDesc(OlympusBoxTemplate::getId).last("LIMIT 1"));
- if (active != null && active.getItemsJson() != null) {
- List> items = parseItems(active.getItemsJson());
- if (!items.isEmpty()) { writeDistribution(boxId, audience, items); return; }
- }
- boxOrnamentMapper.resetUsed(boxId, audience);
- }
-
- public List distribution(Long boxId, String audience) {
- return boxOrnamentMapper.selectByBoxIdAndAudience(boxId, audience);
- }
-
- public List> parseItems(String itemsJson) {
- try {
- return OBJECT_MAPPER.readValue(itemsJson, new TypeReference>>() {});
- } catch (Exception e) {
- return new ArrayList<>();
- }
- }
-
- public String toItemsJson(Object items) {
- try { return OBJECT_MAPPER.writeValueAsString(items); } catch (Exception e) { return "[]"; }
- }
-
- private static Integer toInt(Object v) {
- if (v == null) return null;
- if (v instanceof Number) return ((Number) v).intValue();
- try { return Integer.valueOf(v.toString().trim()); } catch (Exception e) { return null; }
- }
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusGameService.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusGameService.java
deleted file mode 100644
index 3714425..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusGameService.java
+++ /dev/null
@@ -1,526 +0,0 @@
-package com.ruoyi.game.olympus.service;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
-import com.ruoyi.admin.mapper.TtBoxRecordsMapper;
-import com.ruoyi.admin.mapper.TtOrnamentsLevelMapper;
-import com.ruoyi.admin.service.TtUserService;
-import com.ruoyi.common.core.domain.R;
-import com.ruoyi.message.service.MessageService;
-import com.ruoyi.common.exception.ServiceException;
-import com.ruoyi.common.redis.config.RedisLock;
-import com.ruoyi.domain.common.constant.MessageCategoryEnum;
-import com.ruoyi.domain.common.constant.TtAccountRecordSource;
-import com.ruoyi.domain.common.constant.TtboxRecordSource;
-import com.ruoyi.domain.entity.TtBoxRecords;
-import com.ruoyi.domain.entity.sys.TtUser;
-import com.ruoyi.domain.other.TtOrnamentsLevel;
-import com.ruoyi.game.olympus.contract.request.SpinRequest;
-import com.ruoyi.game.olympus.contract.response.SpinResponse;
-import com.ruoyi.game.olympus.domain.*;
-import com.ruoyi.game.olympus.enums.OlympusAudience;
-import com.ruoyi.game.olympus.enums.OlympusModeType;
-import com.ruoyi.game.olympus.mapper.*;
-import com.ruoyi.game.olympus.model.PickedRound;
-import com.ruoyi.game.olympus.model.cache.OlympusGameCache;
-import com.ruoyi.game.olympus.repository.OlympusCacheRepository;
-import com.ruoyi.game.olympus.repository.OlympusCycleRepository;
-import com.ruoyi.game.olympus.repository.OlympusRewardPoolCacheRepository;
-import com.ruoyi.user.service.ApiUserService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.support.TransactionTemplate;
-
-import java.math.BigDecimal;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-import static com.ruoyi.admin.config.RedisConstants.COMMON_LOCK;
-
-/**
- * Olympus 核心游戏服务：dospin 开局/播放/结算 + 多身份选池 + 按箱水位 + 白号隔离。
- */
-@Slf4j
-@Service
-public class OlympusGameService {
-
- @Autowired private OlympusBoxMapper boxMapper;
- @Autowired private OlympusRoundPicker roundPicker;
- @Autowired private OlympusBoxOrnamentMapper boxOrnamentMapper;
- @Autowired private OlympusRecordMapper recordMapper;
- @Autowired private OlympusUserMapper userMapper;
- @Autowired private OlympusRoundMapper roundMapper;
- @Autowired private OlympusPrizeRangeMapper prizeRangeMapper;
- @Autowired private OlympusDistributionService distributionService;
- @Autowired private OlympusCacheRepository cacheRepository;
- @Autowired private OlympusCycleRepository cycleRepository;
- @Autowired private OlympusRewardPoolCacheRepository rewardPoolRepository;
-
- @Autowired private TtUserService userService;
- @Autowired private ApiUserService apiUserService;
- @Autowired private RedisLock redisLock;
- @Autowired private TransactionTemplate transactionTemplate;
-
- @Autowired(required = false) private TtBoxRecordsMapper boxRecordsMapper;
- @Autowired(required = false) private TtOrnamentsLevelMapper ornamentsLevelMapper;
- @Autowired private MessageService messageService;
-
- private static final com.fasterxml.jackson.databind.ObjectMapper MAPPER =
- new com.fasterxml.jackson.databind.ObjectMapper();
-
- /** 单局封顶：总倍率≥此值视为已 1000x 封顶 */
- private static final BigDecimal MAX_WIN_CAP_MUL = new BigDecimal("1000");
-
- /** 免费旋转总旋数上限：15 起，每次重触发 +5，封顶 30 */
- private static final int MAX_FREE_SPINS = 30;
-
- // ============================================================
- // dospin 主入口
- // ============================================================
-
- public SpinResponse doSpin(Long userId, SpinRequest req) throws Exception {
- Boolean lock = redisLock.tryLock(COMMON_LOCK + userId, 3L, 7L, TimeUnit.SECONDS);
- if (!Boolean.TRUE.equals(lock)) throw new RuntimeException("请求频繁，请稍后再试");
- try {
- OlympusGameCache cache = cacheRepository.getCache(userId);
- return cache == null ? startNewGame(userId, req != null ? req.getBoxId() : null) : continueGame(userId, cache);
- } finally {
- redisLock.unlock(COMMON_LOCK + userId);
- }
- }
-
- // ============================================================
- // 新游戏：扣费 + 多身份选池 + 缓存步骤 + 返回第一步
- // ============================================================
-
- private SpinResponse startNewGame(Long userId, Long boxId) {
- if (boxId == null) throw new IllegalArgumentException("boxId 不能为空");
- OlympusBox box = boxMapper.selectById(boxId);
- if (box == null || !"1".equals(box.getStatus())) throw new IllegalArgumentException("箱子不可用");
-
- OlympusModeType mode = OlympusModeType.fromBoxType(box.getBoxType());
- BigDecimal bet = coalesce(box.getBet());
- BigDecimal cost = bet.multiply(BigDecimal.valueOf(mode.getCostMultiplier()));
-
- R rechargeCheck = apiUserService.checkRecharge(userId.intValue());
- if (R.isError(rechargeCheck)) throw new ServiceException("玩家未充值不能游玩任何游戏", 703);
-
- TtUser player = userService.getById(userId);
- if (player == null || player.getAccountAmount() == null || player.getAccountAmount().compareTo(cost) < 0) {
- throw new ServiceException("账户余额不足", 702);
- }
-
- // 身份解析：白号最高优先，压过 user_type
- OlympusAudience audience = OlympusAudience.resolve(player);
- boolean isBlank = audience.isWhite();
-
- // 购买模式必须选有免费旋转的回合
- Boolean needFreeSpins = mode.isBuyMode() ? Boolean.TRUE : null;
-
- // 水位赔付上限：真实玩家按 (本箱水位 + 本局成本) × rtp 约束；白号 payoutCap=null（纯概率、不受水位）
- BigDecimal payoutCap = null;
- if (!isBlank) {
- double ratio = box.getRtp() != null ? box.getRtp().doubleValue() : 0.8;
- BigDecimal balance = rewardPoolRepository.getBoxBalance(boxId, audience.getCode()).add(cost);
- if (balance.signum() < 0) balance = BigDecimal.ZERO;
- payoutCap = scale2(balance.multiply(BigDecimal.valueOf(ratio)));
- }
-
- PickedRound picked = roundPicker.pick(boxId, audience.getCode(), needFreeSpins, bet, payoutCap);
- if (picked == null || picked.getRound() == null) throw new RuntimeException("该箱子暂无可用回合");
-
- BigDecimal totalMul = coalesce(picked.getRound().getActualMul());
- BigDecimal totalWin = scale2(totalMul.multiply(bet));
-
- List cachedSteps = new ArrayList<>();
- for (OlympusStep s : picked.getSteps()) {
- OlympusGameCache.CachedStep cs = new OlympusGameCache.CachedStep();
- cs.setFreeSpinId(coalesce0(s.getFreeSpinId()));
- cs.setCascadeSeq(coalesce0(s.getCascadeSeq()));
- cs.setGridState(s.getGridState());
- cs.setMultiplierDetail(s.getMultiplierDetail());
- cs.setSymbolLinks(s.getSymbolLinks());
- cs.setWinAmount(s.getWinAmount());
- cs.setSpinWin(coalesce(s.getSpinWin()));
- cs.setAccumulatorAfter(coalesce(s.getAccumulatorAfter()));
- cs.setWinCapped(coalesce0(s.getWinCapped()));
- cs.setBigwinLevel(s.getBigwinLevel());
- cs.setIsFinal(coalesce0(s.getIsFinal()));
- cs.setRetriggerInfo(s.getRetriggerInfo());
- cs.setDropData(s.getDropData());
- cs.setFillData(s.getFillData());
- cs.setScatterTrigger(s.getScatterTrigger());
- cachedSteps.add(cs);
- }
-
- OlympusGameCache cache = new OlympusGameCache();
- cache.setBoxId(boxId);
- cache.setBoxType(box.getBoxType());
- cache.setBet(bet);
- cache.setCost(cost);
- cache.setRoundId(picked.getRound().getRoundId());
- cache.setTotalMul(totalMul);
- cache.setFreeSpinCount(coalesce0(picked.getRound().getFreeSpinCount()));
- cache.setStepIndex(1);
- cache.setSteps(cachedSteps);
- cache.setTotalWin(totalWin);
- cache.setAudience(audience.getCode());
- cache.setBlankAccount(isBlank);
-
- boolean firstIsFinal = cachedSteps.size() == 1;
-
- transactionTemplate.executeWithoutResult(status -> {
- R deductR = userService.updateUserAccount(userId.intValue(), cost.negate(), TtAccountRecordSource.OLYMPUS_SPIN);
- if (R.isError(deductR)) throw new RuntimeException(deductR.getMsg());
-
- OlympusRecord record = new OlympusRecord();
- record.setUserId(userId);
- record.setBoxId(boxId);
- record.setRoundId(picked.getRound().getRoundId());
- record.setCost(cost);
- record.setTotalWin(BigDecimal.ZERO);
- record.setModeType(box.getBoxType());
- record.setSettled(0);
- record.setCreateTime(new Date());
- recordMapper.insert(record);
- cache.setRecordId(record.getId());
-
- // 仅固定阶段消耗对应 audience 一个回合（白号消耗自己的 white 库存，不碰其他身份）
- if (!picked.isConverge()) {
- boxOrnamentMapper.incrUsed(boxId, picked.getRound().getOrnamentId(), audience.getCode());
- }
- // 开局即结算：回合结果已确定，立即将饰品写入背包（与扣费同事务，中途退出/刷新无损）
- settleAtStart(userId, cache);
- });
-
- // 事务已提交（钱已扣、奖已落库）。以下全是 Redis 缓存/节奏账本/补桶，非资金操作：
- // 一旦失败必须吞掉——否则接口返回 500，玩家以为没开局而重试，会再开一局、再扣一次钱。
- try {
- cycleRepository.recordDraw(boxId, audience.getCode(), picked.getRound().getOrnamentId(),
- coalesce(picked.getRound().getActualMul()), picked.isConverge());
- // 一轮 N 按该身份固定池分布反推（与 RoundPicker 一致，身份级独立）
- int fixedSum = boxOrnamentMapper.selectByBoxIdAndAudience(boxId, audience.getCode()).stream()
- .mapToInt(bo -> bo.getCount() != null ? bo.getCount() : 0).sum();
- double cr = box.getRtpConvergeRatio() != null ? box.getRtpConvergeRatio().doubleValue() : 0.15;
- int cycleN = fixedSum > 0 ? OlympusDistributionService.deriveTotalRounds(fixedSum, cr) : coalesce0(box.getTotalOrnaments());
- if (cycleN > 0 && cycleRepository.drawn(boxId, audience.getCode()) >= cycleN) {
- cycleRepository.resetCycle(boxId, audience.getCode());
- distributionService.refillFromConfig(boxId, audience.getCode());
- }
-
- if (firstIsFinal) {
- if (cache.getTotalWin().compareTo(BigDecimal.ZERO) <= 0) cache.setTotalWin(new BigDecimal("0.01"));
- cacheRepository.clearCache(userId);
- } else {
- cacheRepository.setCache(userId, cache);
- }
- } catch (Exception e) {
- log.error("olympus 开局后置处理失败（扣费与发奖已提交，不影响本局结果）userId={} boxId={}", userId, boxId, e);
- }
- // 单步局开局即播完，通知此刻发；多步局等末帧（continueGame）
- if (firstIsFinal) sendWinNotice(userId, cache);
- return buildStepResponse(cache, cachedSteps.get(0), 1, firstIsFinal);
- }
-
- // ============================================================
- // 继续游戏：取下一步
- // ============================================================
-
- private SpinResponse continueGame(Long userId, OlympusGameCache cache) {
- int nextIdx = cache.getStepIndex() + 1;
- if (nextIdx > cache.getSteps().size()) {
- cacheRepository.clearCache(userId);
- throw new RuntimeException("游戏已结束");
- }
- OlympusGameCache.CachedStep step = cache.getSteps().get(nextIdx - 1);
- cache.setStepIndex(nextIdx);
-
- if (nextIdx == cache.getSteps().size()) {
- if (cache.getTotalWin().compareTo(BigDecimal.ZERO) <= 0) cache.setTotalWin(new BigDecimal("0.01"));
- // 末帧已播完：这一局才算结束，战绩列表（我的/全服）才会展示
- recordMapper.update(null, new LambdaUpdateWrapper()
- .eq(OlympusRecord::getId, cache.getRecordId())
- .set(OlympusRecord::getSettleSource, "finish"));
- // 末帧到了才发结算通知（开局发会在动画播完前剧透），失败只记日志不影响本局
- sendWinNotice(userId, cache);
- // 已在开局结算入背包，末帧仅揭晓；回填 boxRecordId 供前端选择保留/立即分解
- SpinResponse resp = buildStepResponse(cache, step, nextIdx, true);
- cacheRepository.clearCache(userId);
- return resp;
- }
- cacheRepository.setCache(userId, cache);
- return buildStepResponse(cache, step, nextIdx, false);
- }
-
- /** 结算通知（站内信）：只在"这一局播完"的时刻发——单步局=开局，多步局=末帧。
- * 开局就发会在动画播完前把结果剧透给玩家（饰品开局已入背包，通知是唯一会提前泄露的通道）。
- * 多步局中途退出/断线未播完的局不发通知，饰品仍在背包，战绩按 30 分钟兜底照常展示。 */
- private void sendWinNotice(Long userId, OlympusGameCache cache) {
- if (cache.getRecordId() == null) return;
- try {
- OlympusRecord rec = recordMapper.selectById(cache.getRecordId());
- if (rec == null || rec.getPrizeName() == null) return;
- String priceStr = rec.getSettledWin() == null ? "0" : rec.getSettledWin().stripTrailingZeros().toPlainString();
- messageService.sendNotice(
- userId,
- MessageCategoryEnum.GAME_OLYMPUS.getTitle(),
- "玫瑰女郎挑战结算：您本局获得饰品 " + rec.getPrizeName() + "（价值 ¥" + priceStr + "）",
- MessageCategoryEnum.GAME_OLYMPUS.getCode());
- } catch (Exception e) {
- log.error("olympus 结算通知发送失败 userId={} recordId={}", userId, cache.getRecordId(), e);
- }
- }
-
- // ============================================================
- // 开局即结算（事务中，饰品直接写入背包，中途退出/刷新无损）
- // ============================================================
-
- private void settleAtStart(Long userId, OlympusGameCache cache) {
- BigDecimal totalWin = cache.getTotalWin();
- if (totalWin == null || totalWin.compareTo(BigDecimal.ZERO) <= 0) totalWin = new BigDecimal("0.01");
- BigDecimal win = scale2(totalWin);
-
- Map prize = findPrizeWithFallback(win);
- Long prizeId = asLong(prize != null ? prize.get("id") : null);
- String prizeName = prize != null ? (String) prize.get("name") : null;
- Integer prizeGrade = prize != null && prize.get("grade") instanceof Integer ? (Integer) prize.get("grade") : 1;
- String prizeImageUrl = prize != null ? (String) prize.get("imageUrl") : null;
- String prizeExteriorName = prize != null ? (String) prize.get("exteriorName") : null;
- String prizeLevelImg = prize != null ? (String) prize.get("levelImageUrl") : null;
-
- // 幂等守卫。settle_source：开局写 start，客户端播完末帧才改 finish（战绩列表只展示已结束的局）；
- // 单步局开局即播完，直接写 finish。
- boolean playedOut = cache.getSteps() == null || cache.getSteps().size() <= 1;
- int guard = recordMapper.update(null, new LambdaUpdateWrapper()
- .eq(OlympusRecord::getId, cache.getRecordId())
- .eq(OlympusRecord::getSettled, 0)
- .set(OlympusRecord::getSettled, 1)
- .set(OlympusRecord::getRewardType, "ornament")
- .set(OlympusRecord::getTotalWin, totalWin)
- .set(OlympusRecord::getSettledWin, win)
- .set(OlympusRecord::getPrizeId, prizeId)
- .set(OlympusRecord::getSettleSource, playedOut ? "finish" : "start")
- .set(OlympusRecord::getPrizeName, prizeName)
- .set(OlympusRecord::getPrizeImageUrl, prizeImageUrl));
- if (guard == 0) { cacheRepository.clearCache(userId); return; }
-
- // 写入背包
- Long boxRecordId = null;
- if (boxRecordsMapper != null && prizeId != null) {
- if (prizeLevelImg == null && ornamentsLevelMapper != null) {
- TtOrnamentsLevel lv = ornamentsLevelMapper.selectById(prizeGrade);
- if (lv != null) prizeLevelImg = lv.getLevelImg();
- }
- TtBoxRecords bi = TtBoxRecords.builder()
- .userId(userId.intValue()).holderUserId(userId.intValue())
- .boxId(cache.getBoxId() != null ? cache.getBoxId().intValue() : 0)
- .boxName("OLYMPUS").boxPrice(cache.getCost())
- .ornamentId(prizeId).ornamentsPrice(win)
- .ornamentName(prizeName).imageUrl(prizeImageUrl)
- .marketHashName(prizeExteriorName != null ? prizeName + " (" + prizeExteriorName + ")" : prizeName)
- .ornamentsLevelId(prizeGrade != null ? prizeGrade : 1)
- .ornamentLevelImg(prizeLevelImg)
- .source(TtboxRecordSource.OLYMPUS_BOX.getCode())
- .status(0).isShow(1).createTime(new Date())
- .build();
- boxRecordsMapper.insert(bi);
- boxRecordId = bi.getId();
- cache.setBoxRecordId(bi.getId());
- // 注：结算通知不在这里发——开局就发会在动画播完前把结果剧透给玩家，改由 startNewGame/continueGame 在末帧发
- }
-
- // 注：饰品一律以 ornament 写入背包（开局即结算，断网也不丢）。自动分解由前端开关控制：
- // 末帧前端调 /api/userPackSack/decompose 即按玫瑰女郎奖励(61)入账；调不动也只是留在背包，无资金风险。
-
- // 更新用户统计
- OlympusUser user = userMapper.selectByUserId(userId);
- if (user == null) {
- user = new OlympusUser();
- user.setUserId(userId);
- user.setTotalSpins(1L);
- user.setTotalCost(cache.getCost());
- user.setTotalWin(totalWin);
- user.setTotalFreeSpins(cache.getFreeSpinCount() != null && cache.getFreeSpinCount() > 0 ? 1 : 0);
- user.setMaxWinMul(cache.getTotalMul());
- userMapper.insert(user);
- } else {
- user.setTotalSpins(coalesceL(user.getTotalSpins()) + 1L);
- user.setTotalCost(coalesce(user.getTotalCost()).add(cache.getCost()));
- user.setTotalWin(coalesce(user.getTotalWin()).add(totalWin));
- if (cache.getFreeSpinCount() != null && cache.getFreeSpinCount() > 0)
- user.setTotalFreeSpins(coalesce0(user.getTotalFreeSpins()) + 1);
- if (cache.getTotalMul() != null && cache.getTotalMul().compareTo(coalesce(user.getMaxWinMul())) > 0)
- user.setMaxWinMul(cache.getTotalMul());
- userMapper.updateById(user);
- }
-
- // 注：奖池注水与返奖记入由 startNewGame 事务提交后统一执行（开局即结算，白号隔离）
- }
-
- // ============================================================
- // 断线重连
- // ============================================================
-
- public Map hasActive(Long userId) {
- OlympusGameCache cache = cacheRepository.getCache(userId);
- // 开局即结算模型：无缓存即无进行中动画可恢复（饰品已在背包），直接返回
- if (cache == null) return Map.of("hasActive", false);
- List steps = cache.getSteps();
- int played = Math.min(Math.max(cache.getStepIndex(), 0), steps.size());
- BigDecimal bet = coalesce(cache.getBet());
- // 已播累计直接取最后一步的 spin_win（本局累计），不能逐帧加 win_amount：
- // win_amount 是"本旋内累计"，同一旋的每一波都是同一个累计量的快照，相加会把中间波重复计入。
- BigDecimal playedWin = played > 0
- ? scale2(coalesce(steps.get(played - 1).getSpinWin()).multiply(bet))
- : BigDecimal.ZERO;
- Map result = new HashMap<>();
- result.put("hasActive", true);
- result.put("boxId", cache.getBoxId());
- result.put("boxType", cache.getBoxType());
- result.put("bet", cache.getBet());
- result.put("cost", cache.getCost());
- result.put("stepIndex", cache.getStepIndex());
- result.put("totalSteps", steps.size());
- result.put("freeSpinCount", cache.getFreeSpinCount());
- result.put("spinsRemaining", spinsRemainingAfter(steps, played));
- result.put("totalWin", scale2(playedWin));
- result.put("roundId", cache.getRoundId());
- if (played > 0) result.put("lastStep", buildStepResponse(cache, steps.get(played - 1), played, false));
- return result;
- }
-
- // ============================================================
- // 构建单步响应
- // ============================================================
-
- private SpinResponse buildStepResponse(OlympusGameCache cache, OlympusGameCache.CachedStep cs, int idx, boolean isFinal) {
- BigDecimal bet = coalesce(cache.getBet());
- SpinResponse resp = new SpinResponse();
- resp.setState(isFinal ? "FINISH" : "PLAYING");
- resp.setTumbleNum(cs.getCascadeSeq());
- resp.setSpinNum(cs.getFreeSpinId());
- resp.setGridState(toJson(cs.getGridState()));
- resp.setMultiplierDetail(toJson(cs.getMultiplierDetail()));
- resp.setSymbolLinks(scaleMoneyList(cs.getSymbolLinks(), bet, new String[]{"base_score", "score", "win"}));
- resp.setDropData(toJson(cs.getDropData()));
- resp.setFillData(toJson(cs.getFillData()));
- resp.setScatterTrigger(scaleMoneyMap(cs.getScatterTrigger(), bet, new String[]{"scatterWin", "startAmount"}));
- resp.setWinAmount(scale2(coalesce(cs.getWinAmount()).multiply(bet)));
- resp.setSpinWin(scale2(coalesce(cs.getSpinWin()).multiply(bet)));
- // 炸弹累计倍数（未 ×bet）：跨旋传递的累计器，断线重连只回最后一步，前端靠这一步的值接回累计
- resp.setAccumulator(scale2(coalesce(cs.getAccumulatorAfter())));
- if (cs.getRetriggerInfo() != null && !cs.getRetriggerInfo().isEmpty())
- resp.setRetriggerInfo(scaleMoneyMap(cs.getRetriggerInfo(), bet, new String[]{"scatterWin"}));
- // 爆奖动画：py 已按单旋赢额判档写入 bigwin_level，直接透传
- if (cs.getBigwinLevel() != null && !cs.getBigwinLevel().isEmpty()) resp.setBigWinLevel(cs.getBigwinLevel());
-
- resp.setGlobalStep(idx);
- resp.setGlobalTotalSteps(cache.getSteps().size());
- // 剩余免费旋转：每帧都给（前端直接显示倒计，不用自己加减）；1000x 封顶时下面覆盖成 0
- resp.setSpinsRemaining(spinsRemainingAfter(cache.getSteps(), idx));
-
- if (isFinal) {
- resp.setTotalWin(scale2(cache.getTotalWin()));
- resp.setTotalMul(scale2(cache.getTotalMul()));
- if (coalesce(cache.getTotalMul()).compareTo(MAX_WIN_CAP_MUL) >= 0) {
- resp.setMaxWinReached(true);
- resp.setSpinsRemaining(0);
- }
- // 开局已结算入背包：末帧揭晓饰品 + 回填 boxRecordId 供前端选择保留/立即分解
- try {
- BigDecimal win = scale2(cache.getTotalWin());
- if (win.compareTo(BigDecimal.ZERO) <= 0) win = new BigDecimal("0.01");
- Map prize = findPrizeWithFallback(win);
- if (prize != null && !prize.isEmpty()) resp.setPrizeInfo(prize);
- } catch (Exception ignore) {}
- resp.setBoxRecordId(cache.getBoxRecordId());
- }
- return resp;
- }
-
- // ============================================================
- // 工具
- // ============================================================
-
- private Map findPrizeWithFallback(BigDecimal totalWin) {
- Map prize = prizeRangeMapper.findPrizeByWin(totalWin);
- if (prize != null && !prize.isEmpty()) { prize.put("isFallback", false); return prize; }
- prize = prizeRangeMapper.findFallbackPrize();
- if (prize == null || prize.isEmpty()) prize = prizeRangeMapper.findLowestPrize();
- if (prize == null || prize.isEmpty()) prize = prizeRangeMapper.findHighestPrize();
- if (prize != null) prize.put("isFallback", true);
- return prize;
- }
-
- private static BigDecimal scale2(BigDecimal v) { return v == null ? BigDecimal.ZERO : v.setScale(2, java.math.RoundingMode.HALF_UP); }
- private static BigDecimal coalesce(BigDecimal v) { return v != null ? v : BigDecimal.ZERO; }
- private static int coalesce0(Integer v) { return v != null ? v : 0; }
- private static long coalesceL(Long v) { return v != null ? v : 0L; }
-
- private static Long asLong(Object v) {
- if (v == null) return null;
- if (v instanceof Long) return (Long) v;
- if (v instanceof Number) return ((Number) v).longValue();
- try { return Long.valueOf(v.toString()); } catch (Exception e) { return null; }
- }
-
- private static Object toJson(String s) {
- if (s == null || s.isEmpty()) return null;
- try { return MAPPER.readTree(s); } catch (Exception e) { return s; }
- }
-
- /** 剩余免费旋转 = 已发放 − 已播完的 FS 旋数（played = 算到第几步，含这一步；中间波帧不减，旋末帧才 −1）。
- * 已发放只算玩家**已经看到**的：触发帧的 freeSpins(=15) + 已播步里的 retriggerInfo.extraSpins(=5)，封顶 30
- * （封顶后 3+ 个 S 的旋仍会写 retrigger_info=5 但不再加旋，所以这里必须夹 30）。
- * 例：第 2 旋末帧出 3 个 S → 15+5−2 = 18（那一帧 −1 与 +5 同时结算，净 +4）。*/
- private static int spinsRemainingAfter(List steps, int played) {
- int awarded = 0, completed = 0;
- for (int i = 0; i < played && i < steps.size(); i++) {
- OlympusGameCache.CachedStep s = steps.get(i);
- awarded += jsonInt(s.getScatterTrigger(), "freeSpins") + jsonInt(s.getRetriggerInfo(), "extraSpins");
- if (s.getIsFinal() == 1 && s.getFreeSpinId() > 0) completed++;
- }
- return Math.max(0, Math.min(awarded, MAX_FREE_SPINS) - completed);
- }
-
- /** 取 JSON 对象里的整数字段（缺失 / null / 解析失败一律按 0） */
- private static int jsonInt(String json, String key) {
- if (json == null || json.isEmpty()) return 0;
- try {
- com.fasterxml.jackson.databind.JsonNode node = MAPPER.readTree(json).get(key);
- return node == null ? 0 : node.asInt();
- } catch (Exception e) { return 0; }
- }
-
- /** 解析 JSON 数组，把指定金额字段 ×bet */
- @SuppressWarnings("unchecked")
- private static Object scaleMoneyList(String json, BigDecimal bet, String[] keys) {
- if (json == null || json.isEmpty()) return null;
- try {
- List> list = MAPPER.readValue(json, List.class);
- for (Map m : list) scaleKeys(m, bet, keys);
- return list;
- } catch (Exception e) { return toJson(json); }
- }
-
- @SuppressWarnings("unchecked")
- private static Object scaleMoneyMap(String json, BigDecimal bet, String[] keys) {
- if (json == null || json.isEmpty()) return null;
- try {
- Map m = MAPPER.readValue(json, Map.class);
- scaleKeys(m, bet, keys);
- return m;
- } catch (Exception e) { return toJson(json); }
- }
-
- private static void scaleKeys(Map m, BigDecimal bet, String[] keys) {
- for (String key : keys) {
- Object v = m.get(key);
- if (v instanceof Number) {
- m.put(key, BigDecimal.valueOf(((Number) v).doubleValue())
- .multiply(coalesce(bet)).setScale(2, java.math.RoundingMode.HALF_UP));
- }
- }
- }
-}
diff --git a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusRoundPicker.java b/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusRoundPicker.java
deleted file mode 100644
index 82679f2..0000000
--- a/skins-service/game-olympus-service/src/main/java/com/ruoyi/game/olympus/service/OlympusRoundPicker.java
+++ /dev/null
@@ -1,279 +0,0 @@
-package com.ruoyi.game.olympus.service;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.ruoyi.game.olympus.domain.*;
-import com.ruoyi.game.olympus.enums.OlympusModeType;
-import com.ruoyi.game.olympus.mapper.*;
-import com.ruoyi.game.olympus.model.PickedRound;
-import com.ruoyi.game.olympus.repository.OlympusCycleRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.util.*;
-import java.util.concurrent.ThreadLocalRandom;
-
-/**
- * Olympus 回合选择器（多身份 + 两阶段 + 白号隔离）。
- *
- * 每个身份(audience)读自己的桶分布与轮次账本：
- * - 白号(payoutCap==null)：纯概率原逻辑，不进两阶段、不受水位约束，但消耗自己的 white 库存（isConverge=false）；
- * - 真实身份(payoutCap!=null)：固定阶段(payoutCap 过滤+剩余加权) → 收敛阶段(按 desiredNextMul 在水位内选桶)。
- *
- * 消耗(used+1，仅固定阶段)与账本 recordDraw 由 OlympusGameService 在扣费事务内/提交后执行。
- */
-@Service
-public class OlympusRoundPicker {
-
- @Autowired
- private OlympusBoxOrnamentMapper boxOrnamentMapper;
- @Autowired
- private OlympusRoundMapper roundMapper;
- @Autowired
- private OlympusStepMapper stepMapper;
- @Autowired
- private OlympusDistributionService distributionService;
- @Autowired
- private OlympusBoxMapper boxMapper;
- @Autowired
- private OlympusCycleRepository cycleRepository;
-
- private static final double DEFAULT_CONVERGE_RATIO = 0.15;
-
- public PickedRound pick(Long boxId, String audience, Boolean needFreeSpins, BigDecimal bet, BigDecimal payoutCap) {
- List dist = boxOrnamentMapper.selectByBoxIdAndAudience(boxId, audience);
- if (dist.isEmpty()) throw new RuntimeException("Box " + boxId + " audience=" + audience + " 暂无饰品分布数据");
-
- // 白号 / 无水位约束：纯概率原逻辑（消耗自己的库存，不受水位）
- if (payoutCap == null) {
- int totalRemaining = dist.stream().mapToInt(bo -> safe(bo.getRemaining())).sum();
- if (totalRemaining <= 0) {
- distributionService.refillFromConfig(boxId, audience);
- dist = boxOrnamentMapper.selectByBoxIdAndAudience(boxId, audience);
- }
- Integer ornId = weightedPickByRemaining(dist);
- if (ornId == null) ornId = dist.get(0).getOrnamentId();
- OlympusRound r = resolveRound(boxId, ornId, needFreeSpins, bet, null);
- return new PickedRound(r, stepMapper.selectByRoundId(r.getRoundId()), false);
- }
-
- // 真实玩家：两阶段
- OlympusBox box = boxMapper.selectById(boxId);
- double cm = 1.0, rtp = 0.8, convergeRatio = DEFAULT_CONVERGE_RATIO;
- if (box != null) {
- try { cm = OlympusModeType.fromBoxType(box.getBoxType()).getCostMultiplier(); } catch (Exception ignore) {}
- if (box.getRtp() != null) rtp = box.getRtp().doubleValue();
- if (box.getRtpConvergeRatio() != null) convergeRatio = box.getRtpConvergeRatio().doubleValue();
- }
- if (convergeRatio < 0) convergeRatio = 0;
- if (convergeRatio > 0.9) convergeRatio = 0.9;
- // 一轮总回合 N 按该身份固定池分布反推（身份级独立，各身份可不同），不使用箱子级 total_ornaments；
- // 无分布时回退箱子级值兜底
- int fixedSum = dist.stream().mapToInt(bo -> safe(bo.getCount())).sum();
- int N;
- if (fixedSum > 0) {
- N = (int) Math.round(fixedSum / (1.0 - convergeRatio));
- } else {
- N = (box != null && box.getTotalOrnaments() != null && box.getTotalOrnaments() > 0)
- ? box.getTotalOrnaments() : fixedSum;
- }
- int fixedRounds = (int) Math.round(N * (1 - convergeRatio));
- long drawn = cycleRepository.drawn(boxId, audience);
- int totalRemaining = dist.stream().mapToInt(bo -> safe(bo.getRemaining())).sum();
-
- // 固定阶段
- if (drawn < fixedRounds && totalRemaining > 0) {
- Integer ornId = pickFixedOrnId(dist, bet, payoutCap);
- if (ornId == null) ornId = dist.get(0).getOrnamentId();
- OlympusRound r = resolveRound(boxId, ornId, needFreeSpins, bet, payoutCap);
- return new PickedRound(r, stepMapper.selectByRoundId(r.getRoundId()), false);
- }
-
- // 收敛阶段
- double targetMul = rtp * cm;
- long remainingDraws = Math.max(1, N - drawn);
- double remainingBudget = N * targetMul - cycleRepository.mulSum(boxId, audience);
- double desiredNextMul = Math.max(0, remainingBudget / remainingDraws);
- OlympusRound r = pickConverge(boxId, dist, needFreeSpins, bet, payoutCap, desiredNextMul);
- return new PickedRound(r, stepMapper.selectByRoundId(r.getRoundId()), true);
- }
-
- private Integer pickFixedOrnId(List dist, BigDecimal bet, BigDecimal payoutCap) {
- List eligible = new ArrayList<>();
- for (OlympusBoxOrnament bo : dist) {
- if (Math.max(0, safe(bo.getRemaining())) <= 0) continue;
- if (expectPayout(bo, bet).compareTo(payoutCap) <= 0) eligible.add(bo);
- }
- return !eligible.isEmpty() ? weightedPickByRemaining(eligible) : minPayoutOrnId(dist, bet);
- }
-
- private OlympusRound resolveRound(Long boxId, Integer ornId, Boolean needFreeSpins, BigDecimal bet, BigDecimal payoutCap) {
- OlympusRound round = pickRoundWithCap(boxId, ornId, needFreeSpins, bet, payoutCap);
- if (round == null) round = copyFromSameBucket(boxId, ornId, needFreeSpins);
- if (round == null && needFreeSpins != null) {
- round = roundMapper.pickByOrnament(boxId, ornId, null);
- if (round == null) round = copyFromSameBucket(boxId, ornId, null);
- }
- if (round == null) throw new RuntimeException("暂无可用回合数据");
- return round;
- }
-
- /** 桶内随机取一条，真实玩家还要 actual_mul×bet ≤ payoutCap（最多重抽 5 次，抽不到就退回原条） */
- private OlympusRound pickRoundWithCap(Long boxId, Integer ornId, Boolean needFreeSpins, BigDecimal bet, BigDecimal payoutCap) {
- OlympusRound round = roundMapper.pickByOrnament(boxId, ornId, needFreeSpins);
- if (round == null || payoutCap == null) return round;
- BigDecimal b = bet != null ? bet : BigDecimal.ZERO;
- if (withinCap(round, b, payoutCap)) return round;
- for (int i = 0; i < 5; i++) {
- OlympusRound r = roundMapper.pickByOrnament(boxId, ornId, needFreeSpins);
- if (r != null && withinCap(r, b, payoutCap)) return r;
- }
- return round;
- }
-
- private OlympusRound pickConverge(Long boxId, List dist, Boolean needFreeSpins,
- BigDecimal bet, BigDecimal payoutCap, double desiredNextMul) {
- BigDecimal b = (bet != null && bet.signum() > 0) ? bet : BigDecimal.ONE;
- List allowed = new ArrayList<>();
- for (OlympusBoxOrnament bo : dist) {
- if (expectPayout(bo, b).compareTo(payoutCap) <= 0) allowed.add(bo);
- }
- OlympusBoxOrnament chosen = allowed.isEmpty() ? minExpectMul(dist) : closestExpectMul(allowed, desiredNextMul);
- Integer ornId = chosen.getOrnamentId();
-
- double capMul = payoutCap.doubleValue() / b.doubleValue();
- double effectiveDesired = Math.min(desiredNextMul, capMul);
- BigDecimal desiredBd = BigDecimal.valueOf(effectiveDesired).setScale(4, RoundingMode.HALF_UP);
- BigDecimal capBd = BigDecimal.valueOf(capMul).setScale(4, RoundingMode.HALF_UP);
-
- OlympusRound round = roundMapper.pickClosestMul(boxId, ornId, needFreeSpins, desiredBd, capBd);
- if (round == null && needFreeSpins != null) round = roundMapper.pickClosestMul(boxId, ornId, null, desiredBd, capBd);
- if (round == null) round = copyFromSameBucket(boxId, ornId, needFreeSpins);
- if (round == null) round = copyFromSameBucket(boxId, ornId, null);
- if (round == null) throw new RuntimeException("收敛阶段暂无可用回合数据");
- return round;
- }
-
- private OlympusBoxOrnament closestExpectMul(List list, double desired) {
- List sorted = new ArrayList<>(list);
- sorted.sort(Comparator.comparingDouble(bo -> {
- double mul = bo.getExpectMul() != null ? bo.getExpectMul().doubleValue() : 0;
- return Math.abs(mul - desired);
- }));
- int pickCount = Math.min(3, sorted.size());
- return sorted.get(ThreadLocalRandom.current().nextInt(pickCount));
- }
-
- private OlympusBoxOrnament minExpectMul(List list) {
- OlympusBoxOrnament best = list.get(0);
- double bestMul = Double.MAX_VALUE;
- for (OlympusBoxOrnament bo : list) {
- double mul = bo.getExpectMul() != null ? bo.getExpectMul().doubleValue() : 0;
- if (mul < bestMul) { bestMul = mul; best = bo; }
- }
- return best;
- }
-
- /** 同桶复制已有回合（新ID，动画数据原样拷贝），保证一定有回合可用。 */
- private OlympusRound copyFromSameBucket(Long boxId, Integer ornamentId, Boolean needFreeSpins) {
- OlympusRound template = null;
- for (int i = 0; i < 10; i++) {
- template = roundMapper.pickByOrnament(boxId, ornamentId, needFreeSpins);
- if (template != null && nz(template.getActualMul()).signum() > 0) break;
- }
- if (template == null) {
- for (int i = 0; i < 10; i++) {
- template = roundMapper.pickAnyByBox(boxId, needFreeSpins);
- if (template != null && nz(template.getActualMul()).signum() > 0) break;
- }
- if (template == null) return null;
- }
- List templateSteps = stepMapper.selectByRoundId(template.getRoundId());
- Long newRoundId = nextRoundId();
- long newStepId = nextStepId();
- for (OlympusStep ts : templateSteps) {
- OlympusStep ns = new OlympusStep();
- ns.setId(newStepId++);
- ns.setRoundId(newRoundId);
- ns.setFreeSpinId(ts.getFreeSpinId());
- ns.setCascadeSeq(ts.getCascadeSeq());
- ns.setGridState(ts.getGridState());
- ns.setMultiplierDetail(ts.getMultiplierDetail());
- ns.setSymbolLinks(ts.getSymbolLinks());
- ns.setAccumulatedSymbols(ts.getAccumulatedSymbols());
- ns.setSpinWinners(ts.getSpinWinners());
- ns.setRemovedPositions(ts.getRemovedPositions());
- ns.setDropData(ts.getDropData());
- ns.setFillData(ts.getFillData());
- ns.setScatterTrigger(ts.getScatterTrigger());
- ns.setRetriggerInfo(ts.getRetriggerInfo());
- ns.setBaseScore(ts.getBaseScore());
- ns.setWinAmount(ts.getWinAmount());
- ns.setAccumulatorBefore(ts.getAccumulatorBefore());
- ns.setAccumulatorAfter(ts.getAccumulatorAfter());
- ns.setSpinWin(ts.getSpinWin());
- ns.setWinCapped(ts.getWinCapped());
- ns.setBigwinLevel(ts.getBigwinLevel());
- ns.setIsFinal(ts.getIsFinal());
- stepMapper.insert(ns);
- }
- OlympusRound copy = new OlympusRound();
- copy.setRoundId(newRoundId);
- copy.setBoxId(boxId);
- copy.setOrnamentId(ornamentId);
- copy.setActualMul(template.getActualMul());
- copy.setFreeSpinCount(template.getFreeSpinCount());
- copy.setTotalCascades(template.getTotalCascades());
- copy.setCreateTime(new Date());
- roundMapper.insert(copy);
- return copy;
- }
-
- private Long nextRoundId() {
- List max = roundMapper.selectList(
- new LambdaQueryWrapper().orderByDesc(OlympusRound::getRoundId).last("limit 1"));
- return max.isEmpty() ? 1L : max.get(0).getRoundId() + 1;
- }
-
- private Long nextStepId() {
- List max = stepMapper.selectList(
- new LambdaQueryWrapper().orderByDesc(OlympusStep::getId).last("limit 1"));
- return max.isEmpty() ? 1L : max.get(0).getId() + 1;
- }
-
- private BigDecimal expectPayout(OlympusBoxOrnament bo, BigDecimal bet) {
- BigDecimal mul = bo.getExpectMul() != null ? bo.getExpectMul() : BigDecimal.ZERO;
- return mul.multiply(bet != null ? bet : BigDecimal.ZERO);
- }
-
- private Integer weightedPickByRemaining(List list) {
- if (list.isEmpty()) return null;
- int totalWeight = list.stream().mapToInt(bo -> Math.max(0, safe(bo.getRemaining()))).sum();
- if (totalWeight <= 0) return list.get(0).getOrnamentId();
- int r = ThreadLocalRandom.current().nextInt(totalWeight);
- int acc = 0;
- for (OlympusBoxOrnament bo : list) {
- acc += Math.max(0, safe(bo.getRemaining()));
- if (r < acc) return bo.getOrnamentId();
- }
- return list.get(0).getOrnamentId();
- }
-
- private Integer minPayoutOrnId(List dist, BigDecimal bet) {
- OlympusBoxOrnament best = null;
- for (OlympusBoxOrnament bo : dist) {
- if (Math.max(0, safe(bo.getRemaining())) <= 0) continue;
- if (best == null || expectPayout(bo, bet).compareTo(expectPayout(best, bet)) < 0) best = bo;
- }
- return best != null ? best.getOrnamentId() : dist.get(0).getOrnamentId();
- }
-
- private boolean withinCap(OlympusRound round, BigDecimal bet, BigDecimal payoutCap) {
- BigDecimal mul = nz(round.getActualMul());
- return mul.signum() > 0 && mul.multiply(bet).compareTo(payoutCap) <= 0;
- }
-
- private static BigDecimal nz(BigDecimal v) { return v != null ? v : BigDecimal.ZERO; }
- private static int safe(Integer v) { return v != null ? v : 0; }
-}
diff --git a/skins-service/game-olympus-service/src/main/resources/mapper/olympus/OlympusBoxOrnamentMapper.xml b/skins-service/game-olympus-service/src/main/resources/mapper/olympus/OlympusBoxOrnamentMapper.xml
deleted file mode 100644
index 83dee2a..0000000
--- a/skins-service/game-olympus-service/src/main/resources/mapper/olympus/OlympusBoxOrnamentMapper.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-
-
-
-
-
-
-
-
- INSERT INTO game_olympus_box_ornament (box_id, ornament_id, audience, count, used) VALUES
-
- (#{it.boxId}, #{it.ornamentId}, #{it.audience}, #{it.count}, #{it.used})
-
-
-
-
- DELETE FROM game_olympus_box_ornament WHERE box_id = #{boxId} AND audience = #{audience}
-
-
-
- UPDATE game_olympus_box_ornament SET used = used + 1
- WHERE box_id = #{boxId} AND ornament_id = #{ornamentId} AND audience = #{audience}
-
-
-
- UPDATE game_olympus_box_ornament SET used = 0
- WHERE box_id = #{boxId} AND audience = #{audience}
-
-
-
diff --git a/skins-service/game-olympus-service/src/main/resources/mapper/olympus/OlympusRoundMapper.xml b/skins-service/game-olympus-service/src/main/resources/mapper/olympus/OlympusRoundMapper.xml
deleted file mode 100644
index 2300ef5..0000000
--- a/skins-service/game-olympus-service/src/main/resources/mapper/olympus/OlympusRoundMapper.xml
+++ /dev/null
@@ -1,42 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-