@its-not-rocket-science/ananke 0.1.0

package/dist/src/crafting/workshops.d.ts

@@ -0,0 +1,61 @@
+import type { Q } from "../units.js";
+import type { Recipe } from "./recipes.js";
+/** Facility level tiers with associated bonuses. */
+export type FacilityLevel = "crude" | "basic" | "advanced" | "master";
+/** Workshop type definition. */
+export interface WorkshopType {
+    id: string;
+    name: string;
+    requiredFacilityLevel: FacilityLevel;
+    toolBonus_Q: Q;
+    timeReduction_Q: Q;
+    qualityBonus_Q: Q;
+}
+/** Workshop instance at a specific location. */
+export interface WorkshopInstance {
+    typeId: string;
+    locationId: string;
+    facilityLevel: FacilityLevel;
+    availableTools: Map<string, Q>;
+}
+/** Combined workshop bonuses for a specific recipe. */
+export interface WorkshopBonus {
+    toolBonus_Q: Q;
+    timeReduction_Q: Q;
+    qualityBonus_Q: Q;
+}
+/** Facility level definitions with numeric tier. */
+export declare const FACILITY_LEVELS: Record<FacilityLevel, {
+    tier: number;
+    name: string;
+}>;
+export declare const WORKSHOP_TYPES: WorkshopType[];
+/**
+ * Get combined workshop bonuses for a specific recipe.
+ * Takes into account workshop type, facility level, and available tools.
+ */
+export declare function getWorkshopBonus(workshop: WorkshopInstance, recipe: Recipe): WorkshopBonus;
+/**
+ * Validate workshop requirements for a recipe.
+ * Returns list of missing tool categories and facility level insufficiency.
+ */
+export declare function validateWorkshopRequirements(workshop: WorkshopInstance, recipe: Recipe): {
+    missingTools: string[];
+    facilityLevelInsufficient: boolean;
+};
+/**
+ * Upgrade workshop facility level if resources are available.
+ * Returns success and new workshop instance (or same if failed).
+ */
+export declare function upgradeWorkshop(workshop: WorkshopInstance, resources: Map<string, number>, // resource itemId -> quantity consumed
+targetLevel: FacilityLevel): {
+    success: boolean;
+    upgradedWorkshop: WorkshopInstance;
+    consumedResources: Map<string, number>;
+};
+/** Create a new workshop instance with default tools. */
+export declare function createWorkshop(typeId: string, locationId: string, facilityLevel?: FacilityLevel, initialTools?: Map<string, Q>): WorkshopInstance | undefined;
+/** Get workshop type by ID. */
+export declare function getWorkshopTypeById(id: string): WorkshopType | undefined;
+/** Get all workshop types that can be used at a given facility level. */
+export declare function getWorkshopTypesForLevel(facilityLevel: FacilityLevel): WorkshopType[];

package/dist/src/crafting/workshops.js

