@aura3d/scripting 1.3.3 → 1.4.1

package/src/CulturalBehaviorFixtures.ts

@@ -1,262 +0,0 @@
-export type CulturalCommunicationStyle = "direct" | "balanced" | "indirect";
-export type CulturalPersonalSpace = "close" | "medium" | "distant";
-export type CulturalRelationship = "stranger" | "acquaintance" | "friend" | "family" | "superior" | "subordinate";
-export type ProxemicZone = "intimate" | "personal" | "social" | "public";
-
-export interface CulturalBehaviorFixtureOptions {
-  readonly seed?: number;
-  readonly relationship?: CulturalRelationship;
-  readonly initiatorPosition?: readonly [number, number, number];
-  readonly targetPosition?: readonly [number, number, number];
-  readonly message?: string;
-}
-
-export interface CultureDescriptor {
-  readonly id: string;
-  readonly name: string;
-  readonly individualismScore: number;
-  readonly powerDistanceScore: number;
-  readonly uncertaintyAvoidanceScore: number;
-  readonly communicationStyle: CulturalCommunicationStyle;
-  readonly personalSpacePreference: CulturalPersonalSpace;
-  readonly eyeContactNorm: "low" | "moderate" | "high";
-  readonly greetingStyle: "formal" | "casual" | "bow" | "handshake";
-}
-
-export interface CulturalEntityFixture {
-  readonly id: string;
-  readonly cultureId: string;
-  readonly position: readonly [number, number, number];
-  readonly personalityVariance: number;
-}
-
-export interface CulturalBehaviorFixture {
-  readonly source: "origin-master-cultural-ai-adapted";
-  readonly cultures: readonly CultureDescriptor[];
-  readonly entities: readonly CulturalEntityFixture[];
-  readonly proxemics: {
-    readonly relationship: CulturalRelationship;
-    readonly distanceMeters: number;
-    readonly acceptableDistanceMeters: number;
-    readonly zone: ProxemicZone;
-    readonly comfort: number;
-    readonly approachAllowed: boolean;
-  };
-  readonly communication: {
-    readonly input: string;
-    readonly formatted: string;
-    readonly directness: CulturalCommunicationStyle;
-    readonly formality: "formal" | "neutral" | "informal";
-    readonly audienceAdapted: boolean;
-  };
-  readonly socialNorms: {
-    readonly greetingExpected: string;
-    readonly eyeContactExpected: string;
-    readonly hierarchyAware: boolean;
-    readonly normViolations: readonly string[];
-  };
-  readonly gesture: {
-    readonly id: string;
-    readonly allowed: boolean;
-    readonly intensity: number;
-  };
-  readonly decision: {
-    readonly selectedAction: "approach" | "wait" | "request-distance" | "formal-greeting";
-    readonly score: number;
-    readonly reason: string;
-  };
-  readonly productionReadiness: {
-    readonly proxemicTelemetry: true;
-    readonly communicationStyleTelemetry: true;
-    readonly socialNormTelemetry: true;
-    readonly gestureBoundaryTelemetry: true;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-const collectivistCulture: CultureDescriptor = {
-  id: "collective-formal",
-  name: "Collective Formal Fixture",
-  individualismScore: 0.28,
-  powerDistanceScore: 0.68,
-  uncertaintyAvoidanceScore: 0.74,
-  communicationStyle: "indirect",
-  personalSpacePreference: "distant",
-  eyeContactNorm: "moderate",
-  greetingStyle: "formal"
-};
-
-const directCulture: CultureDescriptor = {
-  id: "direct-pragmatic",
-  name: "Direct Pragmatic Fixture",
-  individualismScore: 0.72,
-  powerDistanceScore: 0.36,
-  uncertaintyAvoidanceScore: 0.42,
-  communicationStyle: "direct",
-  personalSpacePreference: "medium",
-  eyeContactNorm: "high",
-  greetingStyle: "handshake"
-};
-
-export function sampleCulturalBehaviorFixture(options: CulturalBehaviorFixtureOptions = {}): CulturalBehaviorFixture {
-  const seed = normalizeSeed(options.seed ?? 0xc017);
-  const relationship = options.relationship ?? "superior";
-  const initiatorPosition = options.initiatorPosition ?? [0, 0, 0] as const;
-  const targetPosition = options.targetPosition ?? [0.82, 0, 0.34] as const;
-  const initiator: CulturalEntityFixture = {
-    id: "npc-diplomat",
-    cultureId: collectivistCulture.id,
-    position: initiatorPosition,
-    personalityVariance: Number((0.08 + seededUnit(seed) * 0.08).toFixed(3))
-  };
-  const target: CulturalEntityFixture = {
-    id: "player-envoy",
-    cultureId: directCulture.id,
-    position: targetPosition,
-    personalityVariance: Number((0.1 + seededUnit(seed ^ 0x9e37) * 0.06).toFixed(3))
-  };
-  const distanceMeters = distance(initiator.position, target.position);
-  const acceptableDistanceMeters = acceptableDistance(collectivistCulture, relationship);
-  const comfort = comfortLevel(distanceMeters, acceptableDistanceMeters);
-  const approachAllowed = distanceMeters >= acceptableDistanceMeters * 0.7;
-  const formality = determineFormality(collectivistCulture, directCulture, relationship);
-  const input = options.message ?? "Could you help me with the gate plan?";
-  const formatted = formatMessage(input, collectivistCulture, directCulture, relationship, formality);
-  const normViolations = [
-    ...(approachAllowed ? [] : ["personal-space-too-close"]),
-    ...(relationship === "superior" && !formatted.toLowerCase().startsWith("please") ? ["missing-hierarchy-marker"] : [])
-  ];
-  const selectedAction = !approachAllowed
-    ? "request-distance"
-    : formality === "formal"
-      ? "formal-greeting"
-      : "approach";
-  const core = {
-    relationship,
-    distanceMeters,
-    acceptableDistanceMeters,
-    comfort,
-    selectedAction,
-    formatted
-  };
-  return {
-    source: "origin-master-cultural-ai-adapted",
-    cultures: [collectivistCulture, directCulture],
-    entities: [initiator, target],
-    proxemics: {
-      relationship,
-      distanceMeters,
-      acceptableDistanceMeters,
-      zone: zoneForDistance(distanceMeters),
-      comfort,
-      approachAllowed
-    },
-    communication: {
-      input,
-      formatted,
-      directness: collectivistCulture.communicationStyle,
-      formality,
-      audienceAdapted: formatted !== input
-    },
-    socialNorms: {
-      greetingExpected: collectivistCulture.greetingStyle,
-      eyeContactExpected: collectivistCulture.eyeContactNorm,
-      hierarchyAware: relationship === "superior" || relationship === "subordinate",
-      normViolations
-    },
-    gesture: {
-      id: collectivistCulture.greetingStyle === "bow" ? "bow" : "measured-handshake",
-      allowed: comfort >= 0.35,
-      intensity: Number((0.42 + comfort * 0.38).toFixed(3))
-    },
-    decision: {
-      selectedAction,
-      score: Number(((approachAllowed ? 0.52 : 0.18) + comfort * 0.36 + (formality === "formal" ? 0.08 : 0)).toFixed(3)),
-      reason: normViolations.length > 0 ? normViolations.join(",") : "proxemics-and-formality-within-bounds"
-    },
-    productionReadiness: {
-      proxemicTelemetry: true,
-      communicationStyleTelemetry: true,
-      socialNormTelemetry: true,
-      gestureBoundaryTelemetry: true
-    },
-    blockedClaims: [
-      "real cultural modeling certification",
-      "LLM-driven NPC dialogue parity",
-      "Unity Behavior Designer or ML-Agents social AI parity",
-      "Unreal MassAI/SmartObject social simulation parity",
-      "human-subject validated intercultural behavior"
-    ],
-    claimBoundary: "This fixture ports old cultural AI concepts into deterministic proxemics, communication-style, social-norm, gesture, and decision telemetry for runtime evidence. It does not claim validated cultural modeling, generated NPC dialogue, or Unity/Unreal social-AI parity.",
-    hash: stableHash(JSON.stringify(core))
-  };
-}
-
-function acceptableDistance(culture: CultureDescriptor, relationship: CulturalRelationship): number {
-  const base = relationship === "family" ? 0.3 : relationship === "friend" ? 0.6 : relationship === "acquaintance" ? 1.0 : relationship === "superior" || relationship === "subordinate" ? 1.25 : 1.5;
-  const space = culture.personalSpacePreference === "close" ? 0.7 : culture.personalSpacePreference === "distant" ? 1.4 : 1;
-  const individualism = 1 - culture.individualismScore * 0.2;
-  const hierarchy = 1 + culture.powerDistanceScore * 0.15;
-  return Number((base * space * individualism * hierarchy).toFixed(3));
-}
-
-function formatMessage(message: string, speaker: CultureDescriptor, audience: CultureDescriptor, relationship: CulturalRelationship, formality: CulturalBehaviorFixture["communication"]["formality"]): string {
-  let formatted = message.trim();
-  const indirect = speaker.communicationStyle === "indirect" || audience.communicationStyle === "indirect";
-  if (indirect && !/\b(could|would|might)\b/i.test(formatted)) {
-    formatted = `I was wondering if you might ${formatted.charAt(0).toLowerCase()}${formatted.slice(1)}`;
-  }
-  if (formality === "formal") {
-    formatted = formatted.replace(/\bhey\b/gi, "Hello").replace(/\byeah\b/gi, "yes").replace(/\bgonna\b/gi, "going to");
-  }
-  if (relationship === "superior" && !formatted.toLowerCase().startsWith("please")) {
-    formatted = `Please, ${formatted.charAt(0).toLowerCase()}${formatted.slice(1)}`;
-  }
-  return formatted;
-}
-
-function determineFormality(speaker: CultureDescriptor, audience: CultureDescriptor, relationship: CulturalRelationship): CulturalBehaviorFixture["communication"]["formality"] {
-  if (relationship === "superior" || speaker.powerDistanceScore > 0.6 || audience.powerDistanceScore > 0.6) return "formal";
-  if (relationship === "friend" || relationship === "family") return "informal";
-  return "neutral";
-}
-
-function zoneForDistance(distanceMeters: number): ProxemicZone {
-  if (distanceMeters < 0.45) return "intimate";
-  if (distanceMeters < 1.2) return "personal";
-  if (distanceMeters < 3.6) return "social";
-  return "public";
-}
-
-function comfortLevel(distanceMeters: number, acceptableDistanceMeters: number): number {
-  const deviation = Math.abs(distanceMeters - acceptableDistanceMeters);
-  return Number(Math.max(0, 1 - deviation / Math.max(0.001, acceptableDistanceMeters * 0.5)).toFixed(3));
-}
-
-function distance(left: readonly [number, number, number], right: readonly [number, number, number]): number {
-  return Number(Math.hypot(left[0] - right[0], left[1] - right[1], left[2] - right[2]).toFixed(3));
-}
-
-function normalizeSeed(seed: number): number {
-  if (!Number.isInteger(seed) || seed < 0) throw new Error("seed must be a non-negative integer.");
-  return seed >>> 0;
-}
-
-function seededUnit(seed: number): number {
-  let value = seed >>> 0;
-  value ^= value << 13;
-  value ^= value >>> 17;
-  value ^= value << 5;
-  return (value >>> 0) / 0xffffffff;
-}
-
-function stableHash(value: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}

package/src/DecisionTree.ts

@@ -1,162 +0,0 @@
-export type DecisionTreeNodeType = "decision" | "action";
-
-export interface DecisionTreeContext {
-  readonly values?: Record<string, number | boolean | string | undefined>;
-}
-
-export interface DecisionTreeStats {
-  readonly totalNodes: number;
-  readonly decisionNodes: number;
-  readonly actionNodes: number;
-  readonly maxDepth: number;
-  readonly averageActionDepth: number;
-}
-
-export interface DecisionTreeDecision {
-  readonly action: string;
-  readonly path: readonly string[];
-  readonly executed: boolean;
-}
-
-export type DecisionCondition = (context: DecisionTreeContext) => boolean;
-export type DecisionAction = (context: DecisionTreeContext) => void;
-
-export interface DecisionTreeNode {
-  readonly type: DecisionTreeNodeType;
-  readonly name: string;
-  condition?: DecisionCondition;
-  action?: DecisionAction;
-  trueBranch?: DecisionTreeNode;
-  falseBranch?: DecisionTreeNode;
-  parent?: DecisionTreeNode;
-}
-
-export class DecisionTree {
-  private root: DecisionTreeNode | undefined;
-
-  createDecision(name: string, condition: DecisionCondition): DecisionTreeNode {
-    assertName(name);
-    return { type: "decision", name, condition };
-  }
-
-  createAction(name: string, action: DecisionAction = () => undefined): DecisionTreeNode {
-    assertName(name);
-    return { type: "action", name, action };
-  }
-
-  setBranches(node: DecisionTreeNode, trueBranch: DecisionTreeNode, falseBranch: DecisionTreeNode): void {
-    if (node.type !== "decision") throw new Error(`Cannot set branches on action node: ${node.name}`);
-    node.trueBranch = trueBranch;
-    node.falseBranch = falseBranch;
-    trueBranch.parent = node;
-    falseBranch.parent = node;
-  }
-
-  setRoot(node: DecisionTreeNode): void {
-    this.root = node;
-  }
-
-  getRoot(): DecisionTreeNode | undefined {
-    return this.root;
-  }
-
-  decide(context: DecisionTreeContext, maxDepth = 32): DecisionTreeDecision {
-    const action = this.traverse(context, maxDepth);
-    if (!action?.action) return { action: "none", path: this.getTraversalPath(context, maxDepth), executed: false };
-    action.action(context);
-    return { action: action.name, path: this.getTraversalPath(context, maxDepth), executed: true };
-  }
-
-  traverse(context: DecisionTreeContext, maxDepth = 32): DecisionTreeNode | undefined {
-    if (!this.root || maxDepth < 1) return undefined;
-    let current: DecisionTreeNode | undefined = this.root;
-    let depth = 0;
-    while (current && depth < maxDepth) {
-      depth += 1;
-      if (current.type === "action") return current;
-      if (!current.condition) return undefined;
-      current = current.condition(context) ? current.trueBranch : current.falseBranch;
-    }
-    return undefined;
-  }
-
-  getTraversalPath(context: DecisionTreeContext, maxDepth = 32): readonly string[] {
-    if (!this.root || maxDepth < 1) return [];
-    const path: string[] = [];
-    let current: DecisionTreeNode | undefined = this.root;
-    let depth = 0;
-    while (current && depth < maxDepth) {
-      depth += 1;
-      path.push(current.name);
-      if (current.type === "action") break;
-      if (!current.condition) break;
-      current = current.condition(context) ? current.trueBranch : current.falseBranch;
-    }
-    return path;
-  }
-
-  validate(): boolean {
-    return this.root ? validateNode(this.root) : false;
-  }
-
-  getStats(): DecisionTreeStats {
-    if (!this.root) return { totalNodes: 0, decisionNodes: 0, actionNodes: 0, maxDepth: 0, averageActionDepth: 0 };
-    const stats = { totalNodes: 0, decisionNodes: 0, actionNodes: 0, actionDepths: [] as number[] };
-    collectStats(this.root, 0, stats);
-    const maxDepth = stats.actionDepths.length > 0 ? Math.max(...stats.actionDepths) : 0;
-    const averageActionDepth = stats.actionDepths.length > 0
-      ? stats.actionDepths.reduce((sum, depth) => sum + depth, 0) / stats.actionDepths.length
-      : 0;
-    return {
-      totalNodes: stats.totalNodes,
-      decisionNodes: stats.decisionNodes,
-      actionNodes: stats.actionNodes,
-      maxDepth,
-      averageActionDepth: Number(averageActionDepth.toFixed(3))
-    };
-  }
-
-  clone(): DecisionTree {
-    const tree = new DecisionTree();
-    if (this.root) tree.setRoot(cloneNode(this.root));
-    return tree;
-  }
-}
-
-function validateNode(node: DecisionTreeNode): boolean {
-  if (node.type === "action") return typeof node.action === "function";
-  return typeof node.condition === "function" && Boolean(node.trueBranch) && Boolean(node.falseBranch) && validateNode(node.trueBranch!) && validateNode(node.falseBranch!);
-}
-
-function collectStats(
-  node: DecisionTreeNode,
-  depth: number,
-  stats: { totalNodes: number; decisionNodes: number; actionNodes: number; actionDepths: number[] }
-): void {
-  stats.totalNodes += 1;
-  if (node.type === "action") {
-    stats.actionNodes += 1;
-    stats.actionDepths.push(depth);
-    return;
-  }
-  stats.decisionNodes += 1;
-  if (node.trueBranch) collectStats(node.trueBranch, depth + 1, stats);
-  if (node.falseBranch) collectStats(node.falseBranch, depth + 1, stats);
-}
-
-function cloneNode(node: DecisionTreeNode): DecisionTreeNode {
-  const cloned: DecisionTreeNode = { type: node.type, name: node.name, condition: node.condition, action: node.action };
-  if (node.trueBranch) {
-    cloned.trueBranch = cloneNode(node.trueBranch);
-    cloned.trueBranch.parent = cloned;
-  }
-  if (node.falseBranch) {
-    cloned.falseBranch = cloneNode(node.falseBranch);
-    cloned.falseBranch.parent = cloned;
-  }
-  return cloned;
-}
-
-function assertName(name: string): void {
-  if (name.trim().length === 0) throw new Error("Decision tree node name cannot be empty.");
-}

package/src/GOAP.ts

@@ -1,150 +0,0 @@
-export type GOAPValue = string | number | boolean | null;
-export type GOAPStateShape = Record<string, GOAPValue>;
-
-export interface GOAPActionOptions {
-  readonly name: string;
-  readonly cost?: number;
-  readonly preconditions?: GOAPStateShape;
-  readonly effects: GOAPStateShape;
-  readonly enabled?: boolean;
-}
-
-export interface GOAPPlannerOptions {
-  readonly maxIterations?: number;
-  readonly maxPlanLength?: number;
-}
-
-export interface GOAPPlan {
-  readonly valid: boolean;
-  readonly actions: readonly string[];
-  readonly cost: number;
-  readonly nodesExplored: number;
-  readonly finalState: GOAPStateShape;
-}
-
-type PlanNode = {
-  readonly state: WorldState;
-  readonly actions: readonly string[];
-  readonly cost: number;
-};
-
-export class WorldState {
-  private readonly values = new Map<string, GOAPValue>();
-
-  constructor(initial: GOAPStateShape = {}) {
-    for (const [key, value] of Object.entries(initial)) this.values.set(key, value);
-  }
-
-  static from(initial: GOAPStateShape): WorldState {
-    return new WorldState(initial);
-  }
-
-  set(key: string, value: GOAPValue): void {
-    this.values.set(key, value);
-  }
-
-  get(key: string): GOAPValue | undefined {
-    return this.values.get(key);
-  }
-
-  satisfies(goal: WorldState): boolean {
-    return goal.entries().every(([key, value]) => this.values.get(key) === value);
-  }
-
-  matches(shape: GOAPStateShape): boolean {
-    return Object.entries(shape).every(([key, value]) => this.values.get(key) === value);
-  }
-
-  apply(shape: GOAPStateShape): WorldState {
-    const next = this.clone();
-    for (const [key, value] of Object.entries(shape)) next.set(key, value);
-    return next;
-  }
-
-  clone(): WorldState {
-    return new WorldState(this.toObject());
-  }
-
-  entries(): readonly (readonly [string, GOAPValue])[] {
-    return [...this.values.entries()].sort(([left], [right]) => left.localeCompare(right));
-  }
-
-  toObject(): GOAPStateShape {
-    return Object.fromEntries(this.entries());
-  }
-
-  key(): string {
-    return this.entries().map(([key, value]) => `${key}:${String(value)}`).join("|");
-  }
-}
-
-export class GOAPAction {
-  readonly name: string;
-  readonly cost: number;
-  readonly preconditions: GOAPStateShape;
-  readonly effects: GOAPStateShape;
-  enabled: boolean;
-
-  constructor(options: GOAPActionOptions) {
-    this.name = options.name;
-    this.cost = options.cost ?? 1;
-    this.preconditions = options.preconditions ?? {};
-    this.effects = options.effects;
-    this.enabled = options.enabled ?? true;
-    if (!Number.isFinite(this.cost) || this.cost < 0) throw new RangeError("GOAP action cost must be a finite non-negative number.");
-  }
-
-  canRun(state: WorldState): boolean {
-    return this.enabled && state.matches(this.preconditions);
-  }
-
-  apply(state: WorldState): WorldState {
-    return state.apply(this.effects);
-  }
-}
-
-export class GOAPPlanner {
-  private readonly maxIterations: number;
-  private readonly maxPlanLength: number;
-
-  constructor(options: GOAPPlannerOptions = {}) {
-    this.maxIterations = options.maxIterations ?? 128;
-    this.maxPlanLength = options.maxPlanLength ?? 8;
-  }
-
-  plan(current: WorldState, goal: WorldState, actions: readonly GOAPAction[]): GOAPPlan {
-    if (current.satisfies(goal)) {
-      return { valid: true, actions: [], cost: 0, nodesExplored: 0, finalState: current.toObject() };
-    }
-    const enabledActions = actions.filter((action) => action.enabled).sort((left, right) => left.cost - right.cost || left.name.localeCompare(right.name));
-    const open: PlanNode[] = [{ state: current, actions: [], cost: 0 }];
-    const bestCostByState = new Map<string, number>([[current.key(), 0]]);
-    let nodesExplored = 0;
-
-    while (open.length > 0 && nodesExplored < this.maxIterations) {
-      open.sort((left, right) => left.cost - right.cost || left.actions.join(",").localeCompare(right.actions.join(",")));
-      const node = open.shift()!;
-      nodesExplored += 1;
-      if (node.state.satisfies(goal)) {
-        return { valid: true, actions: node.actions, cost: round3(node.cost), nodesExplored, finalState: node.state.toObject() };
-      }
-      if (node.actions.length >= this.maxPlanLength) continue;
-
-      for (const action of enabledActions) {
-        if (!action.canRun(node.state)) continue;
-        const nextState = action.apply(node.state);
-        const nextCost = round3(node.cost + action.cost);
-        const key = nextState.key();
-        if ((bestCostByState.get(key) ?? Number.POSITIVE_INFINITY) <= nextCost) continue;
-        bestCostByState.set(key, nextCost);
-        open.push({ state: nextState, actions: [...node.actions, action.name], cost: nextCost });
-      }
-    }
-
-    return { valid: false, actions: [], cost: 0, nodesExplored, finalState: current.toObject() };
-  }
-}
-
-function round3(value: number): number {
-  return Number(value.toFixed(3));
-}