199 lines
9.8 KiB
JavaScript
199 lines
9.8 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import { test } from 'node:test';
|
|
import vm from 'node:vm';
|
|
|
|
const sheet = readFileSync(new URL('../build/ravenous.html', import.meta.url), 'utf8');
|
|
const script = sheet.match(/<script type="text\/worker">([\s\S]*?)<\/script>/)?.[1];
|
|
assert.ok(script, 'generated sheet worker exists; run ./scripts/build.sh first');
|
|
const generatedData = name => JSON.parse(sheet.match(new RegExp(`const ${name} = ([\\s\\S]*?);\\n`))?.[1]);
|
|
|
|
function worker(initial = {}) {
|
|
const attrs = { ...initial };
|
|
const handlers = new Map();
|
|
const rolls = [];
|
|
const queuedRolls = [];
|
|
let nextRow = 0;
|
|
const context = {
|
|
on(events, callback) {
|
|
for (const event of events.split(/\s+/)) {
|
|
if (!handlers.has(event)) handlers.set(event, []);
|
|
handlers.get(event).push(callback);
|
|
}
|
|
},
|
|
getAttrs(names, callback) {
|
|
callback(Object.fromEntries(names.map(name => [name, attrs[name]])));
|
|
},
|
|
setAttrs(values, options, callback) {
|
|
Object.assign(attrs, values);
|
|
(typeof options === 'function' ? options : callback)?.();
|
|
},
|
|
getSectionIDs(section, callback) {
|
|
const prefix = `repeating_${section}_`;
|
|
callback([...new Set(Object.keys(attrs).filter(key => key.startsWith(prefix))
|
|
.map(key => key.slice(prefix.length).split('_')[0]))]);
|
|
},
|
|
generateRowID: () => nextRow++ === 0 ? 'newrow' : `row${nextRow}`,
|
|
startRoll(command, callback) {
|
|
const queued = queuedRolls.shift();
|
|
assert.ok(queued, `No scripted result for ${command}`);
|
|
const roll = { command, rollId: queued.rollId, computed: undefined };
|
|
rolls.push(roll);
|
|
callback({ rollId: roll.rollId, results: Object.fromEntries(
|
|
Object.entries(queued.results).map(([name, result]) => [name, { result }])) });
|
|
},
|
|
finishRoll(rollId, computed) {
|
|
const roll = rolls.find(item => item.rollId === rollId);
|
|
assert.ok(roll);
|
|
roll.computed = computed;
|
|
},
|
|
};
|
|
vm.runInNewContext(script, context, { filename: 'ravenous-worker.js' });
|
|
const fire = (event, payload = {}) => {
|
|
for (const callback of handlers.get(event) || []) callback(payload);
|
|
};
|
|
const queueRoll = (rollId, results) => queuedRolls.push({ rollId, results });
|
|
return { attrs, fire, queueRoll, rolls };
|
|
}
|
|
|
|
test('opening the sheet recalculates base and temporary values', () => {
|
|
const { attrs, fire } = worker({ force: '3', force_manual: '2', agilite: '4', volonte: '2', stage: '3' });
|
|
fire('sheet:opened');
|
|
assert.equal(attrs.force_total, 5);
|
|
assert.equal(attrs.torque, 15); // Derived from permanent Force.
|
|
assert.equal(attrs.hp_limbs_max, 7);
|
|
assert.equal(attrs.hp_torso_max, 9);
|
|
assert.equal(attrs.toxicite_max, 11);
|
|
assert.equal(attrs.parade_total, 5); // Default Parade characteristic is Force.
|
|
});
|
|
|
|
test('selected resistances and live protections update mitigation', () => {
|
|
const { attrs, fire } = worker({
|
|
force: '3', resist_fire: '2', damage_apply_fire: '1',
|
|
resist_slash: '1', damage_apply_slash: '1',
|
|
repeating_protections_a_active: '1', repeating_protections_a_integrity: '2', repeating_protections_a_protection: '4',
|
|
repeating_protections_b_active: '1', repeating_protections_b_integrity: '0', repeating_protections_b_protection: '9',
|
|
});
|
|
fire('sheet:opened');
|
|
assert.equal(attrs.damage_resistance_total, 3);
|
|
assert.equal(attrs.active_protection_total, 4);
|
|
assert.equal(attrs.active_first_protection, 4);
|
|
assert.equal(attrs.active_mitigation_total, 7);
|
|
fire('clicked:clear_damage_resistances');
|
|
assert.equal(attrs.damage_resistance_total, 0);
|
|
});
|
|
|
|
test('technique selector adds one row and rejects a duplicate', () => {
|
|
const [key, technique] = Object.entries(generatedData('TECHNIQUES'))[0];
|
|
const { attrs, fire } = worker({ technique_to_add: key });
|
|
fire('clicked:add_technique');
|
|
assert.equal(attrs.repeating_techniques_newrow_name, technique.name);
|
|
assert.equal(attrs.repeating_techniques_newrow_school, technique.school_label);
|
|
assert.equal(attrs.repeating_techniques_newrow_source_key, key);
|
|
fire('clicked:add_technique');
|
|
assert.match(attrs.technique_message, /déjà présente/);
|
|
});
|
|
|
|
test('opening the sheet capitalizes old imported school names without changing edits', () => {
|
|
const sheetWorker = worker({
|
|
repeating_techniques_old_source_key: 'artilleur:0',
|
|
repeating_techniques_old_school: 'artilleur',
|
|
repeating_techniques_edited_source_key: 'artilleur:1',
|
|
repeating_techniques_edited_school: 'École maison',
|
|
});
|
|
sheetWorker.fire('sheet:opened');
|
|
assert.equal(sheetWorker.attrs.repeating_techniques_old_school, 'Artilleur');
|
|
assert.equal(sheetWorker.attrs.repeating_techniques_edited_school, 'École maison');
|
|
});
|
|
|
|
test('skill roll reports a critical success and a threshold failure', () => {
|
|
const sheetWorker = worker({ force: '3', parade: '2', skill_die: '10', character_name: 'Test' });
|
|
sheetWorker.fire('sheet:opened');
|
|
sheetWorker.queueRoll('critical', { roll: 1 });
|
|
sheetWorker.fire('clicked:skill_parade');
|
|
assert.equal(sheetWorker.rolls[0].computed.outcome, 'Réussite critique');
|
|
assert.equal(sheetWorker.rolls[0].computed.margin, 4);
|
|
sheetWorker.queueRoll('failure', { roll: 5 });
|
|
sheetWorker.fire('clicked:skill_parade');
|
|
assert.equal(sheetWorker.rolls[1].computed.outcome, 'Échec');
|
|
sheetWorker.attrs.skill_die = '4';
|
|
sheetWorker.queueRoll('critical-failure', { roll: 4 });
|
|
sheetWorker.fire('clicked:skill_parade');
|
|
assert.match(sheetWorker.rolls[2].command, /1d4cs1cf4/);
|
|
assert.equal(sheetWorker.rolls[2].computed.outcome, 'Échec critique');
|
|
});
|
|
|
|
test('attack and defense cap remaining successes at RMax', () => {
|
|
const prefix = 'repeating_attacks_a_';
|
|
const sheetWorker = worker({
|
|
[prefix + 'name']: 'Test', [prefix + 'dice']: '5', [prefix + 'threshold']: '6',
|
|
[prefix + 'base_damage']: '4', [prefix + 'damage_per_success']: '2',
|
|
[prefix + 'break_damage']: '3', [prefix + 'rmax']: '2',
|
|
});
|
|
sheetWorker.queueRoll('attack1', { attack_roll: 4 });
|
|
sheetWorker.fire('clicked:repeating_attacks:attack', { sourceAttribute: prefix + 'attack' });
|
|
assert.equal(sheetWorker.rolls[0].computed.attack_successes, 4);
|
|
assert.match(sheetWorker.rolls[0].command, /\?\{Nombre de dés\|5\}d10/);
|
|
sheetWorker.queueRoll('defense1', { defense_roll: 1 });
|
|
sheetWorker.fire('clicked:repeating_attacks:defend', {
|
|
sourceAttribute: prefix + 'defend', originalRollId: 'attack1',
|
|
});
|
|
assert.equal(sheetWorker.rolls[1].computed.finalsuccesses, 2);
|
|
assert.equal(sheetWorker.rolls[1].computed.damage, 6);
|
|
assert.match(sheetWorker.rolls[1].command, /@\{target\|Défenseur\|character_name\}/);
|
|
assert.doesNotMatch(sheetWorker.rolls[1].command, /@\{selected\|/);
|
|
});
|
|
|
|
test('Subir reports damage and armor break after selected mitigation', () => {
|
|
const prefix = 'repeating_attacks_a_';
|
|
const sheetWorker = worker({
|
|
[prefix + 'name']: 'Test', [prefix + 'base_damage']: '8',
|
|
[prefix + 'damage_per_success']: '2', [prefix + 'break_damage']: '6',
|
|
[prefix + 'rmax']: '3',
|
|
});
|
|
// Roll20 resolves the defender's attribute references and query before the callback.
|
|
sheetWorker.queueRoll('damage1', { remaining: 2, selected_resistance: 1, location_protection: 70004 });
|
|
sheetWorker.fire('clicked:repeating_attacks:take_damage', { sourceAttribute: prefix + 'take_damage' });
|
|
assert.match(sheetWorker.rolls[0].command, /@\{target\|Défenseur\|damage_resistance_total\}/);
|
|
assert.doesNotMatch(sheetWorker.rolls[0].command, /@\{selected\|/);
|
|
assert.equal(sheetWorker.rolls[0].computed.incoming_damage, 10);
|
|
assert.equal(sheetWorker.rolls[0].computed.resistance_reduction, 2);
|
|
assert.equal(sheetWorker.rolls[0].computed.protection_reduction, 7);
|
|
assert.equal(sheetWorker.rolls[0].computed.damage, 1);
|
|
assert.equal(sheetWorker.rolls[0].computed.break_damage, 1);
|
|
});
|
|
|
|
test('origin stage picker adds its powers once and preserves custom rows', () => {
|
|
const origins = generatedData('ORIGINS');
|
|
const stagePowers = origins.dragon_1.powers.filter(power => power.stage === '1');
|
|
const sheetWorker = worker({
|
|
origin_key: 'dragon_1',
|
|
power_stage_to_add: '1',
|
|
repeating_powers_custom_name: 'Pouvoir maison',
|
|
repeating_powers_custom_description: 'Texte libre',
|
|
});
|
|
sheetWorker.fire('change:origin_key');
|
|
let keys = Object.keys(sheetWorker.attrs).filter(key => key.startsWith('repeating_powers_') && key.endsWith('_source_key'));
|
|
assert.equal(keys.length, 0);
|
|
assert.equal(sheetWorker.attrs.origin, 'Ür-Dragon, Maître des Cieux');
|
|
assert.equal(sheetWorker.attrs.repeating_powers_custom_name, 'Pouvoir maison');
|
|
sheetWorker.fire('clicked:add_power_stage');
|
|
keys = Object.keys(sheetWorker.attrs).filter(key => key.startsWith('repeating_powers_') && key.endsWith('_source_key'));
|
|
assert.equal(keys.length, stagePowers.length);
|
|
const firstKey = keys[0].replace(/_source_key$/, '');
|
|
assert.ok(sheetWorker.attrs[firstKey + '_name']);
|
|
assert.ok(sheetWorker.attrs[firstKey + '_stage']);
|
|
sheetWorker.fire('clicked:add_power_stage');
|
|
assert.match(sheetWorker.attrs.power_message, /déjà présents/);
|
|
assert.equal(Object.keys(sheetWorker.attrs).filter(key => key.startsWith('repeating_powers_') && key.endsWith('_source_key')).length, stagePowers.length);
|
|
sheetWorker.attrs.power_stage_to_add = '2';
|
|
sheetWorker.fire('clicked:add_power_stage');
|
|
assert.equal(Object.keys(sheetWorker.attrs).filter(key => key.startsWith('repeating_powers_') && key.endsWith('_source_key')).length,
|
|
stagePowers.length + origins.dragon_1.powers.filter(power => power.stage === '2').length);
|
|
sheetWorker.attrs.origin_key = 'dragon_2';
|
|
sheetWorker.fire('change:origin_key');
|
|
assert.equal(sheetWorker.attrs.repeating_powers_custom_name, 'Pouvoir maison');
|
|
assert.equal(Object.keys(sheetWorker.attrs).filter(key => key.startsWith('repeating_powers_') && key.endsWith('_source_key')).length,
|
|
stagePowers.length + origins.dragon_1.powers.filter(power => power.stage === '2').length);
|
|
});
|