@alpaca-software/40kdc-data 0.1.0

package/dist/converters/view-selector.js

@@ -0,0 +1,96 @@
+/**
+ * Handles multi-view data for shared units.
+ *
+ * Shared units (e.g., Chaos Land Raider) appear in multiple factions with the
+ * same UUID. Their abilities, models, and weapons tables contain repeated entry
+ * groups — one per faction "view". Views are delimited by the line number
+ * resetting to 1.
+ *
+ * For World Eaters, the correct view is identified by having
+ * "Blessings of Khorne" as a Faction-type ability.
+ */
+/** Split an array of line-numbered entries into view groups by line-number resets. */
+export function splitIntoViews(entries) {
+    const views = [];
+    let current = [];
+    let lastLine = Infinity;
+    for (const entry of entries) {
+        const line = parseInt(entry.line, 10);
+        if (line <= lastLine && current.length > 0) {
+            views.push({ index: views.length, entries: current });
+            current = [];
+        }
+        current.push(entry);
+        lastLine = line;
+    }
+    if (current.length > 0) {
+        views.push({ index: views.length, entries: current });
+    }
+    return views;
+}
+/**
+ * Find the view index for a faction's shared unit.
+ * Identifies the correct view by matching the faction's primary ability name
+ * among the Faction-type abilities in each view.
+ * Returns 0 for faction-exclusive units (single view).
+ */
+export function findFactionViewIndex(abilities, factionAbilityName) {
+    if (abilities.length === 0)
+        return 0;
+    const views = splitIntoViews(abilities);
+    if (views.length === 1)
+        return 0;
+    for (const view of views) {
+        const hasAbility = view.entries.some((a) => a.type === "Faction" &&
+            a.name === factionAbilityName);
+        if (hasAbility)
+            return view.index;
+    }
+    // Some shared units (e.g., SM vehicles used by Grey Knights, or units shared
+    // with Agents of the Imperium) have views with no Faction-type ability.
+    // Use the first such view when no direct match is found.
+    const emptyFactionViews = views.filter((v) => !v.entries.some((a) => a.type === "Faction"));
+    if (emptyFactionViews.length > 0) {
+        return emptyFactionViews[0].index;
+    }
+    throw new Error(`No "${factionAbilityName}" faction ability found in ${views.length} views ` +
+        `for datasheet ${abilities[0]?.datasheet_id}`);
+}
+/** Extract entries for a specific view index from a line-numbered array. */
+export function getViewEntries(entries, viewIndex) {
+    if (entries.length === 0)
+        return [];
+    const views = splitIntoViews(entries);
+    if (viewIndex >= views.length) {
+        throw new Error(`View index ${viewIndex} out of range (${views.length} views available)`);
+    }
+    return views[viewIndex].entries;
+}
+/**
+ * Split points entries (no line field) into views for a shared unit.
+ *
+ * Points entries are ordered by view. For simple cases (1 entry per view),
+ * indexing by viewIndex works. For multi-squad-size units, views are
+ * delimited by the model count resetting (decreasing from prev entry).
+ */
+export function getPointsForView(entries, viewIndex, numViews) {
+    if (numViews <= 1)
+        return entries;
+    // Try splitting by model count resets (decrease signals new view)
+    const views = [[]];
+    for (let i = 0; i < entries.length; i++) {
+        const cur = parseInt(entries[i].models, 10);
+        const prev = i > 0 ? parseInt(entries[i - 1].models, 10) : 0;
+        if (i > 0 && cur <= prev) {
+            views.push([]);
+        }
+        views[views.length - 1].push(entries[i]);
+    }
+    if (viewIndex < views.length) {
+        return views[viewIndex];
+    }
+    // Fallback: evenly divide
+    const perView = Math.ceil(entries.length / numViews);
+    const start = viewIndex * perView;
+    return entries.slice(start, start + perView);
+}

package/dist/converters/weapon-dedup.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Weapon profile merging and cross-unit deduplication.
+ *
+ * Source data splits multi-profile weapons into separate rows using an
+ * en-dash delimiter: "Plasma pistol – Standard" / "Plasma pistol – Supercharge".
+ * These become a single weapon entity with a profiles array.
+ *
+ * Cross-unit dedup: weapons with identical (name, type, all profile stats)
+ * across different units are the same entity, referenced by a shared ID.
+ */
+export interface SourceWargear {
+    datasheet_id: string;
+    line: string;
+    line_in_wargear: string;
+    dice: string;
+    name: string;
+    description: string;
+    range: string;
+    type: string;
+    A: string;
+    BS_WS: string;
+    S: string;
+    AP: string;
+    D: string;
+}
+export interface WeaponProfile {
+    name: string;
+    range: number | "Melee";
+    stats: {
+        A: number | string;
+        BS?: number | null;
+        WS?: number | null;
+        S: number | string;
+        AP: number;
+        D: number | string;
+    };
+    keywords: string[];
+}
+export interface WeaponEntity {
+    id: string;
+    name: string;
+    type: "ranged" | "melee";
+    profiles: WeaponProfile[];
+    game_version: {
+        edition: string;
+        dataslate: string;
+    };
+}
+/**
+ * Merge wargear rows for a single unit into weapon entities,
+ * then deduplicate across all units.
+ */
+export declare function buildWeaponRegistry(allUnitWargear: Map<string, SourceWargear[]>, gameVersion: {
+    edition: string;
+    dataslate: string;
+}): {
+    weapons: WeaponEntity[];
+    /** Maps (datasheetId) → Set of weapon entity IDs for that unit */
+    unitWeaponIds: Map<string, Set<string>>;
+};

