@aura3d/scripting 1.4.0 → 1.4.2

package/src/BehaviorRegistry.ts

@@ -1,22 +0,0 @@
-import type { Behavior } from "./Behavior";
-
-export type BehaviorFactory<T extends Behavior = Behavior> = () => T;
-
-export class BehaviorRegistry {
-  private readonly factories = new Map<string, BehaviorFactory>();
-
-  register(type: string, factory: BehaviorFactory): void {
-    if (this.factories.has(type)) {
-      throw new Error(`Behavior type already registered: ${type}`);
-    }
-    this.factories.set(type, factory);
-  }
-
-  create(type: string): Behavior {
-    const factory = this.factories.get(type);
-    if (!factory) {
-      throw new Error(`Unknown behavior type: ${type}`);
-    }
-    return factory();
-  }
-}

package/src/BehaviorSystem.ts

@@ -1,103 +0,0 @@
-import type { Behavior, BehaviorPhase } from "./Behavior";
-import type { BehaviorHost } from "./BehaviorHost";
-import { ScriptContext } from "./ScriptContext";
-
-export interface BehaviorError {
-  readonly phase: BehaviorPhase;
-  readonly behavior: Behavior;
-  readonly error: unknown;
-}
-
-export interface BehaviorSystemUpdateOptions {
-  readonly deltaSeconds?: number;
-  readonly fixedDeltaSeconds?: number;
-}
-
-export class BehaviorSystem {
-  readonly errors: BehaviorError[] = [];
-
-  private readonly hosts = new Set<BehaviorHost>();
-  private readonly started = new WeakSet<Behavior>();
-  private readonly services = new Map<string, unknown>();
-
-  registerHost(host: BehaviorHost): void {
-    this.hosts.add(host);
-  }
-
-  unregisterHost(host: BehaviorHost): void {
-    this.hosts.delete(host);
-  }
-
-  setService(name: string, value: unknown): void {
-    this.services.set(name, value);
-  }
-
-  async fixedUpdate(options: BehaviorSystemUpdateOptions = {}): Promise<void> {
-    await this.runPhase("fixed", options);
-  }
-
-  async update(options: BehaviorSystemUpdateOptions = {}): Promise<void> {
-    await this.runStart(options);
-    await this.runPhase("update", options);
-  }
-
-  private async runStart(options: BehaviorSystemUpdateOptions): Promise<void> {
-    for (const host of [...this.hosts]) {
-      if (host.isDestroyed) {
-        this.hosts.delete(host);
-        continue;
-      }
-
-      for (const behavior of host.list()) {
-        if (behavior.enabled === false || this.started.has(behavior)) {
-          continue;
-        }
-        this.started.add(behavior);
-        await this.invoke("start", behavior, host, options);
-      }
-    }
-  }
-
-  private async runPhase(phase: "fixed" | "update", options: BehaviorSystemUpdateOptions): Promise<void> {
-    for (const host of [...this.hosts]) {
-      if (host.isDestroyed) {
-        this.hosts.delete(host);
-        continue;
-      }
-
-      for (const behavior of host.list()) {
-        if (behavior.enabled === false) {
-          continue;
-        }
-        await this.invoke(phase, behavior, host, options);
-      }
-    }
-  }
-
-  private async invoke(
-    phase: BehaviorPhase,
-    behavior: Behavior,
-    host: BehaviorHost,
-    options: BehaviorSystemUpdateOptions
-  ): Promise<void> {
-    const context = new ScriptContext({
-      phase,
-      deltaSeconds: options.deltaSeconds,
-      fixedDeltaSeconds: options.fixedDeltaSeconds,
-      target: host.target,
-      services: this.services
-    });
-
-    try {
-      if (phase === "start") {
-        await behavior.onStart?.(context);
-      } else if (phase === "fixed") {
-        await behavior.onFixedUpdate?.(context);
-      } else if (phase === "update") {
-        await behavior.onUpdate?.(context);
-      }
-    } catch (error) {
-      this.errors.push({ phase, behavior, error });
-    }
-  }
-}

