264 lines
13 KiB
Python
264 lines
13 KiB
Python
"""回合生成器规则校验（unittest）。不依赖第三方库，可直接 `python tests/test_simulator.py` 运行。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import random
|
||
import sys
|
||
import unittest
|
||
from collections import Counter
|
||
from pathlib import Path
|
||
|
||
# 支持直接 `python tests/test_simulator.py` 运行（无需先安装为包）
|
||
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
||
|
||
from olympus.config import BIGWIN_LEVELS, BIGWIN_TIERS, BOMB_SHORT, SCATTER_SHORT
|
||
import olympus_simulator as sim
|
||
from olympus_simulator import generate_round
|
||
|
||
|
||
def _cells(step):
|
||
return [c for row in step['grid_state'] for c in row]
|
||
|
||
|
||
class TestBuyFsTriggerSpin(unittest.TestCase):
|
||
"""buy_fs 触发盘：首盘固定 4 个 SCATTER，且整盘不出炸弹（炸弹只在免费旋转内生效）。"""
|
||
|
||
def test_trigger_pages(self) -> None:
|
||
for _ in range(100):
|
||
_, steps, _ = generate_round({'box_id': 0, 'box_type': 'buy_fs'})
|
||
trigger = [s for s in steps if s['free_spin_id'] == 0]
|
||
self.assertTrue(trigger)
|
||
for s in trigger:
|
||
cells = _cells(s)
|
||
self.assertEqual(cells.count(SCATTER_SHORT), 4)
|
||
self.assertEqual(cells.count(BOMB_SHORT), 0)
|
||
|
||
|
||
class TestBuyFsFreeSpinHits(unittest.TestCase):
|
||
"""buy_fs 免费旋转"每旋保底消除"：自然阶段命中率应远高于旧实现的 ~13%（旧版 45% 强制空转）。"""
|
||
|
||
def test_natural_phase_hit_rate(self) -> None:
|
||
random.seed(12345)
|
||
box = {'box_id': 0, 'box_type': 'buy_fs'}
|
||
total = hit = 0
|
||
for _ in range(60):
|
||
_, steps, _ = generate_round(box, None)
|
||
spins = Counter(s['free_spin_id'] for s in steps if s['free_spin_id'] > 0)
|
||
total += len(spins)
|
||
hit += sum(1 for v in spins.values() if v > 1)
|
||
self.assertGreater(hit / total, 0.45)
|
||
|
||
|
||
class TestBombOnlyInFreeSpins(unittest.TestCase):
|
||
"""炸弹只存在于免费旋转内：
|
||
· normal/ante 的基础旋（含进 FS 的触发盘、含补桶植入）一律不出炸弹；
|
||
· 三个模式一旦进 FS 规则一致（炸弹 + 累计器），normal/ante 靠它演 100x/150x/200x 桶。"""
|
||
|
||
def test_normal_ante_base_spin_never_emit_bomb(self) -> None:
|
||
random.seed(20260822)
|
||
for mode in ('normal', 'ante'):
|
||
box = {'box_id': 0, 'box_type': mode}
|
||
bombs = 0
|
||
for bias in (None, 'zero', 0.5, 10.0, 150.0):
|
||
for _ in range(400):
|
||
_, steps, _ = generate_round(box, bias)
|
||
bombs += sum(_cells(s).count(BOMB_SHORT)
|
||
for s in steps if s['free_spin_id'] == 0)
|
||
self.assertEqual(bombs, 0, '%s 基础旋不该出炸弹' % mode)
|
||
|
||
def test_normal_ante_free_spins_have_bomb(self) -> None:
|
||
random.seed(11)
|
||
for mode in ('normal', 'ante'):
|
||
box = {'box_id': 0, 'box_type': mode}
|
||
grids = bombs = 0
|
||
for _ in range(400):
|
||
# 目标 150x ≥ FS_ONLY_TARGET_MUL → 该模式的 150x 桶只能靠自然触发 FS 的回合来装
|
||
_, steps, _ = generate_round(box, 150.0)
|
||
for s in steps:
|
||
if s['free_spin_id'] > 0:
|
||
grids += 1
|
||
bombs += _cells(s).count(BOMB_SHORT)
|
||
self.assertGreater(grids, 0, '%s 高倍桶应该是 FS 回合' % mode)
|
||
self.assertGreater(bombs / (30.0 * grids), 0.02,
|
||
'%s 的 FS 盘面应该有炸弹' % mode)
|
||
|
||
def test_high_target_round_enters_free_spins(self) -> None:
|
||
"""目标高到基础旋赔不出来（≥80x）时，生成器必须改用自然触发 FS 的回合。"""
|
||
for mode in ('normal', 'ante'):
|
||
_, steps, _ = generate_round({'box_id': 0, 'box_type': mode}, 150.0)
|
||
self.assertTrue(any(s['free_spin_id'] > 0 for s in steps))
|
||
trigger = [s for s in steps if s['free_spin_id'] == 0][-1]
|
||
self.assertGreaterEqual(_cells(trigger).count(SCATTER_SHORT), 4)
|
||
self.assertEqual(_cells(trigger).count(BOMB_SHORT), 0)
|
||
|
||
def test_buy_fs_still_has_bomb_in_free_spins(self) -> None:
|
||
random.seed(7)
|
||
box = {'box_id': 0, 'box_type': 'buy_fs'}
|
||
bombs = 0
|
||
for _ in range(200):
|
||
_, steps, _ = generate_round(box, None)
|
||
bombs += sum(_cells(s).count(BOMB_SHORT) for s in steps if s['free_spin_id'] > 0)
|
||
self.assertGreater(bombs, 0)
|
||
|
||
|
||
class TestBigWinLevels(unittest.TestCase):
|
||
"""爆奖动画只有小/中/大 3 档，而且只在免费旋转里判档：
|
||
· 基础旋（含触发盘，`free_spin_id=0`）恒为 null —— 这两个模式的普通旋转不播大奖动画；
|
||
· FS 旋的档位 = 该旋末帧 winAmount 与新阈值（两种情况两套）比对的结果。"""
|
||
|
||
def test_tiers_are_three_and_two_cases(self) -> None:
|
||
self.assertEqual(BIGWIN_LEVELS, ('small', 'middle', 'big'))
|
||
self.assertEqual(BIGWIN_TIERS['normal'], BIGWIN_TIERS['ante']) # 自然 FS 共用一套
|
||
self.assertNotEqual(BIGWIN_TIERS['normal'], BIGWIN_TIERS['buy_fs'])
|
||
for tiers in BIGWIN_TIERS.values():
|
||
self.assertEqual(len(tiers), len(BIGWIN_LEVELS))
|
||
|
||
def test_only_free_spin_final_frames_get_level(self) -> None:
|
||
random.seed(4242)
|
||
cases = (('normal', None), ('ante', None), ('buy_fs', None),
|
||
('normal', 150.0), ('ante', 200.0))
|
||
for mode, bias in cases:
|
||
box = {'box_id': 0, 'box_type': mode}
|
||
for _ in range(120):
|
||
_, steps, _ = generate_round(box, bias)
|
||
for s in steps:
|
||
if s['free_spin_id'] == 0 or not s['is_final']:
|
||
self.assertIsNone(s['bigwin_level'],
|
||
'%s 基础旋/非末帧不该有爆奖档' % mode)
|
||
continue
|
||
want = None
|
||
for name, threshold in zip(BIGWIN_LEVELS, BIGWIN_TIERS[mode]):
|
||
if float(s['win_amount']) >= threshold:
|
||
want = name
|
||
self.assertEqual(s['bigwin_level'], want)
|
||
|
||
|
||
class TestFreeSpinFloorSpread(unittest.TestCase):
|
||
"""保底消除"随机间隔"：既不能出现长空尾，也不能变成固定节奏。
|
||
|
||
口径：dry = 该旋所有 cascade 步 `base_score` 全 0（scatter 赔付不算消除，S 不参与消除）。
|
||
两版历史（都别退回去）：
|
||
· 最初按"剩余预算÷剩余旋数"算概率、扣预算扣的是被累计倍数放大后的赢额 → 买 FS 87.9% 的局
|
||
≥4 旋连空、51.7% 的局尾巴一直空转、单局最长 29 旋；
|
||
· 修成"等距铺"后虽然没长空尾，但 87% 的局"最长连空正好 4 旋"，玩家几局就看穿"到第 4 旋肯定消"。"""
|
||
|
||
@staticmethod
|
||
def _max_dry(steps) -> int:
|
||
per = {}
|
||
for s in steps:
|
||
if s['free_spin_id'] > 0:
|
||
per[s['free_spin_id']] = per.get(s['free_spin_id'], 0.0) + float(s['base_score'])
|
||
run = mx = 0
|
||
for k in sorted(per):
|
||
run = 0 if per[k] > 0 else run + 1
|
||
mx = max(mx, run)
|
||
return mx
|
||
|
||
def test_dry_run_stays_short(self) -> None:
|
||
random.seed(20260916)
|
||
for bias in (25.0, None):
|
||
runs = [self._max_dry(generate_round({'box_id': 0, 'box_type': 'buy_fs'}, bias)[1])
|
||
for _ in range(80)]
|
||
avg, worst = sum(runs) / len(runs), max(runs)
|
||
self.assertLess(avg, 7, 'bias=%s 平均最长连空 %.1f 太长（旧实现 9.6）' % (bias, avg))
|
||
self.assertLessEqual(worst, 9, 'bias=%s 出现 %d 旋死尾巴（旧实现最长 29）' % (bias, worst))
|
||
|
||
def test_gap_is_not_a_fixed_cadence(self) -> None:
|
||
"""最长连空的取值必须散开：等距版 87% 的局都卡在同一个值。"""
|
||
random.seed(4242)
|
||
runs = [self._max_dry(generate_round({'box_id': 0, 'box_type': 'buy_fs'}, 25.0)[1])
|
||
for _ in range(120)]
|
||
top, cnt = Counter(runs).most_common(1)[0]
|
||
self.assertGreaterEqual(len(set(runs)), 3, '最长连空只有 %s，节奏太固定' % sorted(set(runs)))
|
||
self.assertLess(cnt / len(runs), 0.7, '最长连空过于集中：%.0f%% 都是 %d 旋' % (100 * cnt / len(runs), top))
|
||
|
||
|
||
class TestTumbleGeometry(unittest.TestCase):
|
||
"""每一步都要能按"消掉上一步的连线 → 重力下落 → 补位"复刻出 `grid_state`：
|
||
前端据此播动画，任何一格对不上/漏掉都会表现成画错符号或空白格子。"""
|
||
|
||
def _check_round(self, steps) -> None:
|
||
rows, cols = 5, 6
|
||
for i in range(1, len(steps)):
|
||
prev, cur = steps[i - 1], steps[i]
|
||
drops = json.loads(cur['drop_data'] or '[]')
|
||
fills = json.loads(cur['fill_data'] or '[]')
|
||
if prev['free_spin_id'] != cur['free_spin_id']:
|
||
# 新的一旋：整盘重发，不该带下落/补位
|
||
self.assertEqual(drops, [])
|
||
self.assertEqual(fills, [])
|
||
continue
|
||
links = json.loads(prev['symbol_links'] or '[]')
|
||
removed = {p - 1 for l in links if l.get('tumble') == prev['cascade_seq']
|
||
for p in l['loc']}
|
||
old = prev['grid_state']
|
||
board = [['' if (r * cols + c) in removed else old[r][c] for c in range(cols)]
|
||
for r in range(rows)]
|
||
nb = [[''] * cols for _ in range(rows)]
|
||
exp_drops = []
|
||
for c in range(cols):
|
||
surv = [(r, board[r][c]) for r in range(rows - 1, -1, -1) if board[r][c] != '']
|
||
for k, (r, sym) in enumerate(surv):
|
||
nr = rows - 1 - k
|
||
nb[nr][c] = sym
|
||
if nr != r:
|
||
exp_drops.append({'from': r * cols + c + 1, 'to': nr * cols + c + 1,
|
||
'symbol': sym})
|
||
key = lambda d: (d['from'], d['to'])
|
||
self.assertEqual(sorted(exp_drops, key=key), sorted(drops, key=key))
|
||
# 下落目标的 symbol 必须是"这一波结束后"的符号（= grid_state 同位置）
|
||
for d in drops:
|
||
p = d['to'] - 1
|
||
self.assertEqual(d['symbol'], cur['grid_state'][p // cols][p % cols])
|
||
# 补位必须正好盖住所有空位，且符号与最终盘面一致
|
||
empty = sorted(r * cols + c for c in range(cols) for r in range(rows)
|
||
if nb[r][c] == '')
|
||
self.assertEqual(sorted(f['pos'] - 1 for f in fills), empty)
|
||
for f in fills:
|
||
p = f['pos'] - 1
|
||
self.assertEqual(f['symbol'], cur['grid_state'][p // cols][p % cols])
|
||
nb[p // cols][p % cols] = f['symbol']
|
||
self.assertEqual(nb, cur['grid_state'], '复刻盘面 ≠ grid_state')
|
||
|
||
def test_all_modes(self) -> None:
|
||
random.seed(31337)
|
||
for mode, biases in (('normal', (None, 'zero', 20.0, 150.0)),
|
||
('ante', (None, 100.0, 200.0)),
|
||
('buy_fs', (None, 25.0, 500.0))):
|
||
for bias in biases:
|
||
for _ in range(60):
|
||
_, steps, _ = generate_round({'box_id': 0, 'box_type': mode}, bias)
|
||
self._check_round(steps)
|
||
|
||
|
||
class TestFreeSpinCap(unittest.TestCase):
|
||
"""30 旋上限（15 + 5×3）：到上限之后不得再落 3+ 个 S。
|
||
|
||
旧实现只在"加旋"那行有闸门，写 retrigger_info 的那行没有 —— 到 30 旋后照样摇出 3+ 个 S、
|
||
照样写 extraSpins=5，玩家白看 "+5" 提示（全库 650 个这种帧）。这里用"每旋必落 5 个 S"的
|
||
极端分布把上限逼出来：应恰好 30 旋、恰好 3 次重触发，上限之后的旋 S 数 ≤2。
|
||
"""
|
||
|
||
def test_no_retrigger_beyond_cap(self) -> None:
|
||
random.seed(20260919)
|
||
original = sim.FREESPIN_SCATTER
|
||
sim.FREESPIN_SCATTER = {'default': {5: 1.0}, 'buy_fs': {5: 1.0}}
|
||
try:
|
||
for mode in ('normal', 'ante', 'buy_fs'):
|
||
steps, _ = sim._free_spin_session(mode)
|
||
spins = {s['free_spin_id'] for s in steps}
|
||
retrigger = [s for s in steps if s.get('retrigger_info')]
|
||
self.assertEqual(len(spins), 30, f'{mode}: 旋数应为 30，实际 {len(spins)}')
|
||
self.assertEqual(len(retrigger), 3, f'{mode}: 重触发应为 3 次，实际 {len(retrigger)}')
|
||
for s in steps:
|
||
if s['is_final'] and s['free_spin_id'] > 3:
|
||
self.assertLessEqual(_cells(s).count(SCATTER_SHORT), 2,
|
||
f'{mode}: 上限之后（第 {s["free_spin_id"]} 旋）又落了 3+ 个 S')
|
||
finally:
|
||
sim.FREESPIN_SCATTER = original
|
||
|
||
|
||
if __name__ == '__main__':
|
||
unittest.main()
|