@axiapps/gw2-data 0.1.0

package/tests/engine/attributes.test.js

@@ -0,0 +1,252 @@
+"use strict";
+
+const { computeAttributes, computeSlotStats, getExcludedSlots } = require("../../src/engine/attributes");
+
+function makeCtx(overrides = {}) {
+  return {
+    profession: "Warrior",
+    specializations: [],
+    equipment: {
+      slots: {},
+      weapons: {},
+      runes: {},
+      infusions: {},
+      enrichment: null,
+      food: null,
+      utility: null,
+    },
+    gameMode: "pve",
+    underwaterMode: false,
+    activeWeaponSet: 1,
+    skills: {},
+    assumedBoons: null,
+    sigilStacks: null,
+    ...overrides,
+  };
+}
+
+function makeCatalogs(overrides = {}) {
+  return {
+    traitById: new Map(),
+    skillById: new Map(),
+    specializationById: new Map(),
+    runeById: new Map(),
+    foodById: new Map(),
+    utilityById: new Map(),
+    infusionById: new Map(),
+    enrichmentById: new Map(),
+    ...overrides,
+  };
+}
+
+describe("getExcludedSlots", () => {
+  test("excludes aquatic slots in land mode", () => {
+    const excluded = getExcludedSlots(false, 1);
+    expect(excluded.has("breather")).toBe(true);
+    expect(excluded.has("aquatic1")).toBe(true);
+    expect(excluded.has("aquatic2")).toBe(true);
+    expect(excluded.has("head")).toBe(false);
+  });
+
+  test("excludes land weapon slots in land mode for inactive set", () => {
+    const excluded = getExcludedSlots(false, 1);
+    expect(excluded.has("mainhand2")).toBe(true);
+    expect(excluded.has("offhand2")).toBe(true);
+    expect(excluded.has("mainhand1")).toBe(false);
+  });
+
+  test("excludes land-only slots in underwater mode", () => {
+    const excluded = getExcludedSlots(true, 1);
+    expect(excluded.has("head")).toBe(true);
+    expect(excluded.has("mainhand1")).toBe(true);
+    expect(excluded.has("breather")).toBe(false);
+  });
+});
+
+describe("computeSlotStats", () => {
+  test("3-stat combo returns major + minor stats", () => {
+    const result = computeSlotStats("Berserker's", "chest", {}, "pve");
+    expect(result).toEqual([
+      { stat: "Power", value: 141 },
+      { stat: "Precision", value: 101 },
+      { stat: "Ferocity", value: 101 },
+    ]);
+  });
+
+  test("4-stat combo returns 2 major + 2 minor stats", () => {
+    const result = computeSlotStats("Marauder's", "chest", {}, "pve");
+    expect(result).toEqual([
+      { stat: "Power", value: 121 },
+      { stat: "Precision", value: 121 },
+      { stat: "Vitality", value: 66 },
+      { stat: "Ferocity", value: 66 },
+    ]);
+  });
+
+  test("Celestial uses c weight for all stats", () => {
+    const result = computeSlotStats("Celestial", "chest", {}, "pve");
+    expect(result.every((r) => r.value === 66)).toBe(true);
+    expect(result).toHaveLength(9);
+  });
+
+  test("WvW Celestial excludes Expertise and Concentration", () => {
+    const result = computeSlotStats("Celestial", "chest", {}, "wvw");
+    expect(result.find((r) => r.stat === "Expertise")).toBeUndefined();
+    expect(result.find((r) => r.stat === "Concentration")).toBeUndefined();
+    expect(result).toHaveLength(7);
+  });
+
+  test("two-handed weapon uses TWO_HAND_WEIGHTS", () => {
+    const weapons = { mainhand1: "greatsword" };
+    const result = computeSlotStats("Berserker's", "mainhand1", weapons, "pve");
+    expect(result[0]).toEqual({ stat: "Power", value: 251 });
+  });
+});
+
+describe("computeAttributes", () => {
+  test("empty build returns base stats only", () => {
+    const result = computeAttributes(makeCtx(), makeCatalogs());
+    expect(result.base.Power).toBe(1000);
+    expect(result.base.Precision).toBe(1000);
+    expect(result.base.Toughness).toBe(1000);
+    expect(result.base.Vitality).toBe(1000);
+    expect(result.base.Ferocity).toBe(0);
+    expect(result.total.Power).toBe(1000);
+  });
+
+  test("equipment slots contribute to total", () => {
+    const ctx = makeCtx({
+      equipment: { slots: { chest: "Berserker's" }, weapons: {}, runes: {}, infusions: {} },
+    });
+    const result = computeAttributes(ctx, makeCatalogs());
+    expect(result.equipment.Power).toBe(141);
+    expect(result.total.Power).toBe(1141);
+  });
+
+  test("food flat bonuses parsed from buff text", () => {
+    const catalogs = makeCatalogs({
+      foodById: new Map([[100, { name: "Steak", buff: "+100 Power" }]]),
+    });
+    const ctx = makeCtx({ equipment: { slots: {}, weapons: {}, runes: {}, infusions: {}, food: 100 } });
+    const result = computeAttributes(ctx, catalogs);
+    expect(result.food.Power).toBe(100);
+  });
+
+  test("food 'to All Attributes' adds to all stats", () => {
+    const catalogs = makeCatalogs({
+      foodById: new Map([[101, { name: "Feast", buff: "+50 to All Attributes" }]]),
+    });
+    const ctx = makeCtx({ equipment: { slots: {}, weapons: {}, runes: {}, infusions: {}, food: 101 } });
+    const result = computeAttributes(ctx, catalogs);
+    expect(result.food.Power).toBe(50);
+    expect(result.food.Ferocity).toBe(50);
+    expect(result.food.HealingPower).toBe(50);
+  });
+
+  test("rune bonuses are cumulative per piece", () => {
+    const catalogs = makeCatalogs({
+      runeById: new Map([[24836, { name: "Scholar", bonuses: ["+25 Power", "+35 Ferocity", "+50 Power"] }]]),
+    });
+    const ctx = makeCtx({
+      equipment: { slots: {}, weapons: {}, runes: { head: 24836, shoulders: 24836, chest: 24836 }, infusions: {} },
+    });
+    const result = computeAttributes(ctx, catalogs);
+    expect(result.runes.Power).toBe(75);
+    expect(result.runes.Ferocity).toBe(35);
+  });
+
+  test("infusion attributes added", () => {
+    const catalogs = makeCatalogs({
+      infusionById: new Map([[49431, { name: "+5 Power", infixUpgrade: { attributes: [{ attribute: "Power", modifier: 5 }] } }]]),
+    });
+    const ctx = makeCtx({
+      equipment: { slots: {}, weapons: {}, infusions: { chest: [49431, 49431] }, runes: {} },
+    });
+    const result = computeAttributes(ctx, catalogs);
+    expect(result.infusions.Power).toBe(10);
+  });
+
+  test("assumed Might boons add Power and ConditionDamage", () => {
+    const ctx = makeCtx({ assumedBoons: { might: 25 } });
+    const result = computeAttributes(ctx, makeCatalogs());
+    expect(result.boons.Power).toBe(750);
+    expect(result.boons.ConditionDamage).toBe(750);
+  });
+
+  test("derived health uses profession base HP", () => {
+    const ctx = makeCtx({ profession: "Warrior" });
+    const result = computeAttributes(ctx, makeCatalogs());
+    // Warrior base HP = 9212, base Vitality = 1000, health = 9212 + 1000*10 = 19212
+    expect(result.derived.health).toBe(19212);
+  });
+
+  test("derived crit chance formula", () => {
+    const ctx = makeCtx();
+    const result = computeAttributes(ctx, makeCatalogs());
+    // Base precision 1000: critChance = (1000 - 895) / 21 = 5%
+    expect(result.derived.critChance).toBeCloseTo(5, 0);
+  });
+
+  test("derived armor includes weight class defense", () => {
+    const ctx = makeCtx({ profession: "Warrior" });
+    const result = computeAttributes(ctx, makeCatalogs());
+    // Warrior = heavy = 1271 defense, base toughness 1000
+    expect(result.derived.armor).toBe(2271);
+  });
+
+  test("trait conversions applied after base stats", () => {
+    const catalogs = makeCatalogs({
+      traitById: new Map([[500, {
+        id: 500,
+        facts: [{ type: "BuffConversion", source: "Vitality", target: "Power", percent: 10 }],
+      }]]),
+      specializationById: new Map([[4, { id: 4, minorTraits: [] }]]),
+    });
+    const ctx = makeCtx({
+      specializations: [{ id: 4, majorChoices: { 1: 500 } }],
+    });
+    const result = computeAttributes(ctx, catalogs);
+    // base Vitality = 1000, 10% = floor(100) = 100
+    expect(result.conversions.Power).toBe(100);
+    expect(result.total.Power).toBe(1100);
+  });
+
+  test("berserk-conditional trait bonuses only apply when berserkActive", () => {
+    const catalogs = makeCatalogs({
+      traitById: new Map([[2046, {
+        id: 2046,
+        slot: "Minor",
+        description: "Fatal Frenzy",
+        facts: [
+          { type: "AttributeAdjust", target: "Power", value: 150 },
+          { type: "AttributeAdjust", target: "ConditionDamage", value: 300 },
+        ],
+      }]]),
+      specializationById: new Map([[18, { id: 18, minorTraits: [2046] }]]),
+    });
+    const baseCtx = {
+      specializations: [{ id: 18, majorChoices: {} }],
+    };
+
+    // Without berserk: bonuses NOT applied
+    const resultOff = computeAttributes(makeCtx({ ...baseCtx, berserkActive: false }), catalogs);
+    expect(resultOff.traits.Power).toBe(0);
+    expect(resultOff.traits.ConditionDamage).toBe(0);
+
+    // With berserk: bonuses applied
+    const resultOn = computeAttributes(makeCtx({ ...baseCtx, berserkActive: true }), catalogs);
+    expect(resultOn.traits.Power).toBe(150);
+    expect(resultOn.traits.ConditionDamage).toBe(300);
+  });
+
+  test("signet passive buffs added", () => {
+    const ctx = makeCtx({
+      skills: { healId: null, utilityIds: [], eliteId: null },
+      equipment: { slots: {}, weapons: {}, runes: {}, infusions: {} },
+    });
+    // Bane Signet (9093) = +180 Power
+    ctx.skills.utilityIds = [9093];
+    const result = computeAttributes(ctx, makeCatalogs());
+    expect(result.signets.Power).toBe(180);
+  });
+});