@@ -0,0 +1,170 @@
+// src/crafting/workshops.ts — Phase 61: Workshop System
+//
+// Workshop types with tiered bonuses, facility levels, and tool requirements.
+// Deterministic bonuses applied to crafting resolution.
+import { SCALE, q, clampQ } from "../units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Facility level definitions with numeric tier. */
+export const FACILITY_LEVELS = {
+    crude: { tier: 1, name: "Crude" },
+    basic: { tier: 2, name: "Basic" },
+    advanced: { tier: 3, name: "Advanced" },
+    master: { tier: 4, name: "Master" },
+};
+/** Default tool quality for missing tools. */
+const DEFAULT_TOOL_QUALITY_Q = q(0.30);
+// ── Workshop Type Catalogue ───────────────────────────────────────────────────
+export const WORKSHOP_TYPES = [
+    {
+        id: "forge",
+        name: "Forge",
+        requiredFacilityLevel: "crude",
+        toolBonus_Q: q(0.20),
+        timeReduction_Q: q(0.95),
+        qualityBonus_Q: q(1.05),
+    },
+    {
+        id: "carpentry",
+        name: "Carpentry Workshop",
+        requiredFacilityLevel: "basic",
+        toolBonus_Q: q(0.15),
+        timeReduction_Q: q(0.90),
+        qualityBonus_Q: q(1.03),
+    },
+    {
+        id: "tailor",
+        name: "Tailor's Workshop",
+        requiredFacilityLevel: "basic",
+        toolBonus_Q: q(0.10),
+        timeReduction_Q: q(0.92),
+        qualityBonus_Q: q(1.02),
+    },
+    {
+        id: "smithy",
+        name: "Smithy",
+        requiredFacilityLevel: "advanced",
+        toolBonus_Q: q(0.30),
+        timeReduction_Q: q(0.85),
+        qualityBonus_Q: q(1.10),
+    },
+    {
+        id: "alchemist",
+        name: "Alchemist's Laboratory",
+        requiredFacilityLevel: "advanced",
+        toolBonus_Q: q(0.25),
+        timeReduction_Q: q(0.88),
+        qualityBonus_Q: q(1.08),
+    },
+    {
+        id: "artificer",
+        name: "Artificer's Workshop",
+        requiredFacilityLevel: "master",
+        toolBonus_Q: q(0.40),
+        timeReduction_Q: q(0.80),
+        qualityBonus_Q: q(1.20),
+    },
+];
+// ── Workshop Operations ───────────────────────────────────────────────────────
+/**
+ * Get combined workshop bonuses for a specific recipe.
+ * Takes into account workshop type, facility level, and available tools.
+ */
+export function getWorkshopBonus(workshop, recipe) {
+    const workshopType = WORKSHOP_TYPES.find(wt => wt.id === workshop.typeId);
+    if (!workshopType) {
+        // No bonus if workshop type unknown
+        return { toolBonus_Q: q(0), timeReduction_Q: q(1.0), qualityBonus_Q: q(1.0) };
+    }
+    // Facility level multiplier: higher tier amplifies bonuses
+    const tier = FACILITY_LEVELS[workshop.facilityLevel].tier;
+    const facilityMul = 1.0 + (tier - 1) * 0.1; // 10% per tier
+    // Tool bonus: average quality of tools required by recipe
+    let totalToolQuality = 0;
+    let toolCount = 0;
+    for (const toolReq of recipe.toolRequirements) {
+        const toolQ = workshop.availableTools.get(toolReq.toolCategory) ?? DEFAULT_TOOL_QUALITY_Q;
+        totalToolQuality += toolQ;
+        toolCount++;
+    }
+    const avgToolQuality = toolCount > 0 ? totalToolQuality / toolCount : DEFAULT_TOOL_QUALITY_Q;
+    const toolBonus_Q = clampQ(Math.round(workshopType.toolBonus_Q * avgToolQuality / SCALE.Q * facilityMul), q(0), q(0.50));
+    // Time reduction: facility level reduces time further
+    const timeReduction_Q = clampQ(Math.round(workshopType.timeReduction_Q * SCALE.Q / facilityMul), q(0.50), q(1.0));
+    // Quality bonus: facility level increases quality
+    const qualityBonus_Q = clampQ(Math.round(workshopType.qualityBonus_Q * facilityMul), q(1.0), q(1.30));
+    return { toolBonus_Q, timeReduction_Q, qualityBonus_Q };
+}
+/**
+ * Validate workshop requirements for a recipe.
+ * Returns list of missing tool categories and facility level insufficiency.
+ */
+export function validateWorkshopRequirements(workshop, recipe) {
+    const workshopType = WORKSHOP_TYPES.find(wt => wt.id === workshop.typeId);
+    const missingTools = [];
+    const facilityLevelInsufficient = workshopType
+        ? FACILITY_LEVELS[workshop.facilityLevel].tier < FACILITY_LEVELS[workshopType.requiredFacilityLevel].tier
+        : true;
+    // Check each required tool category exists in workshop with sufficient quality
+    for (const toolReq of recipe.toolRequirements) {
+        const toolQ = workshop.availableTools.get(toolReq.toolCategory) ?? q(0);
+        const requiredQ = toolReq.minQuality_Q ?? DEFAULT_TOOL_QUALITY_Q;
+        if (toolQ < requiredQ) {
+            missingTools.push(toolReq.toolCategory);
+        }
+    }
+    return { missingTools, facilityLevelInsufficient };
+}
+/**
+ * Upgrade workshop facility level if resources are available.
+ * Returns success and new workshop instance (or same if failed).
+ */
+export function upgradeWorkshop(workshop, resources, // resource itemId -> quantity consumed
+targetLevel) {
+    const currentTier = FACILITY_LEVELS[workshop.facilityLevel].tier;
+    const targetTier = FACILITY_LEVELS[targetLevel].tier;
+    if (targetTier <= currentTier) {
+        return { success: false, upgradedWorkshop: workshop, consumedResources: new Map() };
+    }
+    // TODO: check resource requirements based on workshop type and tier difference
+    // For now, assume upgrade always succeeds
+    const upgradedWorkshop = {
+        ...workshop,
+        facilityLevel: targetLevel,
+    };
+    // Consume resources (placeholder)
+    const consumedResources = new Map();
+    // Example: consume 10 units of "material_wood" per tier step
+    const tierSteps = targetTier - currentTier;
+    consumedResources.set("material_wood", 10 * tierSteps);
+    return { success: true, upgradedWorkshop, consumedResources };
+}
+// ── Workshop Creation ─────────────────────────────────────────────────────────
+/** Create a new workshop instance with default tools. */
+export function createWorkshop(typeId, locationId, facilityLevel = "crude", initialTools) {
+    const workshopType = WORKSHOP_TYPES.find(wt => wt.id === typeId);
+    if (!workshopType)
+        return undefined;
+    // Ensure facility level meets minimum requirement
+    const requiredTier = FACILITY_LEVELS[workshopType.requiredFacilityLevel].tier;
+    const actualTier = FACILITY_LEVELS[facilityLevel].tier;
+    if (actualTier < requiredTier) {
+        // Downgrade to required level
+        facilityLevel = workshopType.requiredFacilityLevel;
+    }
+    return {
+        typeId,
+        locationId,
+        facilityLevel,
+        availableTools: initialTools ?? new Map(),
+    };
+}
+// ── Utility Functions ────────────────────────────────────────────────────────
+/** Get workshop type by ID. */
+export function getWorkshopTypeById(id) {
+    return WORKSHOP_TYPES.find(wt => wt.id === id);
+}
+/** Get all workshop types that can be used at a given facility level. */
+export function getWorkshopTypesForLevel(facilityLevel) {
+    const tier = FACILITY_LEVELS[facilityLevel].tier;
+    return WORKSHOP_TYPES.filter(wt => FACILITY_LEVELS[wt.requiredFacilityLevel].tier <= tier);
+}