package/dist/converters/weapon-dedup.js

@@ -0,0 +1,120 @@
+/**
+ * Weapon profile merging and cross-unit deduplication.
+ *
+ * Source data splits multi-profile weapons into separate rows using an
+ * en-dash delimiter: "Plasma pistol – Standard" / "Plasma pistol – Supercharge".
+ * These become a single weapon entity with a profiles array.
+ *
+ * Cross-unit dedup: weapons with identical (name, type, all profile stats)
+ * across different units are the same entity, referenced by a shared ID.
+ */
+import { nameToId } from "./id-generator.js";
+import { parseRange, parseBSWS, parseStatValue, parseAP, parseWeaponKeywords, } from "./stat-parser.js";
+// EN-DASH (U+2013) and regular hyphen used as profile separators
+const PROFILE_SEPARATOR = /\s*[\u2013\u2014-]\s+/;
+/** Split "Plasma pistol – Standard" into { baseName: "Plasma pistol", profileName: "Standard" } */
+function splitProfileName(fullName) {
+    const parts = fullName.split(PROFILE_SEPARATOR);
+    if (parts.length >= 2) {
+        return {
+            baseName: parts[0].trim(),
+            profileName: parts.slice(1).join(" – ").trim(),
+        };
+    }
+    return { baseName: fullName.trim(), profileName: fullName.trim() };
+}
+/** Build a single weapon profile from a source wargear row. */
+function buildProfile(row, profileName) {
+    const range = parseRange(row.range);
+    const isMelee = row.type === "Melee" || range === "Melee";
+    const stats = {
+        A: parseStatValue(row.A),
+        S: parseStatValue(row.S),
+        AP: parseAP(row.AP),
+        D: parseStatValue(row.D),
+    };
+    if (isMelee) {
+        stats.WS = parseBSWS(row.BS_WS);
+    }
+    else {
+        stats.BS = parseBSWS(row.BS_WS);
+    }
+    return {
+        name: profileName,
+        range,
+        stats,
+        keywords: parseWeaponKeywords(row.description),
+    };
+}
+/** Hash a weapon entity for cross-unit deduplication. */
+function weaponHash(name, type, profiles) {
+    const profileParts = profiles
+        .map((p) => `${p.name}|${p.range}|${JSON.stringify(p.stats)}|${p.keywords.sort().join(",")}`)
+        .sort();
+    return `${name.toLowerCase()}|${type}|${profileParts.join(";")}`;
+}
+/**
+ * Merge wargear rows for a single unit into weapon entities,
+ * then deduplicate across all units.
+ */
+export function buildWeaponRegistry(allUnitWargear, gameVersion) {
+    // Global dedup registry: hash → WeaponEntity
+    const registry = new Map();
+    const unitWeaponIds = new Map();
+    for (const [datasheetId, rows] of allUnitWargear) {
+        const weaponIds = new Set();
+        unitWeaponIds.set(datasheetId, weaponIds);
+        // Group rows by base weapon name for profile merging
+        const groups = new Map();
+        for (const row of rows) {
+            const { baseName, profileName } = splitProfileName(row.name);
+            const key = baseName.toLowerCase();
+            if (!groups.has(key)) {
+                groups.set(key, { baseName, rows: [], profileNames: [] });
+            }
+            const group = groups.get(key);
+            group.rows.push(row);
+            group.profileNames.push(profileName);
+        }
+        for (const [, group] of groups) {
+            const { baseName, rows: groupRows, profileNames } = group;
+            const type = groupRows[0].type === "Melee" ? "melee" : "ranged";
+            // Skip rows with obviously corrupt source data (shifted columns)
+            const validRows = groupRows.filter((row, i) => {
+                const s = parseStatValue(row.S);
+                if (typeof s === "number" && s < 0)
+                    return false;
+                const d = parseStatValue(row.D);
+                if (type === "ranged" && d === 0 && row.D === "")
+                    return false;
+                return true;
+            });
+            if (validRows.length === 0)
+                continue;
+            const validProfileNames = groupRows.map((row, i) => ({ row, name: profileNames[i] }))
+                .filter(({ row }) => validRows.includes(row))
+                .map(({ name }) => name);
+            // If there's only one profile and its name matches the base name, use base name as profile name
+            const profiles = validRows.map((row, i) => {
+                const pName = validRows.length === 1 ? baseName : validProfileNames[i];
+                return buildProfile(row, pName);
+            });
+            const hash = weaponHash(baseName, type, profiles);
+            if (!registry.has(hash)) {
+                const id = nameToId(baseName);
+                registry.set(hash, {
+                    id,
+                    name: baseName,
+                    type: type,
+                    profiles,
+                    game_version: gameVersion,
+                });
+            }
+            weaponIds.add(registry.get(hash).id);
+        }
+    }
+    return {
+        weapons: [...registry.values()],
+        unitWeaponIds,
+    };
+}

package/dist/data/bundle.generated.d.ts

@@ -0,0 +1,3 @@
+import type { RawData } from "./types.js";
+/** The full 40kdc dataset, embedded at build time and parsed once at load. */
+export declare const RAW_DATA: RawData;