package/tests/engine/boons.test.js

@@ -0,0 +1,129 @@
+"use strict";
+
+const { analyzeBoons, isAllyTargeted, normalizeName } = require("../../src/engine/boons");
+
+describe("normalizeName", () => {
+  test("normalizes Blind to Blinded", () => {
+    expect(normalizeName("Blind")).toBe("Blinded");
+  });
+
+  test("normalizes Cripple to Crippled", () => {
+    expect(normalizeName("Cripple")).toBe("Crippled");
+  });
+
+  test("returns unknown names unchanged", () => {
+    expect(normalizeName("Might")).toBe("Might");
+  });
+});
+
+describe("isAllyTargeted", () => {
+  test("returns true when boon name appears in ally sentence", () => {
+    expect(isAllyTargeted("Grant Might to nearby allies.", "Might", [])).toBe(true);
+  });
+
+  test("returns false when boon is in description but not with ally word", () => {
+    expect(isAllyTargeted("Gain Might. Attack enemies.", "Might", [])).toBe(false);
+  });
+
+  test("returns false with no description", () => {
+    expect(isAllyTargeted(null, "Might", [])).toBe(false);
+  });
+
+  test("returns true for generic ally mention when boon not named", () => {
+    expect(isAllyTargeted("Grant boons to allies.", "Fury", [])).toBe(true);
+  });
+
+  test("returns false for unnamed boon when specific boons named with allies", () => {
+    expect(isAllyTargeted("Grant might to allies.", "Fury", ["Might"])).toBe(false);
+  });
+});
+
+describe("analyzeBoons", () => {
+  test("extracts boon from skill with Buff fact", () => {
+    const skills = [{
+      name: "For Great Justice!",
+      description: "Grant Might and Fury to yourself and allies.",
+      icon: "",
+      facts: [
+        { type: "Buff", status: "Might", apply_count: 3, duration: 8 },
+        { type: "Buff", status: "Fury", apply_count: 1, duration: 8 },
+      ],
+    }];
+    const result = analyzeBoons(skills, [], new Map());
+    expect(result.boons.length).toBe(2);
+    expect(result.boons.find((b) => b.name === "Might")).toBeDefined();
+    expect(result.boons.find((b) => b.name === "Fury")).toBeDefined();
+  });
+
+  test("extracts condition from skill", () => {
+    const skills = [{
+      name: "Sword of Justice",
+      description: "Create a Sword of Justice.",
+      icon: "",
+      facts: [{ type: "Buff", status: "Burning", apply_count: 2, duration: 3 }],
+    }];
+    const result = analyzeBoons(skills, [], new Map());
+    expect(result.conditions.length).toBe(1);
+    expect(result.conditions[0].name).toBe("Burning");
+  });
+
+  test("deduplicates by source + stacks + duration + context", () => {
+    const skill = {
+      name: "Skill A", description: "", icon: "",
+      facts: [
+        { type: "Buff", status: "Might", apply_count: 3, duration: 8 },
+        { type: "Buff", status: "Might", apply_count: 3, duration: 8 },
+      ],
+    };
+    const result = analyzeBoons([skill], [], new Map());
+    const might = result.boons.find((b) => b.name === "Might");
+    expect(might.sources).toHaveLength(1);
+  });
+
+  test("handles NoData section context for conditional facts", () => {
+    const skill = {
+      name: "Skill B", description: "", icon: "",
+      facts: [
+        { type: "NoData", text: "On Critical Hit" },
+        { type: "Buff", status: "Fury", apply_count: 1, duration: 4 },
+      ],
+    };
+    const result = analyzeBoons([skill], [], new Map());
+    const fury = result.boons.find((b) => b.name === "Fury");
+    expect(fury.sources[0].context).toBe("On Critical Hit");
+  });
+
+  test("applies Twisted Medicine ally override for Elixir skills", () => {
+    const overrides = new Map([
+      ["trait:2220", { allyTargeted: ["elixir"] }],
+    ]);
+    const skills = [{
+      name: "Elixir B", description: "Drink Elixir B.", icon: "",
+      categories: ["Elixir"],
+      facts: [{ type: "Buff", status: "Fury", apply_count: 1, duration: 5 }],
+    }];
+    const traits = [{ id: 2220, name: "Twisted Medicine", facts: [] }];
+    const result = analyzeBoons(skills, traits, overrides, new Set([2220]));
+    const fury = result.boons.find((b) => b.name === "Fury");
+    expect(fury.sources[0].isAlly).toBe(true);
+  });
+
+  test("sorts boons by display order, conditions alphabetically", () => {
+    const skills = [{
+      name: "Multi", description: "", icon: "",
+      facts: [
+        { type: "Buff", status: "Vigor", apply_count: 1, duration: 5 },
+        { type: "Buff", status: "Aegis", apply_count: 1, duration: 3 },
+        { type: "Buff", status: "Weakness", apply_count: 1, duration: 3 },
+        { type: "Buff", status: "Burning", apply_count: 1, duration: 3 },
+      ],
+    }];
+    const result = analyzeBoons(skills, [], new Map());
+    // Aegis comes before Vigor in GW2 display order
+    const boonNames = result.boons.map((b) => b.name);
+    expect(boonNames.indexOf("Aegis")).toBeLessThan(boonNames.indexOf("Vigor"));
+    // Conditions sorted alphabetically
+    const condNames = result.conditions.map((c) => c.name);
+    expect(condNames).toEqual([...condNames].sort());
+  });
+});

