@zylem/game-lib 0.3.14 → 0.3.16

package/dist/lib/debug/console/console-state.js

@@ -0,0 +1,11 @@
+import { proxy as s } from "valtio/vanilla";
+const o = s({
+  messages: []
+}), n = (t) => {
+  const e = `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${t}`;
+  o.messages.push(e);
+};
+export {
+  o as consoleState,
+  n as printToConsole
+};

package/dist/lib/debug/debug-state.js

@@ -0,0 +1,40 @@
+import { proxy as s } from "valtio/vanilla";
+import { printToConsole as t } from "./console/console-state.js";
+const n = {
+  NONE: "NONE",
+  SELECT: "SELECT",
+  DELETE: "DELETE"
+}, o = s({
+  on: !1,
+  paused: !1,
+  configuration: {
+    showCollisionBounds: !1,
+    showModelBounds: !1,
+    showSpriteBounds: !1
+  },
+  hovered: null,
+  selected: [],
+  tool: n.NONE
+}), r = (e = !1) => {
+  o.on = e;
+}, u = (e) => {
+  o.selected.push(e);
+}, E = () => o.tool, a = (e) => {
+  o.hovered = e;
+}, c = () => {
+  o.hovered = null;
+}, i = () => o.hovered, f = (e) => {
+  o.paused = e, t(e ? "Paused" : "Resumed");
+}, p = () => o.paused;
+export {
+  n as DebugTools,
+  o as debugState,
+  E as getDebugTool,
+  i as getHoveredEntity,
+  p as isPaused,
+  c as resetHoveredEntity,
+  r as setDebugFlag,
+  a as setHoveredEntity,
+  f as setPaused,
+  u as setSelectedEntity
+};

package/dist/lib/entities/actor.js

@@ -0,0 +1,125 @@
+import { ColliderDesc as l, ActiveCollisionTypes as m } from "@dimforge/rapier3d-compat";
+import { Vector3 as r, Group as d, SkinnedMesh as u } from "three";
+import { GameEntity as p } from "./entity.js";
+import { createEntity as g } from "./create.js";
+import { EntityAssetLoader as y } from "../core/entity-asset-loader.js";
+import { AnimationDelegate as f } from "./delegates/animation.js";
+import { EntityCollisionBuilder as b, EntityBuilder as _ } from "./builder.js";
+const c = {
+  position: { x: 0, y: 0, z: 0 },
+  collision: {
+    static: !1,
+    size: new r(0.5, 0.5, 0.5),
+    position: new r(0, 0, 0)
+  },
+  material: {
+    shader: "standard"
+  },
+  animations: [],
+  models: []
+};
+class j extends b {
+  height = 1;
+  objectModel = null;
+  constructor(t) {
+    super(), this.objectModel = t.objectModel;
+  }
+  createColliderFromObjectModel(t) {
+    if (!t)
+      return l.capsule(1, 1);
+    const e = t.children.find((s) => s instanceof u).geometry;
+    if (e && (e.computeBoundingBox(), e.boundingBox)) {
+      const s = e.boundingBox.max.y, h = e.boundingBox.min.y;
+      this.height = s - h;
+    }
+    this.height = 1;
+    let o = l.capsule(this.height / 2, 1);
+    return o.setSensor(!1), o.setTranslation(0, this.height + 0.5, 0), o.activeCollisionTypes = m.DEFAULT, o;
+  }
+  collider(t) {
+    return this.createColliderFromObjectModel(this.objectModel);
+  }
+}
+class C extends _ {
+  createEntity(t) {
+    return new a(t);
+  }
+}
+const D = Symbol("Actor");
+class a extends p {
+  static type = D;
+  _object = null;
+  _animationDelegate = null;
+  _modelFileNames = [];
+  _assetLoader = new y();
+  controlledRotation = !1;
+  constructor(t) {
+    super(), this.options = { ...c, ...t }, this.lifeCycleDelegate = {
+      update: [this.actorUpdate.bind(this)]
+    }, this.controlledRotation = !0;
+  }
+  async load() {
+    this._modelFileNames = this.options.models || [], await this.loadModels(), this._object && (this._animationDelegate = new f(this._object), await this._animationDelegate.loadAnimations(this.options.animations || []));
+  }
+  async data() {
+    return {
+      animations: this._animationDelegate?.animations,
+      objectModel: this._object
+    };
+  }
+  async actorUpdate(t) {
+    this._animationDelegate?.update(t.delta);
+  }
+  async loadModels() {
+    if (this._modelFileNames.length === 0)
+      return;
+    const t = this._modelFileNames.map((e) => this._assetLoader.loadFile(e)), i = await Promise.all(t);
+    i[0]?.object && (this._object = i[0].object), this._object && (this.group = new d(), this.group.attach(this._object), this.group.scale.set(this.options.scale?.x || 1, this.options.scale?.y || 1, this.options.scale?.z || 1));
+  }
+  playAnimation(t) {
+    this._animationDelegate?.playAnimation(t);
+  }
+  get object() {
+    return this._object;
+  }
+  /**
+   * Provide custom debug information for the actor
+   * This will be merged with the default debug information
+   */
+  getDebugInfo() {
+    const t = {
+      type: "Actor",
+      models: this._modelFileNames.length > 0 ? this._modelFileNames : "none",
+      modelLoaded: !!this._object,
+      scale: this.options.scale ? `${this.options.scale.x}, ${this.options.scale.y}, ${this.options.scale.z}` : "1, 1, 1"
+    };
+    if (this._animationDelegate && (t.currentAnimation = this._animationDelegate.currentAnimationKey || "none", t.animationsCount = this.options.animations?.length || 0), this._object) {
+      let i = 0, e = 0;
+      this._object.traverse((o) => {
+        if (o.isMesh) {
+          i++;
+          const s = o.geometry;
+          s && s.attributes.position && (e += s.attributes.position.count);
+        }
+      }), t.meshCount = i, t.vertexCount = e;
+    }
+    return t;
+  }
+}
+async function T(...n) {
+  return await g({
+    args: n,
+    defaultConfig: c,
+    EntityClass: a,
+    BuilderClass: C,
+    CollisionBuilderClass: j,
+    entityType: a.type
+  });
+}
+export {
+  D as ACTOR_TYPE,
+  C as ActorBuilder,
+  j as ActorCollisionBuilder,
+  a as ZylemActor,
+  T as actor
+};

