@yipe/dice 0.4.0 → 0.6.0

package/dist/builder/index.d.ts

@@ -1,379 +1,8 @@
-import { b as RollType, P as PMF, l as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-D5VRghZI.js';
-
-type RollFactory = {
-    (count: number, sides?: number, modifier?: number): RollBuilder;
-    (count: number, die: RollBuilder, modifier?: number): RollBuilder;
-    d(sides: number | string): RollBuilder;
-    hd20(): RollBuilder;
-    d4(): RollBuilder;
-    d6(): RollBuilder;
-    d8(): RollBuilder;
-    d10(): RollBuilder;
-    d12(): RollBuilder;
-    d20(): RollBuilder;
-    d100(): RollBuilder;
-    flat(n: number): RollBuilder;
-};
-type KeepMode = "highest" | "lowest";
-type RollConfig = {
-    count: number;
-    sides: number;
-    modifier: number;
-    reroll: number;
-    explode: number;
-    minimum: number;
-    bestOf: number;
-    keep: {
-        total: number;
-        count: number;
-        mode: KeepMode;
-    } | undefined;
-    rollType: RollType;
-    isSubtraction?: boolean;
-};
-type Resolution = {
-    pmf: PMF;
-    check: PMF;
-    weights: {
-        [key: string]: number;
-    };
-};
-type AttackResolution = Resolution & {
-    hit: PMF;
-    crit: PMF;
-    miss: PMF;
-    weights: {
-        hit: number;
-        crit: number;
-        miss: number;
-    };
-};
-type SaveResolution = Resolution & {
-    saveFail: PMF;
-    saveSuccess: PMF;
-    weights: {
-        success: number;
-        fail: number;
-    };
-};
-interface CheckBuilder {
-    resolve(eps?: number): Resolution;
-    toExpression(): string;
-    readonly pmf: PMF;
-}
-
-type SaveOutcome = "normal" | "half";
-declare class SaveBuilder implements CheckBuilder {
-    readonly check: DCBuilder;
-    private readonly failureEffect?;
-    private readonly saveOutcome;
-    constructor(check: DCBuilder, failureEffect?: RollBuilder | undefined, saveOutcome?: SaveOutcome);
-    saveHalf(): SaveBuilder;
-    toExpression(): string;
-    resolve(eps?: number): SaveResolution;
-    toPMF(eps?: number): PMF;
-    get pmf(): PMF;
-    toQuery(eps?: number): DiceQuery;
-}
-
-interface SaveConfig {
-    dc: number;
-}
-declare class DCBuilder extends RollBuilder {
-    private readonly saveConfig;
-    constructor(baseRoll: RollBuilder, saveConfig?: SaveConfig);
-    dc(saveDC: number): DCBuilder;
-    get saveDC(): number;
-    add(anotherRoll: RollBuilder): DCBuilder;
-    addRoll(count?: number): DCBuilder;
-    onSaveFailure(val: number): SaveBuilder;
-    onSaveFailure(val: string): SaveBuilder;
-    onSaveFailure(val: RollBuilder): SaveBuilder;
-    onSaveFailure(count: number, die: RollBuilder): SaveBuilder;
-    onSaveFailure(count: number, sides: number): SaveBuilder;
-    onSaveFailure(count: number, die: RollBuilder, modifier: number): SaveBuilder;
-    onSaveFailure(count: number, sides: number, modifier: number): SaveBuilder;
-    withElvenAccuracy(): never;
-    toExpression(): string;
-    toPMF(eps?: number): PMF;
-}
-
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
-type DieNode = {
-    type: "die";
-    sides: number;
-    reroll?: number;
-    minimum?: number;
-    explode?: number;
-};
-type ConstantNode = {
-    type: "constant";
-    value: number;
-};
-type SumNode = {
-    type: "sum";
-    count: number;
-    child: ExpressionNode;
-};
-type AddNode = {
-    type: "add";
-    children: {
-        node: ExpressionNode;
-        sign: 1 | -1;
-    }[];
-};
-type KeepNode = {
-    type: "keep";
-    mode: "highest" | "lowest";
-    count: number;
-    child: SumNode | KeepNode;
-};
-type D20RollNode = {
-    type: "d20Roll";
-    rollType: "advantage" | "disadvantage" | "elven accuracy";
-    child: ExpressionNode;
-};
-type HalfNode = {
-    type: "half";
-    child: ExpressionNode;
-};
-type MaxOfNode = {
-    type: "maxOf";
-    count: number;
-    child: ExpressionNode;
-};
-
-declare const defaultConfig: RollConfig;
-declare class RollBuilder {
-    protected readonly subRollConfigs: readonly RollConfig[];
-    constructor(countOrConfigs?: number | readonly RollConfig[]);
-    protected create(configs: readonly RollConfig[]): RollBuilder;
-    protected get lastConfig(): RollConfig;
-    hasHiddenState(): boolean;
-    getSubRollConfigs(): readonly RollConfig[];
-    static fromConfig(config: Partial<RollConfig>): RollBuilder;
-    static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder;
-    static fromArgs(...args: any[]): RollBuilder;
-    d(sides: number | undefined): RollBuilder;
-    plus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
-    plus(count: number, die: RollBuilder): RollBuilder;
-    minus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
-    minus(count: number, die: RollBuilder): RollBuilder;
-    /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */
-    reroll(value: number): RollBuilder;
-    /** Set finite explode count for max-face explosions (Infinity allowed). */
-    explode(count?: number | undefined): RollBuilder;
-    /** Apply per-die minimum value (min > 0). */
-    minimum(val: number | undefined): RollBuilder;
-    bestOf(count: number | undefined): RollBuilder;
-    keepHighest(total: number, count: number): RollBuilder;
-    keepLowest(total: number, count: number): RollBuilder;
-    keepHighestAll(total: number, count: number): PooledRollBuilder;
-    keepLowestAll(total: number, count: number): PooledRollBuilder;
-    withAdvantage(): RollBuilder;
-    withDisadvantage(): RollBuilder;
-    add(anotherRoll: RollBuilder | undefined): RollBuilder;
-    withBonus(anotherRoll: RollBuilder): RollBuilder;
-    addRoll(count?: number): RollBuilder;
-    scaleDice(scale: number): RollBuilder;
-    doubleDice(): RollBuilder;
-    alwaysHits(): AlwaysHitBuilder;
-    alwaysCrits(): AlwaysCritBuilder;
-    copy(): RollBuilder;
-    d4: () => RollBuilder;
-    d6: () => RollBuilder;
-    d8: () => RollBuilder;
-    d10: () => RollBuilder;
-    d12: () => RollBuilder;
-    d20: () => RollBuilder;
-    d100: () => RollBuilder;
-    withElvenAccuracy(): RollBuilder;
-    toExpression(): string;
-    toPMF(eps?: number): PMF;
-    get pmf(): PMF;
-    toQuery(eps?: number): DiceQuery;
-    toAST(): ExpressionNode;
-    private configToSingleExpressionWithoutModifier;
-    getRootDieConfig(): RollConfig | undefined;
-    getAllDieConfigs(): readonly RollConfig[];
-    getBonusDiceConfigs(): RollConfig[];
-    getBonusDicePMFs(check: RollBuilder, eps?: number): PMF[];
-    get modifier(): number;
-    get rollType(): RollType;
-    get baseReroll(): number;
-    half(): HalfRollBuilder;
-    maxOf(count: number): MaxOfRollBuilder;
-    ac(_targetAC: number): ACBuilder;
-    dc(_saveDC: number): DCBuilder;
-}
-declare class HalfRollBuilder extends RollBuilder {
-    private readonly innerRoll;
-    constructor(innerRoll: RollBuilder);
-    hasHiddenState(): boolean;
-    get lastConfig(): RollConfig;
-    getSubRollConfigs(): readonly RollConfig[];
-    toExpression(): string;
-    toAST(): ExpressionNode;
-    toPMF(eps?: number): PMF;
-    copy(): HalfRollBuilder;
-}
-declare class MaxOfRollBuilder extends RollBuilder {
-    private readonly innerRoll;
-    private readonly count;
-    private readonly diceCount?;
-    private readonly diceSides?;
-    constructor(innerRoll: RollBuilder, count: number, diceCount?: number | undefined, diceSides?: number | undefined);
-    hasHiddenState(): boolean;
-    get lastConfig(): RollConfig;
-    getSubRollConfigs(): readonly RollConfig[];
-    toExpression(): string;
-    toAST(): ExpressionNode;
-    toPMF(eps?: number): PMF;
-    copy(): MaxOfRollBuilder;
-}
-declare class AlwaysHitBuilder extends RollBuilder {
-    readonly attackConfig: CritConfig;
-    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
-    protected create(configs: readonly RollConfig[]): RollBuilder;
-    onHit(val: number): AttackBuilder;
-    onHit(val: string): AttackBuilder;
-    onHit(val: RollBuilder): AttackBuilder;
-    onHit(count: number, die: RollBuilder): AttackBuilder;
-    onHit(count: number, sides: number): AttackBuilder;
-    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
-    onHit(count: number, sides: number, modifier: number): AttackBuilder;
-    get critThreshold(): number;
-    critOn(critThreshold: number): AlwaysHitBuilder;
-    alwaysCrits(): AlwaysCritBuilder;
-    toExpression(): string;
-    toPMF(): PMF;
-    copy(): AlwaysHitBuilder;
-}
-declare class AlwaysCritBuilder extends RollBuilder {
-    readonly attackConfig: CritConfig & {
-        ac?: number;
-    };
-    readonly fromAlwaysHit: boolean;
-    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig & {
-        ac?: number;
-    }, fromAlwaysHit?: boolean);
-    protected create(configs: readonly RollConfig[]): RollBuilder;
-    onHit(val: number): AttackBuilder;
-    onHit(val: string): AttackBuilder;
-    onHit(val: RollBuilder): AttackBuilder;
-    onHit(count: number, die: RollBuilder): AttackBuilder;
-    onHit(count: number, sides: number): AttackBuilder;
-    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
-    onHit(count: number, sides: number, modifier: number): AttackBuilder;
-    get critThreshold(): number;
-    critOn(critThreshold: number): AlwaysCritBuilder;
-    toExpression(): string;
-    toPMF(): PMF;
-    copy(): AlwaysCritBuilder;
-}
-declare class ParsedRollBuilder extends RollBuilder {
-    private readonly cachedPMF;
-    private readonly originalExpression;
-    constructor(expression: string);
-    hasHiddenState(): boolean;
-    protected create(configs: readonly RollConfig[]): RollBuilder;
-    toPMF(_eps?: number): PMF;
-    toExpression(): string;
-    toAST(): ExpressionNode;
-    copy(): ParsedRollBuilder;
-    doubleDice(): ParsedRollBuilder;
-}
-declare class PooledRollBuilder extends RollBuilder {
-    private readonly baseAST;
-    private readonly baseExpression;
-    constructor(baseAST: ExpressionNode, baseExpression: string, configs?: readonly RollConfig[]);
-    protected create(configs: readonly RollConfig[]): PooledRollBuilder;
-    hasHiddenState(): boolean;
-    d(_sides: number | undefined): RollBuilder;
-    reroll(_value: number): RollBuilder;
-    explode(_count?: number | undefined): RollBuilder;
-    minimum(_val: number | undefined): RollBuilder;
-    bestOf(_count: number | undefined): RollBuilder;
-    keepHighest(_total: number, _count: number): RollBuilder;
-    keepLowest(_total: number, _count: number): RollBuilder;
-    withAdvantage(): RollBuilder;
-    withDisadvantage(): RollBuilder;
-    withElvenAccuracy(): RollBuilder;
-    toAST(): ExpressionNode;
-    toExpression(): string;
-    copy(): PooledRollBuilder;
-    scaleDice(scale: number): RollBuilder;
-    times(count: number): PooledRollBuilder;
-}
-
-type ActionEffect = RollBuilder;
-declare class AttackBuilder implements CheckBuilder {
-    readonly check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder;
-    private readonly hitEffect?;
-    private readonly critEffect?;
-    private readonly missEffect?;
-    constructor(check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder, hitEffect?: ActionEffect | undefined, critEffect?: (ActionEffect | null) | undefined, missEffect?: ActionEffect | undefined);
-    onCrit(val: number): AttackBuilder;
-    onCrit(val: string): AttackBuilder;
-    onCrit(val: RollBuilder): AttackBuilder;
-    onCrit(count: number, die: RollBuilder): AttackBuilder;
-    onCrit(count: number, sides: number): AttackBuilder;
-    onCrit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
-    onCrit(count: number, sides: number, modifier: number): AttackBuilder;
-    onMiss(val: number): AttackBuilder;
-    onMiss(val: string): AttackBuilder;
-    onMiss(val: RollBuilder): AttackBuilder;
-    onMiss(count: number, die: RollBuilder): AttackBuilder;
-    onMiss(count: number, sides: number): AttackBuilder;
-    onMiss(count: number, die: RollBuilder, modifier: number): AttackBuilder;
-    onMiss(count: number, sides: number, modifier: number): AttackBuilder;
-    noCrit(): AttackBuilder;
-    toExpression(): string;
-    resolveProbabilities(check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder, eps?: number): {
-        pSuccess: number;
-        pHit: number;
-        pCrit: number;
-        pMiss: number;
-    };
-    resolve(eps?: number): AttackResolution;
-    toPMF(eps?: number): PMF;
-    get pmf(): PMF;
-    toQuery(eps?: number): DiceQuery;
-}
-
-interface AttackConfig {
-    ac: number;
-    critThreshold: number;
-}
-declare class ACBuilder extends RollBuilder {
-    readonly attackConfig: AttackConfig;
-    constructor(baseRoll: RollBuilder, ac: number, attackConfig?: AttackConfig);
-    onHit(val: number): AttackBuilder;
-    onHit(val: string): AttackBuilder;
-    onHit(val: RollBuilder): AttackBuilder;
-    onHit(count: number, die: RollBuilder): AttackBuilder;
-    onHit(count: number, sides: number): AttackBuilder;
-    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
-    onHit(count: number, sides: number, modifier: number): AttackBuilder;
-    get critThreshold(): number;
-    critOn(threshold: number): ACBuilder;
-    alwaysCrits(): AlwaysCritBuilder;
-    toExpression(): string;
-    toPMF(eps?: number): PMF;
-    copy(): ACBuilder;
-}
-
-declare function d(sides: number | string): RollBuilder;
-declare const d4: RollBuilder;
-declare const d6: RollBuilder;
-declare const d8: RollBuilder;
-declare const d10: RollBuilder;
-declare const d12: RollBuilder;
-declare const d20: RollBuilder;
-declare const hd20: RollBuilder;
-declare const d100: RollBuilder;
-declare const flat: (n: number) => RollBuilder;
-declare const roll: RollFactory;
-declare const builderPMFCache: LRUCache<string, PMF>;
-
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export * from "./ac.js";
+export * from "./attack.js";
+export * from "./dc.js";
+export * from "./factory.js";
+export * from "./roll.js";
+export * from "./save.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/builder/index.ts"],"names":[],"mappings":"AAAA,cAAc,MAAM,CAAC;AACrB,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/builder/index.js

