@donut-games/engine 0.1.0

package/dist/index.js

@@ -0,0 +1,1158 @@
+// ../core/src/event-emitter.ts
+var EventEmitter = class {
+  /** Map of event names to their registered handler functions. */
+  handlerMap = /* @__PURE__ */ new Map();
+  /**
+   * Registers a handler for the specified event.
+   * @param eventName - The name of the event to listen for.
+   * @param handler - The function to call when the event is emitted.
+   * @returns A subscription that can be used to unsubscribe.
+   */
+  on(eventName, handler) {
+    if (!this.handlerMap.has(eventName)) {
+      this.handlerMap.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.handlerMap.get(eventName).add(handler);
+    return {
+      unsubscribe: () => {
+        this.off(eventName, handler);
+      }
+    };
+  }
+  /**
+   * Removes a previously registered handler for the specified event.
+   * @param eventName - The name of the event.
+   * @param handler - The handler function to remove.
+   */
+  off(eventName, handler) {
+    const handlers = this.handlerMap.get(eventName);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlerMap.delete(eventName);
+      }
+    }
+  }
+  /**
+   * Registers a handler that will be called at most once for the specified event.
+   * @param eventName - The name of the event to listen for.
+   * @param handler - The function to call when the event is emitted.
+   * @returns A subscription that can be used to unsubscribe.
+   */
+  once(eventName, handler) {
+    const wrappedHandler = (...arguments_) => {
+      this.off(eventName, wrappedHandler);
+      handler(...arguments_);
+    };
+    return this.on(eventName, wrappedHandler);
+  }
+  /**
+   * Emits an event, calling all registered handlers with the provided arguments.
+   * @param eventName - The name of the event to emit.
+   * @param arguments_ - Arguments to pass to the event handlers.
+   */
+  emit(eventName, ...arguments_) {
+    const handlers = this.handlerMap.get(eventName);
+    if (handlers) {
+      for (const handler of [...handlers]) {
+        handler(...arguments_);
+      }
+    }
+  }
+};
+
+// ../core/src/component.ts
+var Component = class {
+  /** The entity that owns this component, if any. */
+  owner;
+  /** Optional list of component types that must be present on the entity. */
+  dependencies;
+  /**
+   * Serializes this component's state to a plain object.
+   * @returns A record of serializable key-value pairs.
+   */
+  serialize() {
+    return {};
+  }
+  /**
+   * Restores this component's state from a serialized object.
+   * @param _data - The serialized data to restore from.
+   */
+  deserialize(_data) {
+  }
+};
+
+// ../core/src/entity.ts
+var Entity = class _Entity {
+  /** Auto-incrementing counter for unique entity identifiers. */
+  static nextIdentifier = 1;
+  /** The unique numeric identifier for this entity. */
+  identifier;
+  /** The display name of this entity. */
+  name;
+  /** Map of component constructors to component instances for O(1) lookup. */
+  componentMap = /* @__PURE__ */ new Map();
+  /** Set of tags associated with this entity. */
+  tagSet = /* @__PURE__ */ new Set();
+  /** Whether this entity is active and should be processed by systems. */
+  isActive = true;
+  /** The parent entity in the hierarchy, if any. */
+  parent;
+  /** Child entities in the hierarchy. */
+  children = [];
+  /** Internal event emitter for composition-based event delegation. */
+  eventEmitter = new EventEmitter();
+  constructor(options) {
+    this.identifier = _Entity.nextIdentifier++;
+    this.name = options?.name ?? `Entity${this.identifier}`;
+  }
+  /**
+   * Registers a handler for the specified event.
+   * @param eventName - The name of the event to listen for.
+   * @param handler - The function to call when the event is emitted.
+   * @returns A subscription that can be used to unsubscribe.
+   */
+  on(eventName, handler) {
+    return this.eventEmitter.on(eventName, handler);
+  }
+  /**
+   * Removes a previously registered handler for the specified event.
+   * @param eventName - The name of the event.
+   * @param handler - The handler function to remove.
+   */
+  off(eventName, handler) {
+    this.eventEmitter.off(eventName, handler);
+  }
+  /**
+   * Registers a handler that will be called at most once for the specified event.
+   * @param eventName - The name of the event to listen for.
+   * @param handler - The function to call when the event is emitted.
+   * @returns A subscription that can be used to unsubscribe.
+   */
+  once(eventName, handler) {
+    return this.eventEmitter.once(eventName, handler);
+  }
+  /**
+   * Emits an event, calling all registered handlers with the provided arguments.
+   * @param eventName - The name of the event to emit.
+   * @param arguments_ - Arguments to pass to the event handlers.
+   */
+  emit(eventName, ...arguments_) {
+    this.eventEmitter.emit(eventName, ...arguments_);
+  }
+  /**
+   * Adds a component to this entity.
+   * Sets the component's owner, calls its onAdd hook, and emits 'componentadded'.
+   * @param component - The component instance to add.
+   * @returns The added component for chaining.
+   */
+  addComponent(component) {
+    const constructor = component.constructor;
+    component.owner = this;
+    this.componentMap.set(constructor, component);
+    if (component.onAdd) {
+      component.onAdd(this);
+    }
+    this.emit("componentadded", component);
+    return component;
+  }
+  /**
+   * Removes a component of the specified type from this entity.
+   * Calls the component's onRemove hook and emits 'componentremoved'.
+   * @param componentType - The constructor of the component type to remove.
+   * @param _force - Reserved for future use.
+   */
+  removeComponent(componentType, _force) {
+    const component = this.componentMap.get(componentType);
+    if (component) {
+      this.componentMap.delete(componentType);
+      if (component.onRemove) {
+        component.onRemove(this);
+      }
+      component.owner = void 0;
+      this.emit("componentremoved", component);
+    }
+  }
+  /**
+   * Retrieves a component of the specified type from this entity.
+   * @param componentType - The constructor of the component type to retrieve.
+   * @returns The component instance, or undefined if not found.
+   */
+  get(componentType) {
+    return this.componentMap.get(componentType);
+  }
+  /**
+   * Checks whether this entity has a component of the specified type.
+   * @param componentType - The constructor of the component type to check for.
+   * @returns True if the component is present.
+   */
+  has(componentType) {
+    return this.componentMap.has(componentType);
+  }
+  /**
+   * Adds a tag to this entity.
+   * @param tag - The tag string to add.
+   */
+  addTag(tag) {
+    this.tagSet.add(tag);
+    this.emit("tagadded", tag);
+  }
+  /**
+   * Checks whether this entity has the specified tag.
+   * @param tag - The tag string to check for.
+   * @returns True if the tag is present.
+   */
+  hasTag(tag) {
+    return this.tagSet.has(tag);
+  }
+  /**
+   * Removes a tag from this entity.
+   * @param tag - The tag string to remove.
+   */
+  removeTag(tag) {
+    this.tagSet.delete(tag);
+    this.emit("tagremoved", tag);
+  }
+  /**
+   * Adds a child entity to this entity's hierarchy.
+   * @param entity - The child entity to add.
+   */
+  addChild(entity) {
+    entity.parent = this;
+    this.children.push(entity);
+  }
+  /**
+   * Removes a child entity from this entity's hierarchy.
+   * @param entity - The child entity to remove.
+   */
+  removeChild(entity) {
+    const index = this.children.indexOf(entity);
+    if (index !== -1) {
+      this.children.splice(index, 1);
+      entity.parent = void 0;
+    }
+  }
+  /**
+   * Marks this entity as inactive and emits the 'kill' event.
+   */
+  kill() {
+    this.isActive = false;
+    this.emit("kill");
+  }
+};
+
+// ../core/src/observable.ts
+var Observable = class {
+  /** The registered listeners that will be called on each notify. */
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Subscribes a listener to this observable.
+   * @param listener - The function to call each time a value is emitted.
+   * @returns A subscription that can be used to unsubscribe the listener.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return {
+      unsubscribe: () => {
+        this.listeners.delete(listener);
+      }
+    };
+  }
+  /**
+   * Emits a value to all subscribed listeners.
+   * Intended for internal use by the producer that owns the observable.
+   * @param value - The value to emit.
+   */
+  notify(value) {
+    for (const listener of [...this.listeners]) {
+      listener(value);
+    }
+  }
+};
+
+// ../core/src/query.ts
+var Query = class {
+  /** The resolved query parameters. */
+  parameters;
+  /** The set of entities currently matching this query. */
+  matchedEntities = /* @__PURE__ */ new Set();
+  /** Emits entities when they transition from non-matching to matching this query. */
+  entityAdded$ = new Observable();
+  /** Emits entities when they transition from matching to non-matching this query. */
+  entityRemoved$ = new Observable();
+  /**
+   * Creates a new query from either an array of required component types or a full QueryParameters object.
+   * @param parameters - Component constructor array or full query parameters.
+   */
+  constructor(parameters) {
+    if (Array.isArray(parameters)) {
+      this.parameters = { components: { all: parameters } };
+    } else {
+      this.parameters = parameters;
+    }
+  }
+  /** Returns a readonly array of all entities currently matching this query. */
+  get entities() {
+    return [...this.matchedEntities];
+  }
+  /**
+   * Tests whether a given entity matches this query's criteria.
+   * @param entity - The entity to test.
+   * @returns True if the entity matches all criteria.
+   */
+  matches(entity) {
+    const { components, tags } = this.parameters;
+    if (components?.all) {
+      for (const componentType of components.all) {
+        if (!entity.has(componentType)) return false;
+      }
+    }
+    if (components?.any) {
+      let hasAny = false;
+      for (const componentType of components.any) {
+        if (entity.has(componentType)) {
+          hasAny = true;
+          break;
+        }
+      }
+      if (!hasAny) return false;
+    }
+    if (components?.not) {
+      for (const componentType of components.not) {
+        if (entity.has(componentType)) return false;
+      }
+    }
+    if (tags?.all) {
+      for (const tag of tags.all) {
+        if (!entity.hasTag(tag)) return false;
+      }
+    }
+    if (tags?.any) {
+      let hasAny = false;
+      for (const tag of tags.any) {
+        if (entity.hasTag(tag)) {
+          hasAny = true;
+          break;
+        }
+      }
+      if (!hasAny) return false;
+    }
+    if (tags?.not) {
+      for (const tag of tags.not) {
+        if (entity.hasTag(tag)) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Adds an entity to the matched set unconditionally. Called by the query manager
+   * when it has already determined the entity matches. Fires entityAdded$ on transition.
+   * @param entity - The entity to add.
+   */
+  addEntity(entity) {
+    if (!this.matchedEntities.has(entity)) {
+      this.matchedEntities.add(entity);
+      this.entityAdded$.notify(entity);
+    }
+  }
+  /**
+   * Removes an entity from the matched set. Fires entityRemoved$ on transition.
+   * @param entity - The entity to remove.
+   */
+  removeEntity(entity) {
+    if (this.matchedEntities.has(entity)) {
+      this.matchedEntities.delete(entity);
+      this.entityRemoved$.notify(entity);
+    }
+  }
+  /**
+   * Re-evaluates whether an entity matches this query and updates the matched
+   * set accordingly, firing entityAdded$ / entityRemoved$ on state transitions.
+   * @param entity - The entity to re-evaluate.
+   */
+  checkAndModify(entity) {
+    const currentlyMatches = this.matches(entity);
+    const isTracked = this.matchedEntities.has(entity);
+    if (currentlyMatches && !isTracked) {
+      this.matchedEntities.add(entity);
+      this.entityAdded$.notify(entity);
+    } else if (!currentlyMatches && isTracked) {
+      this.matchedEntities.delete(entity);
+      this.entityRemoved$.notify(entity);
+    }
+  }
+};
+
+// ../core/src/query-manager.ts
+var QueryManager = class {
+  /** All registered queries. */
+  queries = [];
+  /** Optional provider used to backfill newly created queries with existing entities. */
+  entityProvider;
+  /**
+   * Sets the entity provider used to backfill newly created queries.
+   * @param entityProvider - Provider that exposes the current world entities.
+   */
+  setEntityProvider(entityProvider) {
+    this.entityProvider = entityProvider;
+  }
+  /**
+   * Creates a new query, registers it for automatic updates, and backfills it
+   * with any currently-existing entities that match.
+   * @param parameters - Component constructor array or full query parameters.
+   * @returns The newly created query.
+   */
+  createQuery(parameters) {
+    const query = new Query(parameters);
+    this.queries.push(query);
+    if (this.entityProvider) {
+      for (const entity of this.entityProvider.entities) {
+        query.checkAndModify(entity);
+      }
+    }
+    return query;
+  }
+  /**
+   * Notifies all queries that an entity has been added to the world.
+   * @param entity - The entity that was added.
+   */
+  notifyEntityAdded(entity) {
+    for (const query of this.queries) {
+      query.checkAndModify(entity);
+    }
+  }
+  /**
+   * Notifies all queries that an entity has been removed from the world,
+   * forcing removal regardless of match state so entityRemoved$ fires for
+   * matched entities.
+   * @param entity - The entity that was removed.
+   */
+  notifyEntityRemoved(entity) {
+    for (const query of this.queries) {
+      query.removeEntity(entity);
+    }
+  }
+  /**
+   * Notifies all queries that an entity's components or tags have changed.
+   * Queries re-evaluate match state and fire observables on transitions.
+   * @param entity - The entity that changed.
+   */
+  notifyComponentChanged(entity) {
+    for (const query of this.queries) {
+      query.checkAndModify(entity);
+    }
+  }
+};
+
+// ../core/src/system.ts
+var SystemType = /* @__PURE__ */ ((SystemType2) => {
+  SystemType2["Update"] = "update";
+  SystemType2["Draw"] = "draw";
+  return SystemType2;
+})(SystemType || {});
+var SystemPriority = {
+  /** Highest priority (runs first). */
+  Highest: 0,
+  /** Higher than average priority. */
+  Higher: 25,
+  /** Default priority. */
+  Average: 50,
+  /** Lower than average priority. */
+  Lower: 75,
+  /** Lowest priority (runs last). */
+  Lowest: 100
+};
+var System = class {
+  /** The execution priority of this system. Lower values run first. */
+  static priority = SystemPriority.Average;
+};
+
+// ../core/src/system-manager.ts
+var SystemManager = class {
+  /** All registered systems. */
+  systems = [];
+  /**
+   * Registers a system for execution.
+   * @param system - The system to add.
+   */
+  addSystem(system) {
+    this.systems.push(system);
+  }
+  /**
+   * Removes a previously registered system.
+   * @param system - The system to remove.
+   */
+  removeSystem(system) {
+    const index = this.systems.indexOf(system);
+    if (index !== -1) {
+      this.systems.splice(index, 1);
+    }
+  }
+  /**
+   * Runs all systems of the specified type in priority order.
+   * Calls preupdate, update, and postupdate for each system.
+   * @param systemType - The type of systems to run.
+   * @param elapsedMilliseconds - The time elapsed since the last update in milliseconds.
+   */
+  updateSystems(systemType, elapsedMilliseconds) {
+    const matchingSystems = this.systems.filter((system) => system.systemType === systemType).sort((a, b) => {
+      const priorityA = a.constructor.priority;
+      const priorityB = b.constructor.priority;
+      return priorityA - priorityB;
+    });
+    for (const system of matchingSystems) {
+      if (system.preupdate) {
+        system.preupdate(elapsedMilliseconds);
+      }
+      system.update(elapsedMilliseconds);
+      if (system.postupdate) {
+        system.postupdate(elapsedMilliseconds);
+      }
+    }
+  }
+};
+
+// ../core/src/entity-manager.ts
+var EntityManager = class {
+  /** All managed entities. */
+  entitySet = /* @__PURE__ */ new Set();
+  /** Reference to the query manager for change notifications. */
+  queryManager;
+  /**
+   * Creates a new EntityManager.
+   * @param queryManager - The query manager to notify of entity changes.
+   */
+  constructor(queryManager) {
+    this.queryManager = queryManager;
+    this.queryManager.setEntityProvider(this);
+  }
+  /**
+   * Adds an entity to this manager and notifies the query manager.
+   * Also subscribes to the entity's component and tag change events.
+   * @param entity - The entity to add.
+   */
+  addEntity(entity) {
+    this.entitySet.add(entity);
+    this.queryManager.notifyEntityAdded(entity);
+    entity.on("componentadded", () => {
+      this.queryManager.notifyComponentChanged(entity);
+    });
+    entity.on("componentremoved", () => {
+      this.queryManager.notifyComponentChanged(entity);
+    });
+    entity.on("tagadded", () => {
+      this.queryManager.notifyComponentChanged(entity);
+    });
+    entity.on("tagremoved", () => {
+      this.queryManager.notifyComponentChanged(entity);
+    });
+    entity.on("kill", () => {
+      this.removeEntity(entity);
+    });
+  }
+  /**
+   * Removes an entity from this manager and notifies the query manager.
+   * @param entity - The entity to remove.
+   */
+  removeEntity(entity) {
+    this.entitySet.delete(entity);
+    this.queryManager.notifyEntityRemoved(entity);
+  }
+  /** Returns a readonly array of all managed entities. */
+  get entities() {
+    return [...this.entitySet];
+  }
+};
+
+// ../core/src/world.ts
+var World = class {
+  /** Manages entity lifecycle. */
+  entityManager;
+  /** Manages system registration and execution. */
+  systemManager;
+  /** Manages query creation and updates. */
+  queryManager;
+  constructor() {
+    this.queryManager = new QueryManager();
+    this.entityManager = new EntityManager(this.queryManager);
+    this.systemManager = new SystemManager();
+  }
+  /**
+   * Adds an entity to the world.
+   * @param entity - The entity to add.
+   */
+  add(entity) {
+    this.entityManager.addEntity(entity);
+  }
+  /**
+   * Adds a system to the world.
+   * @param system - The system to add.
+   */
+  addSystem(system) {
+    this.systemManager.addSystem(system);
+  }
+  /**
+   * Removes an entity from the world.
+   * @param entity - The entity to remove.
+   */
+  remove(entity) {
+    this.entityManager.removeEntity(entity);
+  }
+  /**
+   * Removes a system from the world.
+   * @param system - The system to remove.
+   */
+  removeSystem(system) {
+    this.systemManager.removeSystem(system);
+  }
+  /**
+   * Creates or retrieves a query matching the given parameters.
+   * @param parameters - Component constructor array or full query parameters.
+   * @returns A reactive query that tracks matching entities.
+   */
+  query(parameters) {
+    return this.queryManager.createQuery(parameters);
+  }
+  /**
+   * Runs all systems of the specified type for one frame.
+   * @param systemType - The type of systems to run.
+   * @param elapsedMilliseconds - The time elapsed since the last update in milliseconds.
+   */
+  update(systemType, elapsedMilliseconds) {
+    this.systemManager.updateSystems(systemType, elapsedMilliseconds);
+  }
+  /** Returns a readonly array of all entities currently in the world. */
+  get entities() {
+    return this.entityManager.entities;
+  }
+};
+
+// ../math/src/vector3.ts
+var Vector3 = class _Vector3 {
+  /**
+   * Creates a new Vector3.
+   * @param x - The x component.
+   * @param y - The y component.
+   * @param z - The z component.
+   */
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  x;
+  y;
+  z;
+  /**
+   * Adds another vector to this vector and returns the result.
+   * @param other - The vector to add.
+   * @returns A new Vector3 representing the sum.
+   */
+  add(other) {
+    return new _Vector3(this.x + other.x, this.y + other.y, this.z + other.z);
+  }
+  /**
+   * Subtracts another vector from this vector and returns the result.
+   * @param other - The vector to subtract.
+   * @returns A new Vector3 representing the difference.
+   */
+  subtract(other) {
+    return new _Vector3(this.x - other.x, this.y - other.y, this.z - other.z);
+  }
+  /**
+   * Scales this vector by a scalar value and returns the result.
+   * @param scalar - The scalar multiplier.
+   * @returns A new scaled Vector3.
+   */
+  scale(scalar) {
+    return new _Vector3(this.x * scalar, this.y * scalar, this.z * scalar);
+  }
+  /**
+   * Returns the normalized (unit length) version of this vector.
+   * If the vector has zero length, returns a zero vector.
+   * @returns A new normalized Vector3.
+   */
+  normalize() {
+    const magnitude = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    if (magnitude === 0) {
+      return _Vector3.zero();
+    }
+    return new _Vector3(this.x / magnitude, this.y / magnitude, this.z / magnitude);
+  }
+  /**
+   * Computes the dot product of this vector with another.
+   * @param other - The other vector.
+   * @returns The dot product.
+   */
+  dot(other) {
+    return this.x * other.x + this.y * other.y + this.z * other.z;
+  }
+  /**
+   * Computes the cross product of this vector with another.
+   * @param other - The other vector.
+   * @returns A new Vector3 representing the cross product.
+   */
+  cross(other) {
+    return new _Vector3(
+      this.y * other.z - this.z * other.y,
+      this.z * other.x - this.x * other.z,
+      this.x * other.y - this.y * other.x
+    );
+  }
+  /**
+   * Computes the Euclidean distance between this vector and another.
+   * @param other - The other vector.
+   * @returns The distance.
+   */
+  distance(other) {
+    return Math.sqrt(this.distanceSquared(other));
+  }
+  /**
+   * Computes the squared Euclidean distance between this vector and another.
+   * @param other - The other vector.
+   * @returns The squared distance.
+   */
+  distanceSquared(other) {
+    const deltaX = this.x - other.x;
+    const deltaY = this.y - other.y;
+    const deltaZ = this.z - other.z;
+    return deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ;
+  }
+  /**
+   * Linearly interpolates between this vector and a target vector.
+   * @param target - The target vector.
+   * @param interpolation - The interpolation factor, typically between 0 and 1.
+   * @returns A new interpolated Vector3.
+   */
+  lerp(target, interpolation) {
+    return new _Vector3(
+      this.x + (target.x - this.x) * interpolation,
+      this.y + (target.y - this.y) * interpolation,
+      this.z + (target.z - this.z) * interpolation
+    );
+  }
+  /**
+   * Creates a copy of this vector.
+   * @returns A new Vector3 with the same components.
+   */
+  clone() {
+    return new _Vector3(this.x, this.y, this.z);
+  }
+  /**
+   * Checks whether this vector is equal to another within floating-point tolerance.
+   * @param other - The vector to compare against.
+   * @param epsilon - The tolerance for comparison. Defaults to 1e-6.
+   * @returns True if the vectors are approximately equal.
+   */
+  equals(other, epsilon = 1e-6) {
+    return Math.abs(this.x - other.x) <= epsilon && Math.abs(this.y - other.y) <= epsilon && Math.abs(this.z - other.z) <= epsilon;
+  }
+  /**
+   * Returns a string representation of this vector.
+   * @returns A string in the format "Vector3(x, y, z)".
+   */
+  toString() {
+    return `Vector3(${this.x}, ${this.y}, ${this.z})`;
+  }
+  /** Returns a vector with all components set to zero. */
+  static zero() {
+    return new _Vector3(0, 0, 0);
+  }
+  /** Returns a vector with all components set to one. */
+  static one() {
+    return new _Vector3(1, 1, 1);
+  }
+  /** Returns the up direction vector (0, 1, 0). */
+  static up() {
+    return new _Vector3(0, 1, 0);
+  }
+  /** Returns the down direction vector (0, -1, 0). */
+  static down() {
+    return new _Vector3(0, -1, 0);
+  }
+  /** Returns the left direction vector (-1, 0, 0). */
+  static left() {
+    return new _Vector3(-1, 0, 0);
+  }
+  /** Returns the right direction vector (1, 0, 0). */
+  static right() {
+    return new _Vector3(1, 0, 0);
+  }
+  /** Returns the forward direction vector (0, 0, 1). */
+  static forward() {
+    return new _Vector3(0, 0, 1);
+  }
+  /** Returns the back direction vector (0, 0, -1). */
+  static back() {
+    return new _Vector3(0, 0, -1);
+  }
+};
+
+// ../math/src/quaternion.ts
+var Quaternion = class _Quaternion {
+  /**
+   * Creates a new Quaternion.
+   * @param x - The x component.
+   * @param y - The y component.
+   * @param z - The z component.
+   * @param w - The w (scalar) component.
+   */
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  x;
+  y;
+  z;
+  w;
+  /**
+   * Multiplies this quaternion by another (composes rotations).
+   * @param other - The quaternion to multiply with.
+   * @returns A new Quaternion representing the combined rotation.
+   */
+  multiply(other) {
+    return new _Quaternion(
+      this.w * other.x + this.x * other.w + this.y * other.z - this.z * other.y,
+      this.w * other.y - this.x * other.z + this.y * other.w + this.z * other.x,
+      this.w * other.z + this.x * other.y - this.y * other.x + this.z * other.w,
+      this.w * other.w - this.x * other.x - this.y * other.y - this.z * other.z
+    );
+  }
+  /**
+   * Returns the inverse (conjugate divided by squared magnitude) of this quaternion.
+   * For unit quaternions, this is the same as the conjugate.
+   * @returns A new Quaternion representing the inverse rotation.
+   */
+  inverse() {
+    const magnitudeSquared = this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+    if (magnitudeSquared === 0) {
+      return _Quaternion.identity();
+    }
+    return new _Quaternion(
+      -this.x / magnitudeSquared,
+      -this.y / magnitudeSquared,
+      -this.z / magnitudeSquared,
+      this.w / magnitudeSquared
+    );
+  }
+  /**
+   * Returns a normalized (unit length) version of this quaternion.
+   * @returns A new normalized Quaternion.
+   */
+  normalize() {
+    const magnitude = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    if (magnitude === 0) {
+      return _Quaternion.identity();
+    }
+    return new _Quaternion(
+      this.x / magnitude,
+      this.y / magnitude,
+      this.z / magnitude,
+      this.w / magnitude
+    );
+  }
+  /**
+   * Performs spherical linear interpolation between this quaternion and a target.
+   * @param target - The target quaternion.
+   * @param interpolation - The interpolation factor, typically between 0 and 1.
+   * @returns A new interpolated Quaternion.
+   */
+  slerp(target, interpolation) {
+    let cosHalfAngle = this.x * target.x + this.y * target.y + this.z * target.z + this.w * target.w;
+    let targetX = target.x;
+    let targetY = target.y;
+    let targetZ = target.z;
+    let targetW = target.w;
+    if (cosHalfAngle < 0) {
+      cosHalfAngle = -cosHalfAngle;
+      targetX = -targetX;
+      targetY = -targetY;
+      targetZ = -targetZ;
+      targetW = -targetW;
+    }
+    if (cosHalfAngle > 0.9995) {
+      return new _Quaternion(
+        this.x + (targetX - this.x) * interpolation,
+        this.y + (targetY - this.y) * interpolation,
+        this.z + (targetZ - this.z) * interpolation,
+        this.w + (targetW - this.w) * interpolation
+      ).normalize();
+    }
+    const halfAngle = Math.acos(cosHalfAngle);
+    const sinHalfAngle = Math.sin(halfAngle);
+    const ratioA = Math.sin((1 - interpolation) * halfAngle) / sinHalfAngle;
+    const ratioB = Math.sin(interpolation * halfAngle) / sinHalfAngle;
+    return new _Quaternion(
+      this.x * ratioA + targetX * ratioB,
+      this.y * ratioA + targetY * ratioB,
+      this.z * ratioA + targetZ * ratioB,
+      this.w * ratioA + targetW * ratioB
+    );
+  }
+  /**
+   * Converts this quaternion to Euler angles (in radians).
+   * Returns a Vector3 with (pitch, yaw, roll) as (x, y, z).
+   * @returns A Vector3 containing the Euler angles in radians.
+   */
+  toEulerAngles() {
+    const sinRollCosP = 2 * (this.w * this.x + this.y * this.z);
+    const cosRollCosP = 1 - 2 * (this.x * this.x + this.y * this.y);
+    const roll = Math.atan2(sinRollCosP, cosRollCosP);
+    const sinPitch = 2 * (this.w * this.y - this.z * this.x);
+    let pitch;
+    if (Math.abs(sinPitch) >= 1) {
+      pitch = Math.sign(sinPitch) * (Math.PI / 2);
+    } else {
+      pitch = Math.asin(sinPitch);
+    }
+    const sinYawCosP = 2 * (this.w * this.z + this.x * this.y);
+    const cosYawCosP = 1 - 2 * (this.y * this.y + this.z * this.z);
+    const yaw = Math.atan2(sinYawCosP, cosYawCosP);
+    return new Vector3(roll, pitch, yaw);
+  }
+  /**
+   * Rotates a Vector3 by this quaternion.
+   * @param vector - The vector to rotate.
+   * @returns A new rotated Vector3.
+   */
+  rotateVector3(vector) {
+    const vectorQuaternion = new _Quaternion(vector.x, vector.y, vector.z, 0);
+    const result = this.multiply(vectorQuaternion).multiply(this.inverse());
+    return new Vector3(result.x, result.y, result.z);
+  }
+  /** Creates a deep copy of this quaternion. */
+  clone() {
+    return new _Quaternion(this.x, this.y, this.z, this.w);
+  }
+  /**
+   * Checks if this quaternion is approximately equal to another.
+   * @param other - The quaternion to compare against.
+   * @param epsilon - The tolerance for floating-point comparison.
+   */
+  equals(other, epsilon = 1e-6) {
+    return Math.abs(this.x - other.x) < epsilon && Math.abs(this.y - other.y) < epsilon && Math.abs(this.z - other.z) < epsilon && Math.abs(this.w - other.w) < epsilon;
+  }
+  /** Returns a string representation of this quaternion. */
+  toString() {
+    return `Quaternion(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
+  }
+  /** Returns the identity quaternion (no rotation). */
+  static identity() {
+    return new _Quaternion(0, 0, 0, 1);
+  }
+  /**
+   * Creates a quaternion from Euler angles (in radians).
+   * @param euler - A Vector3 containing (roll, pitch, yaw) as (x, y, z) in radians.
+   * @returns A new Quaternion representing the rotation.
+   */
+  static fromEulerAngles(euler) {
+    const halfRoll = euler.x * 0.5;
+    const halfPitch = euler.y * 0.5;
+    const halfYaw = euler.z * 0.5;
+    const sinRoll = Math.sin(halfRoll);
+    const cosRoll = Math.cos(halfRoll);
+    const sinPitch = Math.sin(halfPitch);
+    const cosPitch = Math.cos(halfPitch);
+    const sinYaw = Math.sin(halfYaw);
+    const cosYaw = Math.cos(halfYaw);
+    return new _Quaternion(
+      sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,
+      cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,
+      cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,
+      cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw
+    );
+  }
+  /**
+   * Creates a quaternion from an axis-angle representation.
+   * @param axis - The axis of rotation (should be normalized).
+   * @param angleRadians - The angle of rotation in radians.
+   * @returns A new Quaternion representing the rotation.
+   */
+  static fromAxisAngle(axis, angleRadians) {
+    const halfAngle = angleRadians * 0.5;
+    const sinHalfAngle = Math.sin(halfAngle);
+    return new _Quaternion(
+      axis.x * sinHalfAngle,
+      axis.y * sinHalfAngle,
+      axis.z * sinHalfAngle,
+      Math.cos(halfAngle)
+    );
+  }
+};
+
+// ../core/src/transform-component.ts
+var TransformComponent = class _TransformComponent extends Component {
+  /** The position in world space. */
+  position = Vector3.zero();
+  /** The rotation as a quaternion. */
+  rotation = Quaternion.identity();
+  /** The scale factor along each axis. */
+  scale = Vector3.one();
+  /** The z-ordering index for 2D rendering. */
+  zIndex = 0;
+  /** Creates a deep copy of this transform component. */
+  clone() {
+    const cloned = new _TransformComponent();
+    cloned.position = this.position.clone();
+    cloned.rotation = this.rotation.clone();
+    cloned.scale = this.scale.clone();
+    cloned.zIndex = this.zIndex;
+    return cloned;
+  }
+  /**
+   * Serializes this component's state to a plain object.
+   * @returns A record containing position, rotation, scale, and zIndex.
+   */
+  serialize() {
+    return {
+      position: { x: this.position.x, y: this.position.y, z: this.position.z },
+      rotation: { x: this.rotation.x, y: this.rotation.y, z: this.rotation.z, w: this.rotation.w },
+      scale: { x: this.scale.x, y: this.scale.y, z: this.scale.z },
+      zIndex: this.zIndex
+    };
+  }
+  /**
+   * Restores this component's state from a serialized object.
+   * @param data - The serialized data to restore from.
+   */
+  deserialize(data) {
+    const position = data["position"];
+    if (position) {
+      this.position = new Vector3(position.x, position.y, position.z);
+    }
+    const rotation = data["rotation"];
+    if (rotation) {
+      this.rotation = new Quaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+    }
+    const scale = data["scale"];
+    if (scale) {
+      this.scale = new Vector3(scale.x, scale.y, scale.z);
+    }
+    if (typeof data["zIndex"] === "number") {
+      this.zIndex = data["zIndex"];
+    }
+  }
+};
+
+// ../core/src/motion-component.ts
+var MotionComponent = class _MotionComponent extends Component {
+  /**
+   * The linear velocity in units per second.
+   *
+   * Immutable — to change, assign a new Vector3
+   * (`motion.velocity = new Vector3(x, y, z)`) or call setVelocity.
+   */
+  velocity = Vector3.zero();
+  /**
+   * The linear acceleration in units per second squared.
+   *
+   * Immutable — to change, assign a new Vector3
+   * (`motion.acceleration = new Vector3(x, y, z)`) or call setAcceleration.
+   */
+  acceleration = Vector3.zero();
+  /** The angular velocity in radians per second. */
+  angularVelocity = 0;
+  /** The torque applied to the entity in radians per second squared. */
+  torque = 0;
+  /** The rotational inertia of the entity. */
+  inertia = 1;
+  /**
+   * Replaces the velocity with a new Vector3 constructed from the given components.
+   * @param x - The x component of the new velocity.
+   * @param y - The y component of the new velocity.
+   * @param z - The z component of the new velocity.
+   */
+  setVelocity(x, y, z) {
+    this.velocity = new Vector3(x, y, z);
+  }
+  /**
+   * Replaces the acceleration with a new Vector3 constructed from the given components.
+   * @param x - The x component of the new acceleration.
+   * @param y - The y component of the new acceleration.
+   * @param z - The z component of the new acceleration.
+   */
+  setAcceleration(x, y, z) {
+    this.acceleration = new Vector3(x, y, z);
+  }
+  /** Creates a deep copy of this motion component. */
+  clone() {
+    const cloned = new _MotionComponent();
+    cloned.velocity = this.velocity.clone();
+    cloned.acceleration = this.acceleration.clone();
+    cloned.angularVelocity = this.angularVelocity;
+    cloned.torque = this.torque;
+    cloned.inertia = this.inertia;
+    return cloned;
+  }
+  /**
+   * Serializes this component's state to a plain object.
+   * @returns A record containing velocity, acceleration, and rotational properties.
+   */
+  serialize() {
+    return {
+      velocity: { x: this.velocity.x, y: this.velocity.y, z: this.velocity.z },
+      acceleration: { x: this.acceleration.x, y: this.acceleration.y, z: this.acceleration.z },
+      angularVelocity: this.angularVelocity,
+      torque: this.torque,
+      inertia: this.inertia
+    };
+  }
+  /**
+   * Restores this component's state from a serialized object.
+   * @param data - The serialized data to restore from.
+   */
+  deserialize(data) {
+    const velocity = data["velocity"];
+    if (velocity) {
+      this.velocity = new Vector3(velocity.x, velocity.y, velocity.z);
+    }
+    const acceleration = data["acceleration"];
+    if (acceleration) {
+      this.acceleration = new Vector3(acceleration.x, acceleration.y, acceleration.z);
+    }
+    if (typeof data["angularVelocity"] === "number") {
+      this.angularVelocity = data["angularVelocity"];
+    }
+    if (typeof data["torque"] === "number") {
+      this.torque = data["torque"];
+    }
+    if (typeof data["inertia"] === "number") {
+      this.inertia = data["inertia"];
+    }
+  }
+};
+
+// ../core/src/motion-system.ts
+var MotionSystem = class extends System {
+  /** This system runs during the update phase. */
+  systemType = "update" /* Update */;
+  /** The query tracking entities with both TransformComponent and MotionComponent. */
+  motionQuery;
+  /**
+   * Creates a new MotionSystem.
+   * @param world - The world to create the motion query in.
+   */
+  constructor(world) {
+    super();
+    this.motionQuery = world.query([TransformComponent, MotionComponent]);
+  }
+  /**
+   * Updates all entities with motion, applying acceleration to velocity and velocity to position.
+   * @param elapsedMilliseconds - The time elapsed since the last update in milliseconds.
+   */
+  update(elapsedMilliseconds) {
+    const deltaTimeSeconds = elapsedMilliseconds / 1e3;
+    for (const entity of this.motionQuery.entities) {
+      const transform = entity.get(TransformComponent);
+      const motion = entity.get(MotionComponent);
+      motion.velocity = motion.velocity.add(motion.acceleration.scale(deltaTimeSeconds));
+      transform.position = transform.position.add(motion.velocity.scale(deltaTimeSeconds));
+    }
+  }
+};
+
+export { Component, Entity, EntityManager, EventEmitter, MotionComponent, MotionSystem, Observable, Query, QueryManager, System, SystemManager, SystemPriority, SystemType, TransformComponent, World };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map