package/dist/lib/entities/box.js

@@ -0,0 +1,68 @@
+import { ColliderDesc as a } from "@dimforge/rapier3d-compat";
+import { Color as d, Vector3 as n, BoxGeometry as u } from "three";
+import { GameEntity as y } from "./entity.js";
+import { EntityCollisionBuilder as f, EntityBuilder as x, EntityMeshBuilder as m } from "./builder.js";
+import { DebugDelegate as p } from "./delegates/debug.js";
+import { createEntity as z } from "./create.js";
+const l = {
+  size: new n(1, 1, 1),
+  position: new n(0, 0, 0),
+  collision: {
+    static: !1
+  },
+  material: {
+    color: new d("#ffffff"),
+    shader: "standard"
+  }
+};
+class B extends f {
+  collider(t) {
+    const e = t.size || new n(1, 1, 1), s = { x: e.x / 2, y: e.y / 2, z: e.z / 2 };
+    return a.cuboid(s.x, s.y, s.z);
+  }
+}
+class b extends m {
+  build(t) {
+    const e = t.size ?? new n(1, 1, 1);
+    return new u(e.x, e.y, e.z);
+  }
+}
+class C extends x {
+  createEntity(t) {
+    return new i(t);
+  }
+}
+const h = Symbol("Box");
+class i extends y {
+  static type = h;
+  constructor(t) {
+    super(), this.options = { ...l, ...t };
+  }
+  buildInfo() {
+    const e = new p(this).buildDebugInfo(), { x: s, y: r, z: c } = this.options.size ?? { x: 1, y: 1, z: 1 };
+    return {
+      ...e,
+      type: String(i.type),
+      size: `${s}, ${r}, ${c}`
+    };
+  }
+}
+async function $(...o) {
+  return z({
+    args: o,
+    defaultConfig: l,
+    EntityClass: i,
+    BuilderClass: C,
+    MeshBuilderClass: b,
+    CollisionBuilderClass: B,
+    entityType: i.type
+  });
+}
+export {
+  h as BOX_TYPE,
+  C as BoxBuilder,
+  B as BoxCollisionBuilder,
+  b as BoxMeshBuilder,
+  i as ZylemBox,
+  $ as box
+};