package/dist/src/debug.d.ts

@@ -0,0 +1,86 @@
+import type { WorldState } from "./sim/world.js";
+import type { Vec3 } from "./sim/vec3.js";
+import type { Q } from "./units.js";
+import type { TraceEvent } from "./sim/trace.js";
+/**
+ * Per-entity motion state — position, velocity, and facing direction.
+ * Suitable for overlaying movement arrows in a host renderer.
+ * Includes dead entities (last-known position before death).
+ */
+export interface MotionVector {
+    entityId: number;
+    teamId: number;
+    position_m: Vec3;
+    velocity_mps: Vec3;
+    /** Facing direction from ActionState.facingDirQ (fixed-point unit vector). */
+    facing: Vec3;
+}
+/**
+ * Extract per-entity motion vectors from the current world state.
+ * Call once per tick after stepWorld to get the latest motion snapshot.
+ */
+export declare function extractMotionVectors(world: WorldState): MotionVector[];
+/**
+ * A resolved melee hit — energy delivered to a specific body region.
+ * Derived from TraceKinds.Attack events.
+ */
+export interface HitTraceEntry {
+    tick: number;
+    attackerId: number;
+    targetId: number;
+    region: string;
+    energy_J: number;
+    blocked: boolean;
+    parried: boolean;
+    shieldBlocked: boolean;
+    armoured: boolean;
+}
+/**
+ * A resolved projectile hit — energy at impact for a specific body region.
+ * Derived from TraceKinds.ProjectileHit events where hit === true.
+ */
+export interface ProjectileHitEntry {
+    tick: number;
+    shooterId: number;
+    targetId: number;
+    region: string;
+    distance_m: number;
+    energyAtImpact_J: number;
+}
+export interface HitTraceResult {
+    meleeHits: HitTraceEntry[];
+    projectileHits: ProjectileHitEntry[];
+}
+/**
+ * Extract melee and projectile hit data from a flat trace event array.
+ * Pass events accumulated by CollectingTrace for a span of ticks.
+ * Only confirmed hits (blocked=false or energy>0 for melee; hit=true for projectiles)
+ * are included — missed shots and full blocks are omitted.
+ */
+export declare function extractHitTraces(events: TraceEvent[]): HitTraceResult;
+/**
+ * Per-entity condition snapshot for heatmap visualisation.
+ * All values are fixed-point (Q range 0–10000 unless noted).
+ */
+export interface ConditionSample {
+    entityId: number;
+    teamId: number;
+    position_m: Vec3;
+    /** Psychological fear level (0 = calm, q(1.0) = maximum fear). */
+    fearQ: Q;
+    /** Physiological shock (0 = none, q(1.0) = catastrophic). */
+    shock: Q;
+    /** Consciousness level (q(1.0) = fully alert, q(0) = unconscious). */
+    consciousness: Q;
+    /** Cumulative fluid loss (0 = none, q(1.0) = fatal). */
+    fluidLoss: Q;
+    dead: boolean;
+}
+/**
+ * Extract per-entity condition state from the current world state.
+ * Includes dead entities (position = last known position before death).
+ * To sample condition at any past tick, call replayTo(tick) first:
+ *   const past = replayTo(replay, tick, ctx);
+ *   const samples = extractConditionSamples(past);
+ */
+export declare function extractConditionSamples(world: WorldState): ConditionSample[];