@@ -4092,6 +4092,15 @@ var RollBuilder = class _RollBuilder {
   half() {
     return new HalfRollBuilder(this);
   }
+  /**
+   * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+   * A general, composable form of {@link half} — used to model damage-type resistance
+   * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+   * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+   */
+  scaleResult(numerator, denominator = 1, rounding = "floor") {
+    return new ScaleRollBuilder(this, numerator, denominator, rounding);
+  }
   // Create a "max of N rolls" version of this roll for crit damage with keep operations
   maxOf(count) {
     return new MaxOfRollBuilder(this, count);
@@ -4146,6 +4155,50 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
     return new _HalfRollBuilder(this.innerRoll.copy());
   }
 };
+var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
+  constructor(innerRoll, numerator, denominator = 1, rounding = "floor") {
+    super(0);
+    this.innerRoll = innerRoll;
+    this.numerator = numerator;
+    this.denominator = denominator;
+    this.rounding = rounding;
+  }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
+  get lastConfig() {
+    return this.innerRoll.lastConfig;
+  }
+  getSubRollConfigs() {
+    return this.innerRoll.getSubRollConfigs();
+  }
+  toExpression() {
+    const inner = this.innerRoll.toExpression();
+    if (this.denominator === 1) return `${this.numerator} * (${inner})`;
+    if (this.numerator === 1) return `(${inner}) // ${this.denominator}`;
+    return `(${inner}) * ${this.numerator} // ${this.denominator}`;
+  }
+  toAST() {
+    return {
+      type: "scale",
+      numerator: this.numerator,
+      denominator: this.denominator,
+      rounding: this.rounding,
+      child: this.innerRoll.toAST()
+    };
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _ScaleRollBuilder(
+      this.innerRoll.copy(),
+      this.numerator,
+      this.denominator,
+      this.rounding
+    );
+  }
+};
 var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   constructor(innerRoll, count, diceCount, diceSides) {
     super(0);
@@ -4444,6 +4497,49 @@ var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
     return new _PooledRollBuilder(sumNode, newExpr);
   }
 };