package/dist/lib/entities/builder.js

@@ -0,0 +1,79 @@
+import { Mesh as l, Color as n, BufferGeometry as u } from "three";
+import { CollisionBuilder as h } from "../collision/collision-builder.js";
+import { MeshBuilder as m } from "../graphics/mesh.js";
+import { MaterialBuilder as d } from "../graphics/material.js";
+class y extends h {
+}
+class b extends m {
+  build(i) {
+    return new u();
+  }
+  postBuild() {
+  }
+}
+class M {
+  meshBuilder;
+  collisionBuilder;
+  materialBuilder;
+  options;
+  entity;
+  constructor(i, s, t, e) {
+    this.options = i, this.entity = s, this.meshBuilder = t, this.collisionBuilder = e, this.materialBuilder = new d();
+    const o = {
+      meshBuilder: this.meshBuilder,
+      collisionBuilder: this.collisionBuilder,
+      materialBuilder: this.materialBuilder
+    };
+    this.options._builders = o;
+  }
+  withPosition(i) {
+    return this.options.position = i, this;
+  }
+  async withMaterial(i, s) {
+    return this.materialBuilder && await this.materialBuilder.build(i, s), this;
+  }
+  applyMaterialToGroup(i, s) {
+    i.traverse((t) => {
+      t instanceof l && t.type === "SkinnedMesh" && s[0] && !t.material.map && (t.material = s[0]), t.castShadow = !0, t.receiveShadow = !0;
+    });
+  }
+  async build() {
+    const i = this.entity;
+    if (this.materialBuilder && (i.materials = this.materialBuilder.materials), this.meshBuilder && i.materials) {
+      const s = this.meshBuilder.build(this.options);
+      i.mesh = this.meshBuilder._build(this.options, s, i.materials), this.meshBuilder.postBuild();
+    }
+    if (i.group && i.materials && this.applyMaterialToGroup(i.group, i.materials), this.collisionBuilder) {
+      this.collisionBuilder.withCollision(this.options?.collision || {});
+      const [s, t] = this.collisionBuilder.build(this.options);
+      i.bodyDesc = s, i.colliderDesc = t;
+      const { x: e, y: o, z: a } = this.options.position || { x: 0, y: 0, z: 0 };
+      i.bodyDesc.setTranslation(e, o, a);
+    }
+    if (this.options.collisionType && (i.collisionType = this.options.collisionType), this.options.color instanceof n) {
+      const s = (t) => {
+        const e = t;
+        e && e.color && e.color.set && e.color.set(this.options.color);
+      };
+      if (i.materials?.length)
+        for (const t of i.materials)
+          s(t);
+      if (i.mesh && i.mesh.material) {
+        const t = i.mesh.material;
+        Array.isArray(t) ? t.forEach(s) : s(t);
+      }
+      i.group && i.group.traverse((t) => {
+        if (t instanceof l && t.material) {
+          const e = t.material;
+          Array.isArray(e) ? e.forEach(s) : s(e);
+        }
+      });
+    }
+    return i;
+  }
+}
+export {
+  M as EntityBuilder,
+  y as EntityCollisionBuilder,
+  b as EntityMeshBuilder
+};

package/dist/lib/entities/create.js

@@ -0,0 +1,31 @@
+import { BaseNode as s } from "../core/base-node.js";
+import { isLoadable as p, EntityLoader as C } from "./delegates/loader.js";
+async function E(w) {
+  const { args: n, defaultConfig: l, EntityClass: g, BuilderClass: y, entityType: c, MeshBuilderClass: f, CollisionBuilderClass: d } = w;
+  let e = null, r;
+  const u = n.findIndex((i) => !(i instanceof s));
+  u !== -1 && (r = n.splice(u, 1).find((t) => !(t instanceof s)));
+  const m = r ? { ...l, ...r } : l;
+  n.push(m);
+  for (const i of n) {
+    if (i instanceof s)
+      continue;
+    let t = null;
+    const a = new g(i);
+    try {
+      if (p(a)) {
+        const o = new C(a);
+        await o.load(), t = await o.data();
+      }
+    } catch (o) {
+      console.error("Error creating entity with loader:", o);
+    }
+    e = new y(i, a, f ? new f(t) : null, d ? new d(t) : null), i.material && await e.withMaterial(i.material, c);
+  }
+  if (!e)
+    throw new Error(`missing options for ${String(c)}, builder is not initialized.`);
+  return await e.build();
+}
+export {
+  E as createEntity
+};