package/dist/src/debug.js

@@ -0,0 +1,76 @@
+// src/debug.ts
+//
+// Phase 13 — Visual Debug Layer
+//
+// Pure data-extraction functions. No rendering, no kernel changes.
+// Each function transforms WorldState or TraceEvent[] into a structured
+// snapshot that a host renderer can consume directly.
+import { TraceKinds } from "./sim/kinds.js";
+/**
+ * Extract per-entity motion vectors from the current world state.
+ * Call once per tick after stepWorld to get the latest motion snapshot.
+ */
+export function extractMotionVectors(world) {
+    return world.entities.map(e => ({
+        entityId: e.id,
+        teamId: e.teamId,
+        position_m: e.position_m,
+        velocity_mps: e.velocity_mps,
+        facing: e.action.facingDirQ,
+    }));
+}
+/**
+ * Extract melee and projectile hit data from a flat trace event array.
+ * Pass events accumulated by CollectingTrace for a span of ticks.
+ * Only confirmed hits (blocked=false or energy>0 for melee; hit=true for projectiles)
+ * are included — missed shots and full blocks are omitted.
+ */
+export function extractHitTraces(events) {
+    const meleeHits = [];
+    const projectileHits = [];
+    for (const ev of events) {
+        if (ev.kind === TraceKinds.Attack) {
+            meleeHits.push({
+                tick: ev.tick,
+                attackerId: ev.attackerId,
+                targetId: ev.targetId,
+                region: ev.region,
+                energy_J: ev.energy_J,
+                blocked: ev.blocked,
+                parried: ev.parried,
+                shieldBlocked: ev.shieldBlocked,
+                armoured: ev.armoured,
+            });
+        }
+        else if (ev.kind === TraceKinds.ProjectileHit && ev.hit && ev.region !== undefined) {
+            projectileHits.push({
+                tick: ev.tick,
+                shooterId: ev.shooterId,
+                targetId: ev.targetId,
+                region: ev.region,
+                distance_m: ev.distance_m,
+                energyAtImpact_J: ev.energyAtImpact_J,
+            });
+        }
+    }
+    return { meleeHits, projectileHits };
+}
+/**
+ * Extract per-entity condition state from the current world state.
+ * Includes dead entities (position = last known position before death).
+ * To sample condition at any past tick, call replayTo(tick) first:
+ *   const past = replayTo(replay, tick, ctx);
+ *   const samples = extractConditionSamples(past);
+ */
+export function extractConditionSamples(world) {
+    return world.entities.map(e => ({
+        entityId: e.id,
+        teamId: e.teamId,
+        position_m: e.position_m,
+        fearQ: e.condition.fearQ ?? 0,
+        shock: e.injury.shock,
+        consciousness: e.injury.consciousness,
+        fluidLoss: e.injury.fluidLoss,
+        dead: e.injury.dead,
+    }));
+}

package/dist/src/derive.d.ts

