aminus 2.0.0 → 2.0.1

package/README.md

@@ -21,17 +21,14 @@ let ayaka = new StatTable(
 );
 
 const rotation = new Rotation(
-    ["n1", dmg_formula("Cryo", "Normal", 0.84, new StatTable(), 3)],
-    ["n2", dmg_formula("Cryo", "Normal", 0.894, new StatTable(), 2)],
-    ["ca", dmg_formula("Cryo", "Charged", 3.039, new StatTable(), 2)],
-    ["skill", dmg_formula("Cryo", "Skill", 4.07, new StatTable(), 2)],
-    ["burstcuts", dmg_formula("Cryo", "Burst", 1.91, new StatTable(), 19)],
-    ["burstexplosion", dmg_formula("Cryo", "Burst", 2.86, new StatTable(), 1)],
+    ["n1", dmg_formula("Cryo", "Normal", 0.84, 3)],
+    ["n2", dmg_formula("Cryo", "Normal", 0.894, 2)],
+    ["ca", dmg_formula("Cryo", "Charged", 3.039, 2)],
+    ["skill", dmg_formula("Cryo", "Skill", 4.07, 2)],
+    ["burstcuts", dmg_formula("Cryo", "Burst", 1.91, 19)],
+    ["burstexplosion", dmg_formula("Cryo", "Burst", 2.86)],
 );