+var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder {
+  constructor(parts) {
+    super(0);
+    this.parts = parts;
+  }
+  hasHiddenState() {
+    return true;
+  }
+  getSubRollConfigs() {
+    return [];
+  }
+  toAST() {
+    return {
+      type: "add",
+      children: this.parts.map((p) => ({
+        node: p.toAST(),
+        sign: 1
+      }))
+    };
+  }
+  toExpression() {
+    const exprs = this.parts.map((p) => p.toExpression()).filter((e) => e && e !== "0");
+    if (exprs.length === 0) return "0";
+    let result = exprs[0];
+    for (let i = 1; i < exprs.length; i++) {
+      const e = exprs[i];
+      result += e.startsWith("-") ? ` - ${e.substring(1)}` : ` + ${e}`;
+    }
+    return result.replace(/\+ -/g, "-");
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _CompositeSumRollBuilder(this.parts.map((p) => p.copy()));
+  }
+};
+function sumRolls(parts) {
+  const meaningful = parts.filter((p) => p !== void 0);
+  if (meaningful.length === 0) return new RollBuilder(0);
+  if (meaningful.length === 1) return meaningful[0];
+  return new CompositeSumRollBuilder(meaningful);
+}
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -4674,6 +4770,11 @@ function resolve(node, eps = defaultEps) {
         if (count === 1) return childPMF;
         return computeMaxOfPMF(childPMF, count, eps);
       }
+      case "scale": {
+        const childPMF = resolve(node.child, eps);
+        const denom = node.denominator === 0 ? 1 : node.denominator;
+        return childPMF.scaleDamage(node.numerator / denom, node.rounding);
+      }
     }
   })();
   builderPMFCache.set(cacheKey, result);
@@ -4745,6 +4846,7 @@ function findDie(node) {
     case "d20Roll":
     case "half":
     case "maxOf":
+    case "scale":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -4929,6 +5031,8 @@ function getASTSignature(node) {
       return `half{ch:${getASTSignature(node.child)}}`;
     case "maxOf":
       return `maxOf{c:${node.count},ch:${getASTSignature(node.child)}}`;
+    case "scale":
+      return `scale{n:${node.numerator},d:${node.denominator},r:${node.rounding},ch:${getASTSignature(node.child)}}`;
     case "add": {
       let constantValue = 0;
       const otherChildrenSigs = [];
@@ -5365,6 +5469,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map