@@ -0,0 +1,21 @@
+import { Q } from "./units.js";
+import type { IndividualAttributes, EnergyState } from "./types.js";
+import type { Loadout } from "./equipment.js";
+import { type CarryRules } from "./equipment.js";
+export interface MovementCaps {
+    maxSprintSpeed_mps: number;
+    maxAcceleration_mps2: number;
+    jumpHeight_m: number;
+}
+export interface DeriveContext {
+    tractionCoeff: Q;
+    carryRules?: CarryRules;
+}
+/** Fraction of reserve energy that can be spent on a single jump (~0.0283). */
+export declare const JUMP_ENERGY_FRACTION: number;
+export declare function derivePeakForceEff_N(a: IndividualAttributes): number;
+export declare function deriveMaxAcceleration_mps2(a: IndividualAttributes, tractionCoeff: Q): number;
+export declare function deriveMaxSprintSpeed_mps(a: IndividualAttributes): number;
+export declare function deriveJumpHeight_m(a: IndividualAttributes, reserveSpend_J: number): number;
+export declare function deriveMovementCaps(a: IndividualAttributes, loadout: Loadout, ctx: DeriveContext): MovementCaps;
+export declare function stepEnergyAndFatigue(a: IndividualAttributes, state: EnergyState, loadout: Loadout, demandedPower_W: number, dt_s: number, ctx: DeriveContext): void;

package/dist/src/derive.js