-let energyRechargeRequirement = 1.30;
-
-ayaka = ayaka.merge(optimalKqmc5ArtifactsStats(ayaka, rotation, energyRechargeRequirement));
-
+ayaka = ayaka.merge(optimalKqmc5ArtifactsStats(ayaka, rotation, 1.30));
 const dps = rotation.execute(ayaka) / 21.0;
 ```
 

package/dist/src/core/artifact-builder.d.ts

@@ -13,6 +13,9 @@ export declare class ArtifactBuilder {
     rolls: Map<[StatType, ArtifactRollQuality, number], number>;
     constraints: Map<[StatType, number], number>;
     rollLimit?: number;
+    private findRollKey;
+    private getConstraint;
+    private addConstraint;
     constructor(flower?: Artifact, feather?: Artifact, sands?: Artifact, goblet?: Artifact, circlet?: Artifact);
     private initConstraints;
     static kqmc(flower?: Artifact, feather?: Artifact, sands?: Artifact, goblet?: Artifact, circlet?: Artifact): ArtifactBuilder;

package/dist/src/core/artifact-builder.js

@@ -4,6 +4,27 @@ import { POSSIBLE_SUB_STATS, rollQualityMultiplier, maxRollsFor, maxRollsForGive
  * Way to build 1-5 artifact and distrubte substats accordingly
  */
 export class ArtifactBuilder {
+    findRollKey(statType, quality, rarity) {
+        for (const key of this.rolls.keys()) {
+            if (key[0] === statType && key[1] === quality && key[2] === rarity) {
+                return key;
+            }
+        }
+        return undefined;
+    }
+    getConstraint(statType, rarity) {
+        let sum = 0;
+        for (const [[stat, r], count] of this.constraints.entries()) {
+            if (stat === statType && r === rarity) {
+                sum += count;
+            }
+        }
+        return sum;
+    }
+    addConstraint(statType, rarity, amount) {
+        const key = [statType, rarity];
+        this.constraints.set(key, amount);
+    }
     //general constructor to building any set of artifacts
     constructor(flower, feather, sands, goblet, circlet) {
         this.rolls = new Map();
@@ -27,9 +48,8 @@ export class ArtifactBuilder {
             ].filter((p) => p !== undefined);
             for (const piece of pieces) {
                 if (piece.main_stat !== stat) {
-                    const key = [stat, piece.rarity];
-                    const current = this.constraints.get(key) || 0;
-                    this.constraints.set(key, current + maxRollsForGiven(piece, stat));
+                    const current = this.getConstraint(stat, piece.rarity);
+                    this.addConstraint(stat, piece.rarity, current + maxRollsForGiven(piece, stat));
                 }
             }
         }
@@ -54,8 +74,8 @@ export class ArtifactBuilder {
         for (const stat of POSSIBLE_SUB_STATS) {
             for (const piece of pieces) {
                 if (piece.main_stat !== stat) {
-                    const key = [stat, piece.rarity];
-                    builder.constraints.set(key, (builder.constraints.get(key) || 0) + 2);
+                    const current = builder.getConstraint(stat, piece.rarity);
+                    builder.addConstraint(stat, piece.rarity, current + 2);
                 }
             }
         }
@@ -65,8 +85,8 @@ export class ArtifactBuilder {
         // Roll 2 of each substat at AVG quality and rollRarity
         for (const stat of POSSIBLE_SUB_STATS) {
             builder.roll(stat, "AVG", rollRarity, 2);
-            const key = [stat, rollRarity];
-            builder.constraints.set(key, (builder.constraints.get(key) || 0) + 2);
+            const current = builder.getConstraint(stat, rollRarity);
+            builder.addConstraint(stat, rollRarity, current + 2);
         }
         return builder;
     }
@@ -172,21 +192,20 @@ export class ArtifactBuilder {
         const current = this.currentRollsForGiven(substatValue, quality, rarity);
         if (current + num > this.substatConstraint(substatValue, rarity))
             throw new Error("Exceeds constraint");
-        const key = [
-            substatValue,
-            quality,
-            rarity,
-        ];
-        this.rolls.set(key, (this.rolls.get(key) || 0) + num);
+        const existingKey = this.findRollKey(substatValue, quality, rarity);
+        if (existingKey) {
+            this.rolls.set(existingKey, (this.rolls.get(existingKey) || 0) + num);
+            return;
+        }
+        const key = [substatValue, quality, rarity];
+        this.rolls.set(key, num);
     }
     unroll(substatValue, quality, rarity, num) {
         if (!isValidSubstatType(substatValue))
             throw new Error("Invalid substat type");
-        const key = [
-            substatValue,
-            quality,
-            rarity,
-        ];
+        const key = this.findRollKey(substatValue, quality, rarity);
+        if (!key)
+            return;
         const current = this.rolls.get(key) || 0;
         if (current >= num) {
             const newValue = current - num;
@@ -202,11 +221,9 @@ export class ArtifactBuilder {
         return Array.from(this.rolls.values()).reduce((sum, v) => sum + v, 0);
     }
     currentRollsForGiven(statType, quality, rarity) {
-        const key = [
-            statType,
-            quality,
-            rarity,
-        ];
+        const key = this.findRollKey(statType, quality, rarity);
+        if (!key)
+            return 0;
         return this.rolls.get(key) || 0;
     }
     maxRolls() {
@@ -222,8 +239,7 @@ export class ArtifactBuilder {
         return pieces.reduce((sum, p) => sum + maxRollsFor(p), 0);
     }
     substatConstraint(statType, rarity) {
-        const key = [statType, rarity];
-        return this.constraints.get(key) || 0;
+        return this.getConstraint(statType, rarity);
     }
     rollsLeft() {
         return this.maxRolls() - this.currentRolls();

package/dist/src/core/artifacts.d.ts

@@ -1,6 +1,5 @@
 import { ArtifactBuilder } from "./artifact-builder";
-import { ArtifactFactory } from "./artifact-factory";
 import { Artifact, ArtifactType } from "./artifact-constants";
 type ArtifactRollQuality = "MAX" | "HIGH" | "MID" | "LOW" | "AVG";
-export { ArtifactBuilder, ArtifactFactory };
+export { ArtifactBuilder };
 export type { Artifact, ArtifactType, ArtifactRollQuality };

package/dist/src/core/artifacts.js

@@ -1,3 +1,2 @@
 import { ArtifactBuilder } from "./artifact-builder";
-import { ArtifactFactory } from "./artifact-factory";
-export { ArtifactBuilder, ArtifactFactory };
+export { ArtifactBuilder };

package/dist/src/core/formulas.d.ts

@@ -8,5 +8,5 @@ declare const def_multiplier: (character_level: number, enemy_level: number, def
 declare const res_multiplier: (enemy_base_resistance: number, resistance_reduction: number) => number;
 declare const amplifier_multiplier: (amplifier: number, elemental_mastery: number, reaction_bonus: number) => number;
 declare const calculate_damage: (element: Element, damage_type: DamageType, scaling: BaseScaling, amplifier: Amplifier, instances: number, motion_value: number, character: StatTable, buffs: StatTable | undefined) => number;
-declare const dmg_formula: (element: Element, damage_type: DamageType, motion_value: number, buffs?: StatTable, instances?: number, scaling?: BaseScaling, amplifier?: Amplifier) => (s: StatTable) => number;
+declare const dmg_formula: (element: Element, damage_type: DamageType, motion_value: number, instances?: number, buffs?: StatTable, scaling?: BaseScaling, amplifier?: Amplifier) => (s: StatTable) => number;
 export { default_damage_formula, avg_crit_multiplier, def_multiplier, res_multiplier, amplifier_multiplier, calculate_damage, total_attack, total_defense, total_health, dmg_formula, };

package/dist/src/core/formulas.js

@@ -196,7 +196,7 @@ const calculate_damage = (element, damage_type, scaling, amplifier, instances, m
     }
     return default_damage_formula(instances, total_base_scaling_stat, motion_value, 1.0, 0.0, avg_crit_multiplier(total), total_dmg_bonus, 0.0, def_multiplier(90, 100, def_reduction, def_ignore), res_multiplier(0.1, resistance_reduction), amp_multiplier);
 };
-const dmg_formula = (element, damage_type, motion_value, buffs = new StatTable(), instances = 1, scaling = "ATK", amplifier = "None") => (s) => {
+const dmg_formula = (element, damage_type, motion_value, instances = 1, buffs = new StatTable(), scaling = "ATK", amplifier = "None") => (s) => {
     const total = s.clone();
     if (buffs) {
         for (const [key, value] of buffs) {

package/dist/src/core/optimizer.d.ts

@@ -1,2 +1,8 @@
 import { StatType, StatTable, Rotation } from "./stat";
-export declare function optimalMainStats(stats: StatTable, rotation: Rotation, getMainStatValue: (stat: StatType) => number): [StatType, StatType, StatType];
+import { Artifact } from "./artifact-constants";
+/** Public API */
+type SubstatDistribution = Map<StatType, number>;
+export declare function optimalMainStats(stats: StatTable, rotation: Rotation): [StatType, StatType, StatType];
+export declare function gradient5StarKqmcArtifactSubstatOptimizer(stats: StatTable, target: Rotation, flower: Artifact | undefined, feather: Artifact | undefined, sands: Artifact | undefined, goblet: Artifact | undefined, circlet: Artifact | undefined, energyRechargeRequirement: number): SubstatDistribution;
+export declare function optimalKqmc5ArtifactsStats(stats: StatTable, target: Rotation, energyRechargeRequirement: number): StatTable;
+export {};

package/dist/src/core/optimizer.js

@@ -1,35 +1,90 @@
 import { StatTable } from "./stat";
-// Constants for possible main stats
-const POSSIBLE_SANDS_STATS = [
-    "HPPercent",
-    "ATKPercent",
-    "DEFPercent",
-    "ElementalMastery",
-    "EnergyRecharge",
-];
-const POSSIBLE_GOBLET_STATS = [
-    "HPPercent",
-    "ATKPercent",
-    "DEFPercent",
-    "ElementalMastery",
-    "PyroDMGBonus",
-    "CryoDMGBonus",
-    "GeoDMGBonus",
-    "DendroDMGBonus",
-    "ElectroDMGBonus",
-    "HydroDMGBonus",
-    "AnemoDMGBonus",
-    "PhysicalDMGBonus",
-];
-const POSSIBLE_CIRCLE_STATS = [
-    "HPPercent",
-    "ATKPercent",
-    "DEFPercent",
-    "ElementalMastery",
-    "CritRate",
-    "CritDMG",
-    "HealingBonus",
-];
+import { POSSIBLE_SANDS_STATS, POSSIBLE_GOBLET_STATS, POSSIBLE_CIRCLE_STATS, POSSIBLE_SUB_STATS, getMainStatValue, } from "./artifact-constants";
+import { ArtifactBuilder } from "./artifact-builder";
+export function optimalMainStats(stats, rotation) {
+    return globalKqmcArtifactMainStatOptimizer(stats, rotation);
+}
+export function gradient5StarKqmcArtifactSubstatOptimizer(stats, target, flower, feather, sands, goblet, circlet, energyRechargeRequirement) {
+    const builder = ArtifactBuilder.kqmc(flower, feather, sands, goblet, circlet);
+    while (true) {
+        const combinedStats = stats.merge(builder.build());
+        if (combinedStats.get("EnergyRecharge") >= energyRechargeRequirement) {
+            break;
+        }
+        if (builder.rollsLeft() <= 0 ||
+            builder.rollsLeftForGiven("EnergyRecharge", "AVG", 5) <= 0) {
+            throw new Error("Energy Recharge requirements cannot be met with substats alone");
+        }
+        builder.roll("EnergyRecharge", "AVG", 5, 1);
+    }
+    const possibleSubsToRoll = new Set(POSSIBLE_SUB_STATS);
+    while (builder.rollsLeft() > 0 && possibleSubsToRoll.size > 0) {
+        let bestSub = "None";
+        let bestValue = Number.NEGATIVE_INFINITY;
+        for (const substat of possibleSubsToRoll) {
+            if (builder.currentRollsForGiven(substat, "AVG", 5) >=
+                builder.substatConstraint(substat, 5)) {
+                continue;
+            }
+            builder.roll(substat, "AVG", 5, 1);
+            const value = target.execute(stats.merge(builder.build()));
+            builder.unroll(substat, "AVG", 5, 1);
+            if (value > bestValue) {
+                bestValue = value;
+                bestSub = substat;
+            }
+        }
+        if (bestSub === "None") {
+            break;
+        }
+        builder.roll(bestSub, "AVG", 5, 1);
+    }
+    const distribution = new Map();
+    for (const [[stat], count] of builder.rolls.entries()) {
+        distribution.set(stat, (distribution.get(stat) || 0) + count);
+    }
+    return distribution;
+}
+export function optimalKqmc5ArtifactsStats(stats, target, energyRechargeRequirement) {
+    const [sandsMain, gobletMain, circletMain] = globalKqmcArtifactMainStatOptimizer(stats, target);
+    const flower = {
+        type: "flower",
+        rarity: 5,
+        level: 20,
+        main_stat: "FlatHP",
+    };
+    const feather = {
+        type: "feather",
+        rarity: 5,
+        level: 20,
+        main_stat: "FlatATK",
+    };
+    const sands = {
+        type: "sands",
+        rarity: 5,
+        level: 20,
+        main_stat: sandsMain,
+    };
+    const goblet = {
+        type: "goblet",
+        rarity: 5,
+        level: 20,
+        main_stat: gobletMain,
+    };
+    const circlet = {
+        type: "circlet",
+        rarity: 5,
+        level: 20,
+        main_stat: circletMain,
+    };
+    const builder = new ArtifactBuilder(flower, feather, sands, goblet, circlet);
+    const optimalSubstats = gradient5StarKqmcArtifactSubstatOptimizer(stats, target, flower, feather, sands, goblet, circlet, energyRechargeRequirement);
+    for (const [stat, count] of optimalSubstats.entries()) {
+        builder.roll(stat, "AVG", 5, count);
+    }
+    return stats.merge(builder.build());
+}
+/** Ecapsulated implementation */
 // Computes gradients of stats based on slopes
 function statGradients(base, target, slopes) {
     const gradients = new Map();
@@ -58,7 +113,7 @@ function reluHeuristic(base, target, slopes) {
     return effectiveSet;
 }
 // Finds best artifact main stat combo for given stats and rotation
-function globalKqmcArtifactMainStatOptimizer(stats, target, getMainStatValue) {
+function globalKqmcArtifactMainStatOptimizer(stats, target) {
     const sandsStats = new Set(POSSIBLE_SANDS_STATS);
     const gobletStats = new Set(POSSIBLE_GOBLET_STATS);
     const circletStats = new Set(POSSIBLE_CIRCLE_STATS);
@@ -95,6 +150,3 @@ function globalKqmcArtifactMainStatOptimizer(stats, target, getMainStatValue) {
     }
     return bestCombo;
 }
-export function optimalMainStats(stats, rotation, getMainStatValue) {
-    return globalKqmcArtifactMainStatOptimizer(stats, rotation, getMainStatValue);
-}

package/dist/src/core/stat.d.ts

@@ -22,7 +22,8 @@ type DamageCompute = (s: StatTable) => number;
 declare const compose: (...funcs: DamageCompute[]) => DamageCompute;
 declare class Rotation {
     actions: [string, DamageCompute][];
-    constructor(actions: [string, DamageCompute][] | DamageCompute[]);
+    constructor(actions: ([string, DamageCompute] | DamageCompute)[]);
+    constructor(...actions: ([string, DamageCompute] | DamageCompute)[]);
     add(action: [string, DamageCompute]): void;
     execute(s: StatTable): number;
 }

package/dist/src/core/stat.js

@@ -148,15 +148,21 @@ const compose = (...funcs) => {
     return (s) => funcs.reduce((acc, fn) => acc + fn(s), 0);
 };
 class Rotation {
-    constructor(actions) {
+    constructor(...args) {
         this.actions = [];
-        if (actions.length > 0 && typeof actions[0] === "function") {
-            for (let compute of actions) {
+        // Support both `new Rotation([...])` and `new Rotation(a, b, c)`.
+        const first = args[0];
+        const isSingleArrayArg = args.length === 1 && Array.isArray(first);
+        const normalized = isSingleArrayArg
+            ? first
+            : args;
+        if (normalized.length > 0 && typeof normalized[0] === "function") {
+            for (let compute of normalized) {
                 this.actions.push(["", compute]);
             }
         }
         else {
-            this.actions = actions;
+            this.actions = normalized;
         }
     }
     add(action) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aminus",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {

package/src/core/formulas.ts

@@ -286,8 +286,8 @@ const dmg_formula =
     element: Element,
     damage_type: DamageType,
     motion_value: number,
-    buffs: StatTable = new StatTable(),
     instances = 1,
+    buffs: StatTable = new StatTable(),
     scaling: BaseScaling = "ATK",
     amplifier: Amplifier = "None",
   ) =>

package/tests/int/damage-calculation.test.ts

@@ -19,17 +19,14 @@ describe("Damage Calculation Integration", () => {
     );
 
     const rotation = new Rotation(
-      ["n1", dmg_formula("Cryo", "Normal", 0.84, new StatTable(), 3)],
-      ["n2", dmg_formula("Cryo", "Normal", 0.894, new StatTable(), 2)],
-      ["ca", dmg_formula("Cryo", "Charged", 3.039, new StatTable(), 2)],
-      ["skill", dmg_formula("Cryo", "Skill", 4.07, new StatTable(), 2)],
-      ["burstcuts", dmg_formula("Cryo", "Burst", 1.91, new StatTable(), 19)],
-      ["burstexplosion", dmg_formula("Cryo", "Burst", 2.86, new StatTable(), 1)],
+      ["n1", dmg_formula("Cryo", "Normal", 0.84, 3)],
+      ["n2", dmg_formula("Cryo", "Normal", 0.894, 2)],
+      ["ca", dmg_formula("Cryo", "Charged", 3.039, 2)],
+      ["skill", dmg_formula("Cryo", "Skill", 4.07, 2)],
+      ["burstcuts", dmg_formula("Cryo", "Burst", 1.91, 19)],
+      ["burstexplosion", dmg_formula("Cryo", "Burst", 2.86)],
     );
-    let energyRechargeRequirement = 1.3;
-
-    ayaka = ayaka.merge(optimalKqmc5ArtifactsStats(ayaka, rotation, energyRechargeRequirement));
-
+    ayaka = ayaka.merge(optimalKqmc5ArtifactsStats(ayaka, rotation, 1.30));
     const dps = rotation.execute(ayaka) / 21.0;
 
     expect(dps).toBeGreaterThan(0);