Implement Emperor Nexus Cunning with physical casualty recovery
This commit is contained in:
1 parent
b05125de9a
commit
ba0b5647e1
27 files changed
+2487
-64
No files matched your search
@@ -0,0 +1,260 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
casualtyOptions,
|
||||
maxCombatDial,
|
||||
maxCombatSupport,
|
||||
validCombatForces,
|
||||
type CombatForces,
|
||||
} from '../game/combat';
|
||||
import {
|
||||
stoneBurnerComparison,
|
||||
stoneBurnerPlanBlock,
|
||||
} from '../game/stone-burner';
|
||||
import {
|
||||
quoteBattleResolution,
|
||||
type BattleResolutionInput,
|
||||
} from '../game/battle-resolution-quote';
|
||||
import { leaders } from '../game/cards';
|
||||
|
||||
const pool = (patch: Partial<CombatForces> = {}): CombatForces => ({
|
||||
normal: 7,
|
||||
elite: 0,
|
||||
temporaryElite: 5,
|
||||
eliteStrength: 2,
|
||||
freeSupport: false,
|
||||
...patch,
|
||||
});
|
||||
|
||||
void test('temporary Sardaukar produce alternative ordinary casualties and pay only for physical counters', () => {
|
||||
const forces = pool(),
|
||||
before = structuredClone(forces);
|
||||
assert.deepEqual(casualtyOptions(forces, 2, 0), [
|
||||
{ normal: 2, elite: 0, paidNormal: 0, paidElite: 0 },
|
||||
{ normal: 3, elite: 0, paidNormal: 0, paidElite: 0 },
|
||||
]);
|
||||
assert.deepEqual(casualtyOptions(forces, 2, 1), [
|
||||
{ normal: 1, elite: 0, paidNormal: 1, paidElite: 0 },
|
||||
{ normal: 2, elite: 0, paidNormal: 1, paidElite: 0 },
|
||||
]);
|
||||
assert.deepEqual(casualtyOptions(forces, 12, 7), [
|
||||
{ normal: 7, elite: 0, paidNormal: 7, paidElite: 0 },
|
||||
]);
|
||||
assert.equal(maxCombatDial(forces), 12);
|
||||
assert.equal(maxCombatSupport(forces), 7);
|
||||
assert.deepEqual(forces, before);
|
||||
});
|
||||
|
||||
void test('Salusa support, ordinary free support and canceled Sardaukar strength retain distinct role arithmetic', () => {
|
||||
const salusa = pool({ eliteFreeSupport: true });
|
||||
assert.equal(maxCombatSupport(salusa), 2);
|
||||
assert.equal(maxCombatDial(salusa), 12);
|
||||
assert.deepEqual(casualtyOptions(salusa, 12, 2), [
|
||||
{ normal: 7, elite: 0, paidNormal: 2, paidElite: 0 },
|
||||
]);
|
||||
assert.deepEqual(casualtyOptions(salusa, 12, 7), []);
|
||||
const normalFree = pool({ normalFreeSupport: true });
|
||||
assert.equal(maxCombatSupport(normalFree), 5);
|
||||
assert.deepEqual(casualtyOptions(normalFree, 12, 5), [
|
||||
{ normal: 7, elite: 0, paidNormal: 5, paidElite: 0 },
|
||||
]);
|
||||
const suppressed = pool({ eliteStrength: 1 });
|
||||
assert.equal(maxCombatDial(suppressed), 7);
|
||||
for (let half = 0; half <= 14; half++)
|
||||
for (let support = 0; support <= 7; support++) {
|
||||
assert.deepEqual(
|
||||
casualtyOptions(suppressed, half / 2, support),
|
||||
casualtyOptions(
|
||||
{ ...suppressed, temporaryElite: undefined },
|
||||
half / 2,
|
||||
support,
|
||||
),
|
||||
);
|
||||
}
|
||||
assert.equal(maxCombatSupport(pool({ freeSupport: true })), 0);
|
||||
assert.deepEqual(casualtyOptions(pool({ freeSupport: true }), 12, 0), [
|
||||
{ normal: 7, elite: 0, paidNormal: 0, paidElite: 0 },
|
||||
]);
|
||||
});
|
||||
|
||||
/** Independent labeled-counter choices: survive, die unsupported, die supported. */
|
||||
function assignments(forces: CombatForces) {
|
||||
let states = new Set(['0:0:0']);
|
||||
for (let counter = 0; counter < forces.normal; counter++) {
|
||||
const temporary = counter < (forces.temporaryElite ?? 0);
|
||||
const strength = temporary ? forces.eliteStrength : 1;
|
||||
const free =
|
||||
forces.freeSupport ||
|
||||
(temporary ? forces.eliteFreeSupport : forces.normalFreeSupport);
|
||||
const fixedHalf =
|
||||
!temporary && forces.normalFixedHalf && !forces.normalFreeSupport;
|
||||
const choices = [
|
||||
[0, 0, 0],
|
||||
[1, strength * (free && !fixedHalf ? 2 : 1), 0],
|
||||
];
|
||||
if (!free && !fixedHalf) choices.push([1, strength * 2, 1]);
|
||||
const next = new Set<string>();
|
||||
for (const previous of states) {
|
||||
const [loss, half, paid] = previous.split(':').map(Number);
|
||||
for (const [n, h, p] of choices)
|
||||
next.add(`${loss + n}:${half + h}:${paid + p}`);
|
||||
}
|
||||
states = next;
|
||||
}
|
||||
return [...states].map((state) => state.split(':').map(Number));
|
||||
}
|
||||
|
||||
void test('mapped losses match independent counter enumeration across mixed roles and every support exemption', () => {
|
||||
for (const normal of [0, 1, 2, 4, 6])
|
||||
for (let temporaryElite = 0; temporaryElite <= normal; temporaryElite++)
|
||||
for (const eliteStrength of [1, 2] as const)
|
||||
for (const flags of [
|
||||
{},
|
||||
{ eliteFreeSupport: true },
|
||||
{ normalFreeSupport: true },
|
||||
{ normalFixedHalf: true },
|
||||
{ normalFixedHalf: true, normalFreeSupport: true },
|
||||
{ freeSupport: true },
|
||||
{ freeSupport: true, normalFixedHalf: true },
|
||||
{ eliteFreeSupport: true, normalFreeSupport: true },
|
||||
]) {
|
||||
const forces = pool({
|
||||
normal,
|
||||
temporaryElite,
|
||||
eliteStrength,
|
||||
...flags,
|
||||
});
|
||||
const expected = assignments(forces);
|
||||
assert.equal(
|
||||
maxCombatDial(forces),
|
||||
Math.max(...expected.map(([, half]) => half)) / 2,
|
||||
);
|
||||
assert.equal(
|
||||
maxCombatSupport(forces),
|
||||
Math.max(...expected.map(([, , paid]) => paid)),
|
||||
);
|
||||
for (let half = 0; half <= normal * 4; half++)
|
||||
for (let support = 0; support <= normal; support++) {
|
||||
const losses = expected
|
||||
.filter(([, h, p]) => h === half && p === support)
|
||||
.map(([n]) => n)
|
||||
.sort((a, b) => a - b);
|
||||
assert.deepEqual(
|
||||
casualtyOptions(forces, half / 2, support),
|
||||
losses.map((normal) => ({
|
||||
normal,
|
||||
elite: 0,
|
||||
paidNormal: support,
|
||||
paidElite: 0,
|
||||
})),
|
||||
JSON.stringify([forces, half, support]),
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
void test('Stone Burner compares physical survivors and separates temporary-role cache entries', () => {
|
||||
const own: CombatForces = {
|
||||
normal: 4,
|
||||
elite: 0,
|
||||
eliteStrength: 1,
|
||||
freeSupport: true,
|
||||
};
|
||||
const temporary = pool({ normal: 3, temporaryElite: 2 });
|
||||
const ordinary = { ...temporary, temporaryElite: 0 };
|
||||
assert.deepEqual(stoneBurnerComparison(temporary, 2, 0, own, 2, 0), {
|
||||
winner: 'defender',
|
||||
attacker: [1],
|
||||
defender: [2],
|
||||
});
|
||||
assert.deepEqual(stoneBurnerComparison(temporary, 2, 1, own, 2, 0), {
|
||||
winner: null,
|
||||
attacker: [1, 2],
|
||||
defender: [2],
|
||||
});
|
||||
for (let repeat = 0; repeat < 3; repeat++) {
|
||||
assert.equal(stoneBurnerPlanBlock(own, 3, 0, ordinary, 'attacker'), null);
|
||||
assert.match(
|
||||
stoneBurnerPlanBlock(own, 3, 0, temporary, 'attacker')!,
|
||||
/different legal force allocations/,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
function resolution(): BattleResolutionInput {
|
||||
const a = leaders('emperor')[0],
|
||||
d = leaders('guild')[0];
|
||||
return {
|
||||
advanced: true,
|
||||
turn: 2,
|
||||
territory: 'pasty_mesa',
|
||||
attacker: {
|
||||
id: 'e',
|
||||
faction: 'emperor',
|
||||
spice: 7,
|
||||
hand: [],
|
||||
leader: a,
|
||||
forces: pool(),
|
||||
plan: { dial: 12, support: 7, leader: a.id, weapon: null, defense: null },
|
||||
},
|
||||
defender: {
|
||||
id: 'g',
|
||||
faction: 'guild',
|
||||
spice: 0,
|
||||
hand: [],
|
||||
leader: d,
|
||||
forces: { normal: 1, elite: 0, eliteStrength: 1, freeSupport: false },
|
||||
plan: { dial: 0, support: 0, leader: d.id, weapon: null, defense: null },
|
||||
},
|
||||
voters: [
|
||||
{ id: 'e', beneficiary: 'e', called: false, traitors: [] },
|
||||
{ id: 'g', beneficiary: 'g', called: false, traitors: [] },
|
||||
],
|
||||
participants: [
|
||||
{ id: 'e', faction: 'emperor' },
|
||||
{ id: 'g', faction: 'guild' },
|
||||
],
|
||||
physicalCards: [],
|
||||
pendingAuditorPresent: false,
|
||||
pendingRetentionPresent: false,
|
||||
};
|
||||
}
|
||||
|
||||
void test('battle quote retains the physical pool, ordinary casualties and exact support payment', () => {
|
||||
const input = resolution(),
|
||||
before = structuredClone(input),
|
||||
quote = quoteBattleResolution(input);
|
||||
assert.equal(quote.winner, 'e');
|
||||
assert.equal(quote.payments.find((p) => p.player === 'e')!.cost, 7);
|
||||
assert.deepEqual(quote.casualties!.forces, input.attacker.forces);
|
||||
assert.deepEqual(quote.casualties!.options, [
|
||||
{ normal: 7, elite: 0, paidNormal: 7, paidElite: 0 },
|
||||
]);
|
||||
assert.deepEqual(input, before);
|
||||
});
|
||||
|
||||
void test('invalid temporary populations reject before calculation without changing physical custody', () => {
|
||||
for (const temporaryElite of [-1, 0.5, 8, 21, NaN, Infinity, '5', null]) {
|
||||
const forces = { ...pool(), temporaryElite } as unknown as CombatForces;
|
||||
assert.equal(validCombatForces(forces), false);
|
||||
assert.deepEqual(casualtyOptions(forces, 2, 0), []);
|
||||
assert.equal(maxCombatDial(forces), 0);
|
||||
assert.equal(maxCombatSupport(forces), 0);
|
||||
assert.match(
|
||||
stoneBurnerPlanBlock(forces, 2, 0, pool(), 'attacker')!,
|
||||
/valid supported physical/,
|
||||
);
|
||||
const input = resolution();
|
||||
input.attacker.forces = forces;
|
||||
const before = structuredClone(input);
|
||||
assert.throws(() => quoteBattleResolution(input), /valid force/);
|
||||
assert.deepEqual(input, before);
|
||||
}
|
||||
assert.equal(validCombatForces(pool({ elite: 1 })), false);
|
||||
assert.equal(validCombatForces(pool({ normal: 21 })), false);
|
||||
assert.equal(
|
||||
validCombatForces(pool({ normal: 20, temporaryElite: 20 })),
|
||||
true,
|
||||
);
|
||||
assert.equal(maxCombatDial(pool({ normal: 20, temporaryElite: 20 })), 40);
|
||||
});
|
||||
Reference in new issue
Block a user