@@ -0,0 +1,88 @@
+import { SCALE, q, clampQ, qMul, mulDiv, cbrtQ, sqrtQ, G_mps2 } from "./units.js";
+import { computeEncumbrance, deriveArmourProfile, DEFAULT_CARRY_RULES } from "./equipment.js";
+/** Fraction of reserve energy that can be spent on a single jump (~0.0283). */
+export const JUMP_ENERGY_FRACTION = q(0.0283);
+export function derivePeakForceEff_N(a) {
+    const F0 = a.performance.peakForce_N;
+    const controlFactor = q(0.7) + qMul(q(0.3), a.control.controlQuality);
+    const combined = qMul(a.morphology.actuatorScale, controlFactor);
+    return mulDiv(F0, combined, SCALE.Q);
+}
+export function deriveMaxAcceleration_mps2(a, tractionCoeff) {
+    const m = Math.max(1, a.morphology.mass_kg);
+    // normalForce ~ m*g. Use g~9.81 and keep deterministic:
+    const normalForce_N_scaled = mulDiv(m, G_mps2 * SCALE.N, SCALE.mps2); // scaled N
+    const tractionLimit_N = mulDiv(normalForce_N_scaled, tractionCoeff, SCALE.Q);
+    const F_eff = derivePeakForceEff_N(a);
+    const usable_N = Math.min(F_eff, tractionLimit_N);
+    // a = F/m
+    return mulDiv(usable_N, SCALE.kg * SCALE.mps2, m * SCALE.N);
+}
+export function deriveMaxSprintSpeed_mps(a) {
+    const m = Math.max(1, a.morphology.mass_kg);
+    const P = a.performance.peakPower_W;
+    const p2m_Q = mulDiv(P * SCALE.Q, SCALE.kg, m); // Q
+    const c = cbrtQ(Math.max(1, p2m_Q));
+    const reachSqrt = sqrtQ(a.morphology.reachScale);
+    const controlFactor = q(0.6) + qMul(q(0.4), a.control.controlQuality);
+    const K = q(2.86);
+    const mult = qMul(qMul(qMul(qMul(K, c), reachSqrt), controlFactor), a.performance.conversionEfficiency);
+    return mulDiv(mult, SCALE.mps, SCALE.Q);
+}
+export function deriveJumpHeight_m(a, reserveSpend_J) {
+    const m = Math.max(1, a.morphology.mass_kg);
+    const Euse = Math.min(a.performance.reserveEnergy_J, reserveSpend_J);
+    const controlFactor = q(0.7) + qMul(q(0.3), a.control.controlQuality);
+    const Eeff = mulDiv(mulDiv(Euse, a.performance.conversionEfficiency, SCALE.Q), controlFactor, SCALE.Q);
+    // h = E/(m*g)
+    // force_real = m * g   where m = mass_real (kg), g = G_mps2 / SCALE.mps2
+    const force_real = mulDiv(m, G_mps2, SCALE.mps2 * SCALE.kg); // integer Newtons
+    return mulDiv(Eeff, SCALE.m, Math.max(1, force_real));
+}
+export function deriveMovementCaps(a, loadout, ctx) {
+    const carryRules = ctx.carryRules ?? DEFAULT_CARRY_RULES;
+    const { penalties } = computeEncumbrance(a, loadout, carryRules);
+    const armour = deriveArmourProfile(loadout);
+    const speedMul = qMul(penalties.speedMul, armour.mobilityMul);
+    const accelMul = qMul(penalties.accelMul, armour.mobilityMul);
+    const jumpMul = qMul(penalties.jumpMul, armour.mobilityMul);
+    const baseV = deriveMaxSprintSpeed_mps(a);
+    const baseA = deriveMaxAcceleration_mps2(a, ctx.tractionCoeff);
+    const baseH = deriveJumpHeight_m(a, Math.trunc(a.performance.reserveEnergy_J * JUMP_ENERGY_FRACTION / SCALE.Q));
+    return {
+        maxSprintSpeed_mps: mulDiv(baseV, speedMul, SCALE.Q),
+        maxAcceleration_mps2: mulDiv(baseA, accelMul, SCALE.Q),
+        jumpHeight_m: mulDiv(baseH, jumpMul, SCALE.Q),
+    };
+}
+export function stepEnergyAndFatigue(a, state, loadout, demandedPower_W, dt_s, ctx) {
+    const carryRules = ctx.carryRules ?? DEFAULT_CARRY_RULES;
+    const { penalties } = computeEncumbrance(a, loadout, carryRules);
+    const armour = deriveArmourProfile(loadout);
+    const demandMul = qMul(penalties.energyDemandMul, armour.fatigueMul);
+    const P = mulDiv(demandedPower_W, demandMul, SCALE.Q);
+    const dt = dt_s;
+    const E_need = mulDiv(P, dt, SCALE.s);
+    const cont = a.performance.continuousPower_W;
+    const P_sustain = Math.min(P, cont);
+    const E_sustain = mulDiv(P_sustain, dt, SCALE.s);
+    const E_excess = Math.max(0, E_need - E_sustain);
+    const eff = Math.max(1, a.performance.conversionEfficiency);
+    const E_reserveDrain = mulDiv(E_excess * SCALE.Q, 1, eff);
+    state.reserveEnergy_J = Math.max(0, state.reserveEnergy_J - E_reserveDrain);
+    // Phase 2B: regen — surplus continuous power replenishes reserve.
+    // Rate = surplus_W × dt × recoveryRate × 0.40 (40 % aerobic-to-reserve conversion).
+    // Calibration: at idle (80 W demand, 200 W cont) → 120 W surplus →
+    //   120 × 0.05 s × 1.0 × 0.40 = 2.4 J/tick ≈ 2 J/tick (integer floor).
+    const surplus_W = Math.max(0, cont - P);
+    if (surplus_W > 0) {
+        const regenBase_J = mulDiv(surplus_W, dt, SCALE.s);
+        const regen_J = mulDiv(mulDiv(regenBase_J, a.resilience.recoveryRate, SCALE.Q), q(0.40), SCALE.Q);
+        state.reserveEnergy_J = Math.min(a.performance.reserveEnergy_J, state.reserveEnergy_J + regen_J);
+    }
+    const cap = Math.max(1, a.performance.reserveEnergy_J);
+    const stepFrac_Q = mulDiv(E_reserveDrain * SCALE.Q, 1, cap);
+    const k = q(0.15);
+    const delta = qMul(qMul(k, stepFrac_Q), a.resilience.fatigueRate);
+    state.fatigue = clampQ((state.fatigue + delta), 0, SCALE.Q);
+}

package/dist/src/describe.d.ts

@@ -0,0 +1,29 @@
+import type { IndividualAttributes } from "./types.js";
+export type Tier = 1 | 2 | 3 | 4 | 5 | 6;
+export interface AttributeRating {
+    tier: Tier;
+    label: string;
+    comparison: string;
+    value: string;
+}
+export interface CharacterDescription {
+    stature: string;
+    mass: string;
+    strength: AttributeRating;
+    explosivePower: AttributeRating;
+    endurance: AttributeRating;
+    stamina: AttributeRating;
+    reactionTime: AttributeRating;
+    coordination: AttributeRating;
+    balance: AttributeRating;
+    precision: AttributeRating;
+    painTolerance: AttributeRating;
+    toughness: AttributeRating;
+    concussionResistance: AttributeRating;
+    visionRange: string;
+    hearingRange: string;
+    decisionSpeed: AttributeRating;
+}
+export declare function describeCharacter(attrs: IndividualAttributes): CharacterDescription;
+export declare function formatCharacterSheet(desc: CharacterDescription): string;
+export declare function formatOneLine(desc: CharacterDescription): string;