package/dist/lib/entities/delegates/animation.js

@@ -0,0 +1,58 @@
+import { AnimationMixer as u, LoopOnce as c, LoopRepeat as h } from "three";
+import { EntityAssetLoader as _ } from "../../core/entity-asset-loader.js";
+class d {
+  target;
+  _mixer = null;
+  _actions = {};
+  _animations = [];
+  _currentAction = null;
+  _pauseAtPercentage = 0;
+  _isPaused = !1;
+  _queuedKey = null;
+  _fadeDuration = 0.5;
+  _currentKey = "";
+  _assetLoader = new _();
+  constructor(e) {
+    this.target = e;
+  }
+  async loadAnimations(e) {
+    if (!e.length)
+      return;
+    const i = await Promise.all(e.map((t) => this._assetLoader.loadFile(t.path)));
+    this._animations = i.filter((t) => !!t.animation).map((t) => t.animation), this._animations.length && (this._mixer = new u(this.target), this._animations.forEach((t, n) => {
+      const a = e[n].key || n.toString();
+      this._actions[a] = this._mixer.clipAction(t);
+    }), this.playAnimation({ key: Object.keys(this._actions)[0] }));
+  }
+  update(e) {
+    if (!this._mixer || !this._currentAction)
+      return;
+    this._mixer.update(e);
+    const i = this._currentAction.getClip().duration * (this._pauseAtPercentage / 100);
+    if (!this._isPaused && this._pauseAtPercentage > 0 && this._currentAction.time >= i && (this._currentAction.time = i, this._currentAction.paused = !0, this._isPaused = !0, this._queuedKey !== null)) {
+      const t = this._actions[this._queuedKey];
+      t.reset().play(), this._currentAction.crossFadeTo(t, this._fadeDuration, !1), this._currentAction = t, this._currentKey = this._queuedKey, this._queuedKey = null;
+    }
+  }
+  playAnimation(e) {
+    if (!this._mixer)
+      return;
+    const { key: i, pauseAtPercentage: t = 0, pauseAtEnd: n = !1, fadeToKey: a, fadeDuration: o = 0.5 } = e;
+    if (i === this._currentKey)
+      return;
+    this._queuedKey = a || null, this._fadeDuration = o, this._pauseAtPercentage = n ? 100 : t, this._isPaused = !1;
+    const r = this._currentAction;
+    r && r.stop();
+    const s = this._actions[i];
+    s && (this._pauseAtPercentage > 0 ? (s.setLoop(c, 1 / 0), s.clampWhenFinished = !0) : (s.setLoop(h, 1 / 0), s.clampWhenFinished = !1), r && r.crossFadeTo(s, o, !1), s.reset().play(), this._currentAction = s, this._currentKey = i);
+  }
+  get currentAnimationKey() {
+    return this._currentKey;
+  }
+  get animations() {
+    return this._animations;
+  }
+}
+export {
+  d as AnimationDelegate
+};

package/dist/lib/entities/delegates/debug.js