package/src/BehaviorTree.ts

@@ -1,234 +0,0 @@
-export type BehaviorTreeStatus = "success" | "failure" | "running";
-export type BlackboardValue = number | string | boolean | readonly unknown[] | Record<string, unknown> | null | undefined;
-
-export interface BlackboardChange {
-  readonly key: string;
-  readonly value: BlackboardValue;
-  readonly previous: BlackboardValue;
-  readonly version: number;
-}
-
-export interface BehaviorTreeContext {
-  readonly blackboard: Blackboard;
-  readonly deltaSeconds: number;
-  readonly depth: number;
-}
-
-export interface BehaviorTreeTickResult {
-  readonly status: BehaviorTreeStatus;
-  readonly tickCount: number;
-  readonly trace: readonly string[];
-  readonly blackboardVersion: number;
-}
-
-export abstract class BehaviorTreeNode {
-  public status: BehaviorTreeStatus = "failure";
-  public running = false;
-
-  constructor(public readonly name: string) {}
-
-  abstract tick(context: BehaviorTreeContext): BehaviorTreeStatus;
-
-  reset(): void {
-    this.status = "failure";
-    this.running = false;
-  }
-}
-
-export class Blackboard {
-  private readonly values = new Map<string, { readonly value: BlackboardValue; readonly version: number }>();
-  private readonly changes: BlackboardChange[] = [];
-  private localVersion = 0;
-
-  constructor(public readonly parent?: Blackboard) {}
-
-  get version(): number {
-    return this.localVersion;
-  }
-
-  set(key: string, value: BlackboardValue): void {
-    const previous = this.get(key);
-    this.localVersion += 1;
-    this.values.set(key, { value, version: this.localVersion });
-    this.changes.push({ key, value, previous, version: this.localVersion });
-  }
-
-  get<T extends BlackboardValue = BlackboardValue>(key: string, fallback?: T): T {
-    const local = this.values.get(key);
-    if (local) return local.value as T;
-    if (this.parent?.has(key)) return this.parent.get<T>(key, fallback);
-    return fallback as T;
-  }
-
-  has(key: string): boolean {
-    return this.values.has(key) || this.parent?.has(key) === true;
-  }
-
-  snapshot(): Record<string, BlackboardValue> {
-    const inherited = this.parent?.snapshot() ?? {};
-    return { ...inherited, ...Object.fromEntries([...this.values].map(([key, entry]) => [key, entry.value])) };
-  }
-
-  changeLog(): readonly BlackboardChange[] {
-    return [...this.changes];
-  }
-}
-
-export class BehaviorAction extends BehaviorTreeNode {
-  constructor(name: string, private readonly action: (context: BehaviorTreeContext) => BehaviorTreeStatus) {
-    super(name);
-  }
-
-  tick(context: BehaviorTreeContext): BehaviorTreeStatus {
-    this.running = true;
-    this.status = this.action(context);
-    if (this.status !== "running") this.running = false;
-    return this.status;
-  }
-}
-
-export class BehaviorCondition extends BehaviorTreeNode {
-  constructor(name: string, private readonly condition: (context: BehaviorTreeContext) => boolean) {
-    super(name);
-  }
-
-  tick(context: BehaviorTreeContext): BehaviorTreeStatus {
-    this.status = this.condition(context) ? "success" : "failure";
-    return this.status;
-  }
-}
-
-export class BehaviorSequence extends BehaviorTreeNode {
-  private currentIndex = 0;
-
-  constructor(name: string, public readonly children: readonly BehaviorTreeNode[]) {
-    super(name);
-  }
-
-  tick(context: BehaviorTreeContext): BehaviorTreeStatus {
-    this.running = true;
-    while (this.currentIndex < this.children.length) {
-      const child = this.children[this.currentIndex]!;
-      const status = child.tick({ ...context, depth: context.depth + 1 });
-      if (status === "failure") {
-        this.reset();
-        return "failure";
-      }
-      if (status === "running") {
-        this.status = "running";
-        return "running";
-      }
-      this.currentIndex += 1;
-    }
-    this.reset();
-    this.status = "success";
-    return "success";
-  }
-
-  override reset(): void {
-    super.reset();
-    this.currentIndex = 0;
-    for (const child of this.children) child.reset();
-  }
-}
-
-export class BehaviorSelector extends BehaviorTreeNode {
-  private currentIndex = 0;
-
-  constructor(name: string, public readonly children: readonly BehaviorTreeNode[]) {
-    super(name);
-  }
-
-  tick(context: BehaviorTreeContext): BehaviorTreeStatus {
-    this.running = true;
-    while (this.currentIndex < this.children.length) {
-      const child = this.children[this.currentIndex]!;
-      const status = child.tick({ ...context, depth: context.depth + 1 });
-      if (status === "success") {
-        this.reset();
-        return "success";
-      }
-      if (status === "running") {
-        this.status = "running";
-        return "running";
-      }
-      this.currentIndex += 1;
-    }
-    this.reset();
-    this.status = "failure";
-    return "failure";
-  }
-
-  override reset(): void {
-    super.reset();
-    this.currentIndex = 0;
-    for (const child of this.children) child.reset();
-  }
-}
-
-export class BehaviorTree {
-  private tickCounter = 0;
-  private lastTrace: string[] = [];
-
-  constructor(public readonly root: BehaviorTreeNode, public readonly blackboard = new Blackboard()) {}
-
-  tick(deltaSeconds: number): BehaviorTreeTickResult {
-    this.tickCounter += 1;
-    this.lastTrace = [];
-    const status = this.tickNode(this.root, { blackboard: this.blackboard, deltaSeconds, depth: 0 });
-    return {
-      status,
-      tickCount: this.tickCounter,
-      trace: [...this.lastTrace],
-      blackboardVersion: this.blackboard.version
-    };
-  }
-
-  reset(): void {
-    this.root.reset();
-    this.lastTrace = [];
-    this.tickCounter = 0;
-  }
-
-  private tickNode(node: BehaviorTreeNode, context: BehaviorTreeContext): BehaviorTreeStatus {
-    const status = node.tick({
-      ...context,
-      blackboard: new TracingBlackboard(context.blackboard, (key, value) => {
-        this.lastTrace.push(`${node.name}:${key}=${String(value)}`);
-      })
-    });
-    this.lastTrace.push(`${node.name}:${status}`);
-    return status;
-  }
-}
-
-class TracingBlackboard extends Blackboard {
-  constructor(private readonly target: Blackboard, private readonly onSet: (key: string, value: BlackboardValue) => void) {
-    super();
-  }
-
-  override get version(): number {
-    return this.target.version;
-  }
-
-  override set(key: string, value: BlackboardValue): void {
-    this.target.set(key, value);
-    this.onSet(key, value);
-  }
-
-  override get<T extends BlackboardValue = BlackboardValue>(key: string, fallback?: T): T {
-    return this.target.get(key, fallback);
-  }
-
-  override has(key: string): boolean {
-    return this.target.has(key);
-  }
-
-  override snapshot(): Record<string, BlackboardValue> {
-    return this.target.snapshot();
-  }
-
-  override changeLog(): readonly BlackboardChange[] {
-    return this.target.changeLog();
-  }
-}