package/tests/engine/combos.test.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const { analyzeCombos } = require("../../src/engine/combos");
+
+describe("analyzeCombos", () => {
+  test("extracts combo field from skill facts", () => {
+    const skills = [{
+      name: "Flame Wall", icon: "", description: "", facts: [
+        { type: "ComboField", field_type: "Fire" },
+        { type: "Time", duration: 5 },
+        { type: "Radius", distance: 240 },
+      ],
+    }];
+    const result = analyzeCombos(skills, []);
+    expect(result.fields).toHaveLength(1);
+    expect(result.fields[0]).toMatchObject({
+      fieldType: "Fire", sourceName: "Flame Wall", duration: 5, radius: 240,
+    });
+  });
+
+  test("extracts combo finisher from skill facts", () => {
+    const skills = [{
+      name: "Mighty Blow", icon: "", description: "", facts: [
+        { type: "ComboFinisher", finisher_type: "Blast", percent: 100 },
+      ],
+    }];
+    const result = analyzeCombos(skills, []);
+    expect(result.finishers).toHaveLength(1);
+    expect(result.finishers[0]).toMatchObject({
+      finisherType: "Blast", sourceName: "Mighty Blow", hitCount: 1, percent: 100,
+    });
+  });
+
+  test("groups multiple finishers of same type on one skill", () => {
+    const skills = [{
+      name: "Whirling Strike", icon: "", description: "", facts: [
+        { type: "ComboFinisher", finisher_type: "Whirl" },
+        { type: "ComboFinisher", finisher_type: "Whirl" },
+        { type: "ComboFinisher", finisher_type: "Whirl" },
+      ],
+    }];
+    const result = analyzeCombos(skills, []);
+    expect(result.finishers).toHaveLength(1);
+    expect(result.finishers[0].hitCount).toBe(3);
+  });
+
+  test("deduplicates fields by (type, sourceName)", () => {
+    const skills = [
+      { name: "Flame Wall", icon: "", description: "", facts: [{ type: "ComboField", field_type: "Fire" }] },
+      { name: "Flame Wall", icon: "", description: "", facts: [{ type: "ComboField", field_type: "Fire" }] },
+    ];
+    const result = analyzeCombos(skills, []);
+    expect(result.fields).toHaveLength(1);
+  });
+
+  test("extracts fields from traits too", () => {
+    const traits = [{
+      name: "Healing Trait", icon: "", description: "", facts: [
+        { type: "ComboField", field_type: "Water" },
+      ],
+    }];
+    const result = analyzeCombos([], traits);
+    expect(result.fields).toHaveLength(1);
+    expect(result.fields[0].fieldType).toBe("Water");
+  });
+
+  test("tracks finisher percent below 100", () => {
+    const skills = [{
+      name: "Leap", icon: "", description: "", facts: [
+        { type: "ComboFinisher", finisher_type: "Leap", percent: 50 },
+      ],
+    }];
+    const result = analyzeCombos(skills, []);
+    expect(result.finishers[0].percent).toBe(50);
+  });
+});