@@ -0,0 +1,72 @@
+import { MeshStandardMaterial as c, MeshBasicMaterial as u, MeshPhongMaterial as f } from "three";
+function g(o) {
+  return o && typeof o.getDebugInfo == "function";
+}
+class d {
+  entity;
+  constructor(t) {
+    this.entity = t;
+  }
+  /**
+   * Get formatted position string
+   */
+  getPositionString() {
+    if (this.entity.mesh) {
+      const { x: n, y: s, z: r } = this.entity.mesh.position;
+      return `${n.toFixed(2)}, ${s.toFixed(2)}, ${r.toFixed(2)}`;
+    }
+    const { x: t, y: i, z: e } = this.entity.options.position || { x: 0, y: 0, z: 0 };
+    return `${t.toFixed(2)}, ${i.toFixed(2)}, ${e.toFixed(2)}`;
+  }
+  /**
+   * Get formatted rotation string (in degrees)
+   */
+  getRotationString() {
+    if (this.entity.mesh) {
+      const { x: s, y: r, z: y } = this.entity.mesh.rotation, a = (h) => (h * 180 / Math.PI).toFixed(1);
+      return `${a(s)}°, ${a(r)}°, ${a(y)}°`;
+    }
+    const { x: t, y: i, z: e } = this.entity.options.rotation || { x: 0, y: 0, z: 0 }, n = (s) => (s * 180 / Math.PI).toFixed(1);
+    return `${n(t)}°, ${n(i)}°, ${n(e)}°`;
+  }
+  /**
+   * Get material information
+   */
+  getMaterialInfo() {
+    if (!this.entity.mesh || !this.entity.mesh.material)
+      return { type: "none" };
+    const t = Array.isArray(this.entity.mesh.material) ? this.entity.mesh.material[0] : this.entity.mesh.material, i = {
+      type: t.type
+    };
+    return (t instanceof c || t instanceof u || t instanceof f) && (i.color = `#${t.color.getHexString()}`, i.opacity = t.opacity, i.transparent = t.transparent), "roughness" in t && (i.roughness = t.roughness), "metalness" in t && (i.metalness = t.metalness), i;
+  }
+  getPhysicsInfo() {
+    if (!this.entity.body)
+      return null;
+    const t = {
+      type: this.entity.body.bodyType(),
+      mass: this.entity.body.mass(),
+      isEnabled: this.entity.body.isEnabled(),
+      isSleeping: this.entity.body.isSleeping()
+    }, i = this.entity.body.linvel();
+    return t.velocity = `${i.x.toFixed(2)}, ${i.y.toFixed(2)}, ${i.z.toFixed(2)}`, t;
+  }
+  buildDebugInfo() {
+    const t = {
+      name: this.entity.name || this.entity.uuid,
+      uuid: this.entity.uuid,
+      position: this.getPositionString(),
+      rotation: this.getRotationString(),
+      material: this.getMaterialInfo()
+    }, i = this.getPhysicsInfo();
+    if (i && (t.physics = i), this.entity.behaviors.length > 0 && (t.behaviors = this.entity.behaviors.map((e) => e.constructor.name)), g(this.entity)) {
+      const e = this.entity.getDebugInfo();
+      return { ...t, ...e };
+    }
+    return t;
+  }
+}
+export {
+  d as DebugDelegate,
+  g as hasDebugInfo
+};

package/dist/lib/entities/delegates/loader.js

@@ -0,0 +1,19 @@
+function n(e) {
+  return typeof e?.load == "function" && typeof e?.data == "function";
+}
+class a {
+  entityReference;
+  constructor(t) {
+    this.entityReference = t;
+  }
+  async load() {
+    this.entityReference.load && await this.entityReference.load();
+  }
+  async data() {
+    return this.entityReference.data ? this.entityReference.data() : null;
+  }
+}
+export {
+  a as EntityLoader,
+  n as isLoadable
+};

package/dist/lib/entities/destroy.js

@@ -0,0 +1,15 @@
+import { getGlobalState as n } from "../game/game-state.js";
+function r(o, t, e) {
+  e({
+    me: o,
+    globals: t
+  });
+}
+function d(o, t) {
+  const e = t ?? n();
+  r(o, e, o.nodeDestroy.bind(o));
+}
+export {
+  d as destroy,
+  r as destroyEntity
+};

package/dist/lib/entities/entity.d.ts

@@ -2,7 +2,6 @@ import { Mesh, Material, ShaderMaterial, Group, Color } from "three";
 import { Collider, ColliderDesc, RigidBody, RigidBodyDesc } from "@dimforge/rapier3d-compat";
 import { Vec3 } from "../core/vector";
 import { MaterialBuilder, MaterialOptions } from "../graphics/material";
-import { PhysicsOptions } from "../collision/physics";
 import { CollisionOptions } from "../collision/collision";
 import { BaseNode } from "../core/base-node";
 import { DestroyContext, SetupContext, UpdateContext } from "../core/base-node-life-cycle";
