81 lines
1.8 KiB
TypeScript
81 lines
1.8 KiB
TypeScript
import constant from './constant';
|
|
import NodeFactory from '/imports/parser/parseTree/NodeFactory';
|
|
import { Context, ResolvedResult } from '/imports/parser/resolve';
|
|
|
|
type RollValue = {
|
|
value: number,
|
|
disabled?: true,
|
|
italics?: true,
|
|
bold?: true,
|
|
underline?: true,
|
|
}
|
|
|
|
export type RollArrayNode = {
|
|
parseType: 'rollArray';
|
|
values: RollValue[];
|
|
diceSize: number,
|
|
diceNum: number,
|
|
}
|
|
|
|
interface RollArrayFactory extends NodeFactory {
|
|
create(input: { values: number[], diceSize: number, diceNum: number }): RollArrayNode;
|
|
compile(
|
|
node: RollArrayNode, scope: Record<string, any>, context: Context
|
|
): ResolvedResult;
|
|
roll?: undefined;
|
|
reduce(
|
|
node: RollArrayNode, scope: Record<string, any>, context: Context
|
|
): ResolvedResult;
|
|
resolve?: undefined;
|
|
toString(node: RollArrayNode): string;
|
|
traverse?: undefined;
|
|
map?: undefined;
|
|
}
|
|
|
|
const rollArray: RollArrayFactory = {
|
|
create({
|
|
values, diceSize, diceNum
|
|
}) {
|
|
return {
|
|
parseType: 'rollArray',
|
|
values: values.map(v => ({ value: v })),
|
|
diceSize,
|
|
diceNum,
|
|
};
|
|
},
|
|
compile(node, scope, context) {
|
|
return {
|
|
result: node,
|
|
context
|
|
};
|
|
},
|
|
toString(node) {
|
|
return `${node.diceNum || ''}d${node.diceSize} [${valuesToString(node.values)}]`;
|
|
},
|
|
reduce(node, scope, context) {
|
|
const total = node.values.reduce((a, b) => {
|
|
if (b.disabled) return a;
|
|
return a + b.value;
|
|
}, 0);
|
|
return {
|
|
result: constant.create({
|
|
value: total,
|
|
}),
|
|
context,
|
|
};
|
|
},
|
|
}
|
|
|
|
function valuesToString(values: RollValue[]) {
|
|
return values.map(v => {
|
|
let text = `${v.value}`;
|
|
if (v.disabled) text = `~~${text}~~`;
|
|
if (v.italics) text = `*${text}*`;
|
|
if (v.bold) text = `**${text}**`;
|
|
if (v.underline) text = `__${text}__`;
|
|
return text;
|
|
}).join(', ');
|
|
}
|
|
|
|
export default rollArray;
|