package/src/CloudServiceFixtures.ts

@@ -1,225 +0,0 @@
-export type CloudFixtureServiceStatus = "offline-cache" | "queued" | "synced" | "simulated-match" | "blocked";
-
-export interface CloudServiceFixtureOptions {
-  readonly seed?: number;
-  readonly playerId?: string;
-  readonly score?: number;
-  readonly offlineMode?: boolean;
-  readonly sessionSeconds?: number;
-}
-
-export interface CloudServiceFixture {
-  readonly source: "origin-master-cloud-services-adapted";
-  readonly services: {
-    readonly authentication: {
-      readonly provider: "guest";
-      readonly authenticated: false;
-      readonly offlineUserId: string;
-      readonly tokenIssued: false;
-      readonly status: CloudFixtureServiceStatus;
-    };
-    readonly cloudSave: {
-      readonly saveId: "runtime-progress";
-      readonly version: number;
-      readonly checksum: string;
-      readonly queuedUploads: number;
-      readonly conflictResolution: "last-write-wins" | "merge" | "manual";
-      readonly status: CloudFixtureServiceStatus;
-    };
-    readonly achievements: {
-      readonly unlocked: readonly string[];
-      readonly inProgress: readonly { readonly id: string; readonly progress: number }[];
-      readonly totalPoints: number;
-      readonly status: CloudFixtureServiceStatus;
-    };
-    readonly leaderboard: {
-      readonly id: "runtime-score";
-      readonly score: number;
-      readonly rank: number;
-      readonly timeFrame: "daily" | "weekly" | "all-time";
-      readonly cachedEntries: number;
-      readonly status: CloudFixtureServiceStatus;
-    };
-    readonly remoteConfig: {
-      readonly activated: true;
-      readonly abTestGroup: "control" | "variant-a" | "variant-b";
-      readonly parameterCount: number;
-      readonly difficultyScale: number;
-      readonly eventMultiplier: number;
-      readonly status: CloudFixtureServiceStatus;
-    };
-    readonly matchmaking: {
-      readonly queue: "casual-runtime";
-      readonly region: "local";
-      readonly ticketId: string;
-      readonly estimatedWaitMs: number;
-      readonly matchedPlayers: number;
-      readonly status: CloudFixtureServiceStatus;
-    };
-    readonly contentDelivery: {
-      readonly manifestId: "runtime-content";
-      readonly assetCount: number;
-      readonly cacheHits: number;
-      readonly integrityHashes: readonly string[];
-      readonly status: CloudFixtureServiceStatus;
-    };
-  };
-  readonly productionReadiness: {
-    readonly cloudServiceTelemetry: true;
-    readonly offlineQueueTelemetry: true;
-    readonly remoteConfigTelemetry: true;
-    readonly leaderboardTelemetry: true;
-    readonly matchmakingTelemetry: true;
-    readonly contentDeliveryTelemetry: true;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-export function sampleCloudServiceFixture(options: CloudServiceFixtureOptions = {}): CloudServiceFixture {
-  const seed = normalizeSeed(options.seed ?? 0xc10d);
-  const playerId = normalizePlayerId(options.playerId ?? "external-parity-runtime-player");
-  const score = positiveInteger(options.score ?? 12_400, "score");
-  const sessionSeconds = positiveInteger(options.sessionSeconds ?? 180, "sessionSeconds");
-  const offlineMode = options.offlineMode ?? true;
-  const abTestGroup = seededChoice(seed, ["control", "variant-a", "variant-b"] as const);
-  const difficultyScale = Number((0.86 + seededUnit(seed ^ 0x55a5) * 0.24).toFixed(3));
-  const eventMultiplier = Number((1 + Math.min(0.5, sessionSeconds / 1800)).toFixed(3));
-  const version = 3 + Math.floor(seededUnit(seed ^ 0x911) * 6);
-  const savePayload = JSON.stringify({ playerId, score, sessionSeconds, version });
-  const cloudSaveChecksum = stableHash(savePayload);
-  const achievements = [
-    { id: "first-run", points: 10, progress: 1 },
-    { id: "collector", points: 25, progress: Math.min(1, score / 20_000) },
-    { id: "speed-clear", points: 50, progress: Math.min(1, sessionSeconds <= 240 ? 1 : 240 / sessionSeconds) }
-  ] as const;
-  const unlocked = achievements.filter((achievement) => achievement.progress >= 1).map((achievement) => achievement.id);
-  const inProgress = achievements.filter((achievement) => achievement.progress < 1).map((achievement) => ({
-    id: achievement.id,
-    progress: Number(achievement.progress.toFixed(3))
-  }));
-  const rank = Math.max(1, Math.round(5000 / Math.max(1, score / 500)));
-  const integrityHashes = [
-    stableHash(`runtime-content:${seed}:arena`),
-    stableHash(`runtime-content:${seed}:hero`),
-    stableHash(`runtime-content:${seed}:config`)
-  ] as const;
-  const status: CloudFixtureServiceStatus = offlineMode ? "offline-cache" : "queued";
-  const fixture: Omit<CloudServiceFixture, "hash"> = {
-    source: "origin-master-cloud-services-adapted",
-    services: {
-      authentication: {
-        provider: "guest",
-        authenticated: false,
-        offlineUserId: `guest-${stableHash(playerId).slice(0, 6)}`,
-        tokenIssued: false,
-        status
-      },
-      cloudSave: {
-        saveId: "runtime-progress",
-        version,
-        checksum: cloudSaveChecksum,
-        queuedUploads: offlineMode ? 1 : 0,
-        conflictResolution: "last-write-wins",
-        status: offlineMode ? "queued" : "synced"
-      },
-      achievements: {
-        unlocked,
-        inProgress,
-        totalPoints: achievements.filter((achievement) => achievement.progress >= 1).reduce((sum, achievement) => sum + achievement.points, 0),
-        status
-      },
-      leaderboard: {
-        id: "runtime-score",
-        score,
-        rank,
-        timeFrame: "weekly",
-        cachedEntries: 5 + Math.floor(seededUnit(seed ^ 0x7717) * 8),
-        status
-      },
-      remoteConfig: {
-        activated: true,
-        abTestGroup,
-        parameterCount: 4,
-        difficultyScale,
-        eventMultiplier,
-        status
-      },
-      matchmaking: {
-        queue: "casual-runtime",
-        region: "local",
-        ticketId: `ticket-${stableHash(`${playerId}:${score}`).slice(0, 8)}`,
-        estimatedWaitMs: Math.round(1500 + seededUnit(seed ^ 0x4d47) * 3000),
-        matchedPlayers: 2,
-        status: "simulated-match"
-      },
-      contentDelivery: {
-        manifestId: "runtime-content",
-        assetCount: integrityHashes.length,
-        cacheHits: offlineMode ? integrityHashes.length : Math.max(1, integrityHashes.length - 1),
-        integrityHashes,
-        status
-      }
-    },
-    productionReadiness: {
-      cloudServiceTelemetry: true,
-      offlineQueueTelemetry: true,
-      remoteConfigTelemetry: true,
-      leaderboardTelemetry: true,
-      matchmakingTelemetry: true,
-      contentDeliveryTelemetry: true
-    },
-    blockedClaims: [
-      "real cloud authentication backend",
-      "production cloud-save conflict resolution",
-      "hosted CDN/content-delivery parity",
-      "real multiplayer matchmaking service",
-      "Unity Gaming Services parity",
-      "Unreal Online Services parity",
-      "privacy/compliance/security certification"
-    ],
-    claimBoundary: "This fixture ports old cloud-service concepts into deterministic local telemetry. It does not contact a backend, issue real auth tokens, upload saves, submit leaderboards, run CDN delivery, create multiplayer matches, or claim Unity Gaming Services or Unreal Online Services parity."
-  };
-  return {
-    ...fixture,
-    hash: stableHash(JSON.stringify(fixture))
-  };
-}
-
-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 normalizePlayerId(playerId: string): string {
-  const trimmed = playerId.trim();
-  if (trimmed.length === 0) throw new Error("playerId must not be empty.");
-  return trimmed;
-}
-
-function positiveInteger(value: number, name: string): number {
-  if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer.`);
-  return value;
-}
-
-function seededChoice<T>(seed: number, values: readonly T[]): T {
-  return values[Math.min(values.length - 1, Math.floor(seededUnit(seed) * values.length))] as T;
-}
-
-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");
-}