@@ -39,7 +38,6 @@ export type GameEntityOptions = {
     position?: Vec3;
     batched?: boolean;
     collision?: Partial<CollisionOptions>;
-    physics?: Partial<PhysicsOptions>;
     material?: Partial<MaterialOptions>;
     custom?: {
         [key: string]: any;

package/dist/lib/entities/entity.js

@@ -0,0 +1,116 @@
+import { ShaderMaterial as s } from "three";
+import { position as o, scale as a, rotation as n } from "../systems/transformable.system.js";
+import { BaseNode as c } from "../core/base-node.js";
+class d extends c {
+  group;
+  mesh;
+  materials;
+  bodyDesc = null;
+  body = null;
+  colliderDesc;
+  collider;
+  custom = {};
+  debugInfo = {};
+  debugMaterial;
+  lifeCycleDelegate = {
+    setup: [],
+    update: [],
+    destroy: []
+  };
+  collisionDelegate = {
+    collision: []
+  };
+  collisionType;
+  behaviorCallbackMap = {
+    setup: [],
+    update: [],
+    destroy: [],
+    collision: []
+  };
+  constructor() {
+    super();
+  }
+  create() {
+    const { position: e } = this.options, { x: t, y: i, z: l } = e || { x: 0, y: 0, z: 0 };
+    return this.behaviors = [
+      { component: o, values: { x: t, y: i, z: l } },
+      { component: a, values: { x: 0, y: 0, z: 0 } },
+      { component: n, values: { x: 0, y: 0, z: 0, w: 0 } }
+    ], this.name = this.options.name || "", this;
+  }
+  onSetup(...e) {
+    const t = [...this.lifeCycleDelegate.setup ?? [], ...e];
+    return this.lifeCycleDelegate = {
+      ...this.lifeCycleDelegate,
+      setup: t
+    }, this;
+  }
+  onUpdate(...e) {
+    const t = [...this.lifeCycleDelegate.update ?? [], ...e];
+    return this.lifeCycleDelegate = {
+      ...this.lifeCycleDelegate,
+      update: t
+    }, this;
+  }
+  onDestroy(...e) {
+    return this.lifeCycleDelegate = {
+      ...this.lifeCycleDelegate,
+      destroy: e.length > 0 ? e : void 0
+    }, this;
+  }
+  onCollision(...e) {
+    return this.collisionDelegate = {
+      collision: e.length > 0 ? e : void 0
+    }, this;
+  }
+  _setup(e) {
+    this.behaviorCallbackMap.setup.forEach((t) => {
+      t({ ...e, me: this });
+    }), this.lifeCycleDelegate.setup?.length && this.lifeCycleDelegate.setup.forEach((i) => {
+      i({ ...e, me: this });
+    });
+  }
+  _update(e) {
+    this.updateMaterials(e), this.lifeCycleDelegate.update?.length && this.lifeCycleDelegate.update.forEach((i) => {
+      i({ ...e, me: this });
+    }), this.behaviorCallbackMap.update.forEach((t) => {
+      t({ ...e, me: this });
+    });
+  }
+  _destroy(e) {
+    this.lifeCycleDelegate.destroy?.length && this.lifeCycleDelegate.destroy.forEach((i) => {
+      i({ ...e, me: this });
+    }), this.behaviorCallbackMap.destroy.forEach((t) => {
+      t({ ...e, me: this });
+    });
+  }
+  _collision(e, t) {
+    this.collisionDelegate.collision?.length && this.collisionDelegate.collision.forEach((l) => {
+      l({ entity: this, other: e, globals: t });
+    }), this.behaviorCallbackMap.collision.forEach((i) => {
+      i({ entity: this, other: e, globals: t });
+    });
+  }
+  addBehavior(e) {
+    const t = e.handler;
+    return t && this.behaviorCallbackMap[e.type].push(t), this;
+  }
+  addBehaviors(e) {
+    return e.forEach((t) => {
+      const i = t.handler;
+      i && this.behaviorCallbackMap[t.type].push(i);
+    }), this;
+  }
+  updateMaterials(e) {
+    if (this.materials?.length)
+      for (const t of this.materials)
+        t instanceof s && t.uniforms && t.uniforms.iTime && (t.uniforms.iTime.value += e.delta);
+  }
+  buildInfo() {
+    const e = {};
+    return e.name = this.name, e.uuid = this.uuid, e.eid = this.eid.toString(), e;
+  }
+}
+export {
+  d as GameEntity
+};