356 lines
13 KiB
TypeScript
356 lines
13 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
||
import { createRun, dispatch, target } from '../src/core/run';
|
||
import { evaluate } from '../src/core/poker';
|
||
import { scoreHand } from '../src/core/scoring';
|
||
import { validateRun } from '../src/platform/storage';
|
||
import { JOKERS } from '../src/content/catalog';
|
||
import type { Card, Run, Command } from '../src/core/types';
|
||
const cards = (ranks: number[], suits: number[] = []): Card[] =>
|
||
ranks.map((rank, i) => ({ id: i + 1, rank, suit: (suits[i] ?? i % 4) as Card['suit'] }));
|
||
function fixture(cs: Card[], jokers: string[] = []) {
|
||
const r = createRun('TEST');
|
||
r.phase = 'play';
|
||
r.cards = cs;
|
||
r.hand = cs.map((c) => c.id);
|
||
r.draw = [];
|
||
r.jokers = jokers.map((id, i) => ({ id, uid: 100 + i, value: 0 }));
|
||
return r;
|
||
}
|
||
function act(r: Run, c: Command) {
|
||
const x = dispatch(r, c);
|
||
expect(x.error).toBeUndefined();
|
||
return x.state;
|
||
}
|
||
describe('牌型分类与计分牌', () => {
|
||
const cases: [number[], number[], number, number][] = [
|
||
[[14, 9, 7, 4, 2], [], 0, 1],
|
||
[[13, 13, 7], [], 1, 2],
|
||
[[13, 13, 7, 7, 2], [], 2, 4],
|
||
[[9, 9, 9, 2, 3], [], 3, 3],
|
||
[[2, 3, 4, 5, 6], [], 4, 5],
|
||
[[2, 5, 7, 9, 13], [0, 0, 0, 0, 0], 5, 5],
|
||
[[8, 8, 8, 5, 5], [], 6, 5],
|
||
[[8, 8, 8, 8, 2], [], 7, 4],
|
||
[[2, 3, 4, 5, 6], [0, 0, 0, 0, 0], 8, 5],
|
||
[[8, 8, 8, 8, 8], [], 9, 5],
|
||
[[8, 8, 8, 5, 5], [1, 1, 1, 1, 1], 10, 5],
|
||
[[8, 8, 8, 8, 8], [1, 1, 1, 1, 1], 11, 5],
|
||
];
|
||
it.each(cases)('%j → 牌型 %s', (rs, ss, hand, count) => {
|
||
const e = evaluate(cards(rs, ss));
|
||
expect(e.hand).toBe(hand);
|
||
expect(e.scoring).toHaveLength(count);
|
||
});
|
||
it('A 可高可低，但不能绕接', () => {
|
||
expect(evaluate(cards([14, 2, 3, 4, 5])).hand).toBe(4);
|
||
expect(evaluate(cards([10, 11, 12, 13, 14])).hand).toBe(4);
|
||
expect(evaluate(cards([12, 13, 14, 2, 3])).hand).toBe(0);
|
||
});
|
||
it('牌型包含关系不依赖最终牌型名称', () => {
|
||
expect(evaluate(cards([8, 8, 8, 5, 5]))).toMatchObject({ hand: 6, pair: true, triple: true });
|
||
});
|
||
it('计分牌保留用户顺序', () => {
|
||
const cs = cards([3, 13, 3, 13, 5]);
|
||
expect(evaluate(cs).scoring.map((c) => c.id)).toEqual([1, 2, 3, 4]);
|
||
});
|
||
});
|
||
describe('分阶段计分金样', () => {
|
||
it('K K 7：只有对子计分，30×2=60', () => {
|
||
const cs = cards([13, 13, 7]);
|
||
expect(scoreHand(fixture(cs), cs).total).toBe(60);
|
||
});
|
||
it('加倍率 / 乘倍率顺序分别为 360 / 240', () => {
|
||
const cs = cards([13, 13, 7]);
|
||
expect(scoreHand(fixture(cs, ['smile', 'double']), cs).total).toBe(360);
|
||
expect(scoreHand(fixture(cs, ['double', 'smile']), cs).total).toBe(240);
|
||
});
|
||
it('红封和回声相加，不递归：高牌 A 触发三次，38 分', () => {
|
||
const cs = cards([14]);
|
||
cs[0].seal = true;
|
||
expect(scoreHand(fixture(cs, ['echo']), cs).total).toBe(38);
|
||
});
|
||
it('红封完整重触发逐张小丑', () => {
|
||
const cs = cards([14], [0]);
|
||
cs[0].seal = true;
|
||
expect(scoreHand(fixture(cs, ['hearts']), cs).total).toBe(27 * 9);
|
||
});
|
||
it('留手钢铁先于月后：16 × (1×1.5+13)', () => {
|
||
const cs = cards([14, 12]);
|
||
cs[1].enh = 'steel';
|
||
expect(scoreHand(fixture(cs, ['moon']), [cs[0]]).total).toBe(232);
|
||
});
|
||
it('失效牌能成对子但不给点数与逐张加成', () => {
|
||
const cs = cards([13, 13], [0, 0]),
|
||
r = fixture(cs, ['hearts']);
|
||
r.blind = 2;
|
||
r.bosses[0] = 0;
|
||
expect(scoreHand(r, cs).total).toBe(20);
|
||
});
|
||
it('成长在当前出牌即生效', () => {
|
||
const cs = cards([14]),
|
||
r = fixture(cs, ['growth']);
|
||
expect(scoreHand(r, cs).total).toBe(48);
|
||
expect(r.jokers[0].value).toBe(2);
|
||
});
|
||
it('牌型等级修改基础值', () => {
|
||
const cs = cards([13, 13]),
|
||
r = fixture(cs);
|
||
r.levels[1] = 2;
|
||
expect(scoreHand(r, cs).total).toBe(135);
|
||
});
|
||
it('钝刃基础值向上取整', () => {
|
||
const cs = cards([14]),
|
||
r = fixture(cs);
|
||
r.blind = 2;
|
||
r.bosses[0] = 5;
|
||
expect(scoreHand(r, cs).total).toBe(14);
|
||
});
|
||
it('非计分玻璃牌不会触发或破碎', () => {
|
||
const cs = cards([13, 13, 7]),
|
||
r = fixture(cs);
|
||
cs[2].enh = 'glass';
|
||
const rng = r.rng.effect;
|
||
expect(scoreHand(r, cs).total).toBe(60);
|
||
expect(r.cards).toHaveLength(3);
|
||
expect(r.rng.effect).toBe(rng);
|
||
});
|
||
it('最后一次出牌 ×3 以扣除次数前判断', () => {
|
||
const cs = cards([14]),
|
||
r = fixture(cs, ['last']);
|
||
r.hands = 1;
|
||
expect(scoreHand(r, cs).total).toBe(48);
|
||
});
|
||
it('逐张经济先于银行家独立触发', () => {
|
||
const cs = cards([14], [2]),
|
||
r = fixture(cs, ['diamonds', 'bank']);
|
||
r.money = 4;
|
||
expect(scoreHand(r, cs).total).toBe(80);
|
||
expect(r.money).toBe(5);
|
||
});
|
||
it.each(JOKERS.map((j) => [j.id]))('所有小丑 %s 的结果与事件有限', (id) => {
|
||
const cs = cards([13, 13, 13, 7, 7]),
|
||
r = fixture(cs, [id]);
|
||
const s = scoreHand(r, cs);
|
||
expect(Number.isFinite(s.total)).toBe(true);
|
||
expect(s.trace.at(-1)).toMatchObject({ chips: s.chips, mult: s.mult });
|
||
});
|
||
});
|
||
describe('对局、经济与事务', () => {
|
||
it('相同种子产生相同状态与抽牌', () => {
|
||
expect(act(createRun('SEED'), { type: 'enter' })).toEqual(
|
||
act(createRun('SEED'), { type: 'enter' }),
|
||
);
|
||
});
|
||
it('弃牌不回牌库，卡牌守恒', () => {
|
||
let r = act(createRun('S'), { type: 'enter' });
|
||
for (let i = 0; i < 3; i++) {
|
||
r = act(r, { type: 'discard', ids: r.hand.slice(0, 5) });
|
||
expect(new Set([...r.hand, ...r.draw, ...r.spent]).size).toBe(52);
|
||
expect(r.hand).toHaveLength(8);
|
||
}
|
||
expect(r.draw).toHaveLength(29);
|
||
});
|
||
it('非法操作原子拒绝', () => {
|
||
const r = createRun('S');
|
||
const before = structuredClone(r);
|
||
expect(dispatch(r, { type: 'play', ids: [1] }).error).toBeTruthy();
|
||
expect(r).toEqual(before);
|
||
expect(dispatch(r, { type: 'play', ids: [1] }).state).toBe(r);
|
||
});
|
||
it('重复选择同一实例不能计分两次', () => {
|
||
const r = act(createRun('S'), { type: 'enter' });
|
||
expect(dispatch(r, { type: 'play', ids: [r.hand[0], r.hand[0]] }).error).toBeTruthy();
|
||
});
|
||
it('胜利即时结算奖励，cashout 不再加钱', () => {
|
||
const cs = cards([14]),
|
||
r = fixture(cs);
|
||
r.target = 1;
|
||
r.money = 25;
|
||
const next = act(r, { type: 'play', ids: [1] });
|
||
expect(next.phase).toBe('reward');
|
||
expect(next.money).toBe(36);
|
||
const shop = act(next, { type: 'cashout' });
|
||
expect(shop.money).toBe(36);
|
||
expect(dispatch(shop, { type: 'cashout' }).error).toBeTruthy();
|
||
});
|
||
it('购买后商品消失，重复购买不扣钱', () => {
|
||
let r = createRun('S');
|
||
r.phase = 'reward';
|
||
r.money = 100;
|
||
r = act(r, { type: 'cashout' });
|
||
const it = r.shop[0];
|
||
r = act(r, { type: 'buy', uid: it.uid });
|
||
const money = r.money;
|
||
expect(r.jokers).toHaveLength(1);
|
||
const again = dispatch(r, { type: 'buy', uid: it.uid });
|
||
expect(again.error).toBeTruthy();
|
||
expect(again.state.money).toBe(money);
|
||
});
|
||
it('满槽购买不扣钱、不移除商品', () => {
|
||
let r = createRun('S');
|
||
r.phase = 'reward';
|
||
r.money = 100;
|
||
r = act(r, { type: 'cashout' });
|
||
r.jokers = JOKERS.slice(0, 5).map((j, i) => ({ id: j.id, uid: 200 + i, value: 0 }));
|
||
const result = dispatch(r, { type: 'buy', uid: r.shop[0].uid });
|
||
expect(result.error).toBeTruthy();
|
||
expect(result.state).toBe(r);
|
||
});
|
||
it('免费刷新消耗一次，之后价格从 $5 起', () => {
|
||
let r = createRun('S');
|
||
r.phase = 'reward';
|
||
r.money = 100;
|
||
r.freeReroll = true;
|
||
r = act(r, { type: 'cashout' });
|
||
r = act(r, { type: 'reroll' });
|
||
expect(r.money).toBe(100);
|
||
expect(r.reroll).toBe(5);
|
||
r = act(r, { type: 'reroll' });
|
||
expect(r.money).toBe(95);
|
||
expect(r.reroll).toBe(6);
|
||
});
|
||
it('跳盲记录标签，Boss 不能跳过', () => {
|
||
let r = act(createRun('S'), { type: 'skip' });
|
||
expect(r.freeReroll).toBe(true);
|
||
r = act(r, { type: 'skip' });
|
||
expect(r.investment).toBe(true);
|
||
expect(r.blind).toBe(2);
|
||
expect(dispatch(r, { type: 'skip' }).error).toBeTruthy();
|
||
});
|
||
it('Boss 对手牌/弃牌/出牌的限制', () => {
|
||
let r = createRun('S');
|
||
r.blind = 2;
|
||
r.bosses[0] = 2;
|
||
expect(act(r, { type: 'enter' }).hand).toHaveLength(7);
|
||
r.bosses[0] = 3;
|
||
expect(act(r, { type: 'enter' }).discards).toBe(0);
|
||
r.bosses[0] = 4;
|
||
r = act(r, { type: 'enter' });
|
||
expect(dispatch(r, { type: 'play', ids: [r.hand[0]] }).error).toBeTruthy();
|
||
});
|
||
it('打完最后次数且未达标失败', () => {
|
||
let r = fixture(cards([2]));
|
||
r.hands = 1;
|
||
r.target = 300;
|
||
r = act(r, { type: 'play', ids: [1] });
|
||
expect(r.phase).toBe('lost');
|
||
});
|
||
it('卡包先扣钱，选牌仅能一次', () => {
|
||
let r = createRun('S');
|
||
r.phase = 'reward';
|
||
r.money = 20;
|
||
r = act(r, { type: 'cashout' });
|
||
r = act(r, { type: 'buy', uid: r.packs[0].uid });
|
||
expect(r.phase).toBe('pack');
|
||
expect(r.money).toBe(16);
|
||
const id = r.packChoices[0].uid;
|
||
r = act(r, { type: 'take', uid: id });
|
||
expect(r.jokers).toHaveLength(1);
|
||
expect(dispatch(r, { type: 'take', uid: id }).error).toBeTruthy();
|
||
});
|
||
it('完整 24 关流程的状态机通关（测试夹具提升牌型等级）', () => {
|
||
let r = createRun('FLOW');
|
||
r.levels = r.levels.map(() => 10000);
|
||
for (let n = 0; n < 24; n++) {
|
||
r = act(r, { type: 'enter' });
|
||
const ids =
|
||
r.blind === 2 && r.bosses[r.ante - 1] === 4 ? r.hand.slice(0, 5) : r.hand.slice(0, 1);
|
||
r = act(r, { type: 'play', ids });
|
||
if (n === 23) {
|
||
expect(r.phase).toBe('won');
|
||
break;
|
||
}
|
||
expect(r.phase).toBe('reward');
|
||
r = act(r, { type: 'cashout' });
|
||
r = act(r, { type: 'next' });
|
||
}
|
||
expect(r.ante).toBe(8);
|
||
expect(r.round).toBe(24);
|
||
});
|
||
it('目标曲线与终局倍率', () => {
|
||
const r = createRun('S');
|
||
expect(target(r)).toBe(300);
|
||
r.ante = 8;
|
||
r.blind = 2;
|
||
expect(target(r)).toBe(200000);
|
||
});
|
||
});
|
||
describe('消耗品与持久化', () => {
|
||
it('删牌后无法凑齐 Boss 所需张数时失败，不留下死局', () => {
|
||
let r = fixture(cards([2, 3, 4, 5, 6]));
|
||
r.blind = 2;
|
||
r.bosses[0] = 4;
|
||
r.discards = 0;
|
||
r.consumables = [{ uid: 999, kind: 'tarot', ref: 4, price: 3 }];
|
||
r = act(r, { type: 'use', uid: 999, ids: [1] });
|
||
expect(r.phase).toBe('lost');
|
||
});
|
||
it('可使用复制牌恢复张数时保留出牌阶段', () => {
|
||
let r = fixture(cards([2, 3, 4, 5, 6]));
|
||
r.blind = 2;
|
||
r.bosses[0] = 4;
|
||
r.discards = 0;
|
||
r.consumables = [
|
||
{ uid: 999, kind: 'tarot', ref: 4, price: 3 },
|
||
{ uid: 998, kind: 'tarot', ref: 3, price: 3 },
|
||
];
|
||
r = act(r, { type: 'use', uid: 999, ids: [1] });
|
||
expect(r.phase).toBe('play');
|
||
r = act(r, { type: 'use', uid: 998, ids: [2] });
|
||
expect(r.hand).toHaveLength(5);
|
||
});
|
||
it('空牌组进入盲注直接失败', () => {
|
||
const r = createRun('EMPTY');
|
||
r.cards = [];
|
||
expect(act(r, { type: 'enter' }).phase).toBe('lost');
|
||
});
|
||
it('行星只升级指定牌型，并从库存消失', () => {
|
||
let r = act(createRun('S'), { type: 'enter' });
|
||
r.consumables = [{ uid: 999, kind: 'planet', ref: 1, price: 3 }];
|
||
r = act(r, { type: 'use', uid: 999, ids: [] });
|
||
expect(r.levels[1]).toBe(2);
|
||
expect(r.consumables).toHaveLength(0);
|
||
});
|
||
it('塔罗复制产生新实例，保持属性', () => {
|
||
let r = fixture(cards([13, 13]));
|
||
r.cards[0].seal = true;
|
||
r.consumables = [{ uid: 999, kind: 'tarot', ref: 3, price: 3 }];
|
||
r = act(r, { type: 'use', uid: 999, ids: [1] });
|
||
expect(r.cards).toHaveLength(3);
|
||
expect(r.cards[2]).toMatchObject({ rank: 13, seal: true });
|
||
expect(r.cards[2].id).not.toBe(1);
|
||
expect(new Set(r.hand).size).toBe(3);
|
||
});
|
||
it('销毁不能清空牌组；非法目标不消耗塔罗', () => {
|
||
const r = fixture(cards([14]));
|
||
r.consumables = [{ uid: 999, kind: 'tarot', ref: 4, price: 3 }];
|
||
expect(dispatch(r, { type: 'use', uid: 999, ids: [1] }).state).toBe(r);
|
||
});
|
||
it.each([0, 1, 2, 5, 6, 7, 8])('塔罗 %s 修改正确属性', (ref) => {
|
||
let r = fixture(cards([14], [2]));
|
||
r.consumables = [{ uid: 999, kind: 'tarot', ref, price: 3 }];
|
||
r = act(r, { type: 'use', uid: 999, ids: [1] });
|
||
if (ref === 0) expect(r.cards[0].suit).toBe(0);
|
||
if (ref === 1) expect(r.cards[0].suit).toBe(1);
|
||
if (ref === 2) expect(r.cards[0].rank).toBe(2);
|
||
if (ref === 5) expect(r.cards[0].enh).toBe('glass');
|
||
if (ref === 6) expect(r.cards[0].enh).toBe('steel');
|
||
if (ref === 7) expect(r.cards[0]).toMatchObject({ enh: 'bonus', seal: true });
|
||
if (ref === 8) expect(r.cards[0].enh).toBe('mult');
|
||
});
|
||
it('序列化恢复保留抽牌随机状态', () => {
|
||
const r = act(createRun('SAVE'), { type: 'enter' }),
|
||
copy = JSON.parse(JSON.stringify(r));
|
||
expect(validateRun(copy)).toBe(true);
|
||
expect(act(r, { type: 'discard', ids: r.hand.slice(0, 3) })).toEqual(
|
||
act(copy, { type: 'discard', ids: copy.hand.slice(0, 3) }),
|
||
);
|
||
});
|
||
it('损坏或未知规则的存档被拒绝', () => {
|
||
const r = createRun('S');
|
||
expect(validateRun({ ...r, rules: 'other' })).toBe(false);
|
||
expect(validateRun({ ...r, cards: [{ id: 1, rank: 99, suit: 0 }] })).toBe(false);
|
||
expect(validateRun({ ...r, hand: [1, 1] })).toBe(false);
|
||
});
|
||
});
|