Pool.defs.ts

Pool — definitions.

Holds the PoolComponent class and the shapes its data and events travel in. No System lives here, which is the point: another component can name Pool in a query, or type an event it listens for, without pulling Pool's behaviour into its own bundle. Import from here, not from Pool.ts.

Pool.defs.ts

import { Component } from '@babylonjsmarket/ecs';
export { PoolEvents, PoolInputEvents } from './Pool.events';

export interface PoolInput {
  /**
   * Pool name spawners pass to `world.acquire(name)`. Defaults to the blueprint
   * entity's id, so a `"Bullets"` blueprint is acquired as `world.acquire('Bullets')`.
   */
  name?: string
  /** Slots to pre-allocate. Caps concurrent live instances (recycles the oldest when exceeded). */
  size?: number
}

Marks its host entity as a pool blueprint. The host's other components are the template each pooled instance carries; this component itself is never copied onto an instance.

Pool.defs.ts

export class PoolComponent extends Component {
  // Declared, not read off the class name: a minified build renames classes,
  // and the scene file still has to find this class by name.
  static componentType = 'Pool'

  /** Empty string means "use the blueprint entity's id as the pool name". */
  name: string
  size: number

  constructor(data: PoolInput = {}) {
    super()
    this.name = data.name ?? ''
    this.size = data.size ?? 16
  }

  serialize(): PoolInput {
    return { name: this.name || undefined, size: this.size }
  }
}

Pool.events.ts

Pool — event names.

The EventBus contract for Pool: what it emits and what it listens for. A listener imports these names from here, never from Pool.ts, so it can hear Pool without carrying Pool's System. bjs download hands this file out free with any component that imports it, and it does not make Pool a dependency to buy.

Pool.events.ts

// PoolEvents — from Pool (the blueprint-driven entity factory)
export const PoolEvents = {
  /** Emitted once per pool after it finishes pre-allocating its slots. `{ pool, size }`. */
  READY: 'pool.ready',
  /** Emitted when a slot is acquired (via SPAWN). `{ pool, entityId, spawnerId? }`. */
  SPAWNED: 'pool.spawned',
  /**
   * Emitted during reset (after the blueprint config is re-applied) so game
   * systems can apply per-spawn dynamics. `{ pool, entityId, data }`.
   */
  ACQUIRED: 'pool.acquired',
  /** Emitted when a slot is parked back into the pool. `{ pool, entityId }`. */
  RELEASED: 'pool.released',
  /** Emitted when a spawn can't be served (every slot live). `{ pool }`. */
  EXHAUSTED: 'pool.exhausted',
} as const;

// PoolInputEvents — from Pool
export const PoolInputEvents = {
  /** Acquire + place a live entity from a pool. `{ pool, x, y, z, spawnerId?, ...overrides }`. */
  SPAWN: 'pool.spawn',
  /** Park the entity `entityId` back into its pool. `{ entityId }`. */
  RELEASE: 'pool.release',
} as const;

Pool.ts

Pool.ts — the blueprint-driven entity factory (renderer-agnostic System).

For each scene entity carrying a PoolComponent, PoolSystem reads the entity's OTHER components as a template, pre-allocates size parked copies of them via world.registerPool, then consumes the blueprint entity (its component keys have already registered their Systems through the normal scene-keyed path, so it's done its job). Spawners acquire an instance with world.acquire(name) — or fire a pool.spawn event — and park it with world.removeEntity / a pool.release event.

ONE pool for every projectile / wave / debris type: a Bullet blueprint, an Enemy blueprint, a Missile blueprint are all just entities with a Pool marker beside the components their instances carry — no BulletPool / EnemyPool / MissilePool subclasses.

Reuse semantics — on acquire the slot's declared config is re-applied (so HP / speed / lifetime snap back to the blueprint's values) and its tags are reset to exactly the blueprint's, then pool.acquired fires so the spawner can set per-spawn pose / velocity / owner on the returned entity. A declared MeshPrimitive proxy is positioned from the spawn {x,y,z} for classic games; 6-DOF spawners set Transform6DOF on the acquired entity themselves.

No imports from @babylonjs, three, solid-js, or the DOM.

Pool.ts

import { PoolEvents, PoolInputEvents } from './Pool.events';
import { System } from '@babylonjsmarket/ecs'
import type { Entity, World, Component } from '@babylonjsmarket/ecs'
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.defs';
import { MeshComponent } from '../Mesh/Mesh.defs';
import { ShadowComponent } from '../Shadow/Shadow.defs';
import { PoolComponent } from './Pool.defs'

export { PoolComponent, type PoolInput } from './Pool.defs'

/** One captured blueprint component: its class + the config to rebuild it with. */
interface SlotPart {
  Ctor: new (data?: unknown) => Component
  data: Record<string, unknown>
}

/** Spawn payload for the `pool.spawn` event (extra keys ride through to ACQUIRED). */
export interface PoolSpawnEvent {
  pool: string
  x?: number
  y?: number
  z?: number
  spawnerId?: string
  [key: string]: unknown
}

export interface PoolReleaseEvent {
  entityId: string
}

function ctorOf(c: Component): new (data?: unknown) => Component {
  return c.constructor as new (data?: unknown) => Component
}

function serializeOf(c: Component): Record<string, unknown> {
  const s = (c as { serialize?: () => unknown }).serialize
  return typeof s === 'function' ? ((s.call(c) as Record<string, unknown>) ?? {}) : {}
}

export class PoolSystem extends System {
  protected query = { required: [PoolComponent] }

  /** Pool names already registered (idempotent). */
  private registered = new Set<string>()
  /** entityId → pool name, so RELEASE can name the pool on its event. */
  private poolOf = new Map<string, string>()

  protected onInitialize(): void {
    // High priority so a blueprint is captured + consumed early each frame,
    // before spawners try to acquire from it and before it can be drawn.
    this.priority = 900
    this.listen(PoolInputEvents.SPAWN, (e: PoolSpawnEvent) => this.handleSpawn(e))
    this.listen(PoolInputEvents.RELEASE, (e: PoolReleaseEvent) => this.release(e.entityId))
  }

  protected onUpdate(): void {
    const w = this.world
    // Wait for the renderer: `build` pre-creates each slot's mesh, and a
    // renderer-less run (some tests) would allocate handle-less slots.
    if (!w || !w.renderer) return

    // Collect first — registering a pool + consuming its blueprint mutates
    // `this.entities`, which we must not do mid-iteration.
    const blueprints: Array<{ name: string; entity: Entity; size: number }> = []
    for (const entity of this.entities) {
      const comp = entity.get(PoolComponent)
      if (!comp) continue
      const name = comp.name || entity.id
      if (this.registered.has(name)) continue
      blueprints.push({ name, entity, size: comp.size })
    }

    for (const { name, entity, size } of blueprints) {
      this.registerFromBlueprint(w, name, entity, size)
      this.registered.add(name)
      this.eventBus.emit(PoolEvents.READY, { pool: name, size })
    }
  }

  private registerFromBlueprint(w: World, name: string, blueprint: Entity, size: number): void {
    const tags = blueprint.getTags()
    // Capture the template: every component EXCEPT the Pool marker, as
    // { class, config }. `constructor` gives the class, `serialize()` the config.
    const parts = blueprint.getComponents().filter((c) => !(c instanceof PoolComponent))
    // When the blueprint declares a visual `Mesh`, the `MeshPrimitive` is the
    // collision proxy underneath it, not a second body to draw: hide it, and
    // hand the shadow to the model (an invisible caster otherwise drops a
    // capsule-shaped shadow beside the one the model already casts). Demoted
    // ONCE here so `build` and `reset` agree — the same rule EntityPool applied
    // to its declarative `components` map, which this blueprint form replaced.
    const hasVisual = parts.some((c) => c instanceof MeshComponent)
    const spec: SlotPart[] = parts.map((c) => {
      const data = serializeOf(c)
      if (hasVisual && c instanceof MeshPrimitiveComponent) return { Ctor: ctorOf(c), data: { ...data, visible: false } }
      if (hasVisual && c instanceof ShadowComponent) return { Ctor: ctorOf(c), data: { ...data, castShadow: false } }
      return { Ctor: ctorOf(c), data }
    })

    w.registerPool(name, {
      size,
      build: (e: Entity) => {
        for (const t of tags) e.addTag(t)
        for (const { Ctor, data } of spec) e.add(new Ctor(data))
      },
      reset: (e: Entity, data?: unknown) => {
        const d = (data ?? {}) as PoolSpawnEvent
        // A reused slot keeps exactly the blueprint's tags — drop transient ones
        // (e.g. `dead`) added during its last life.
        for (const t of e.getTags()) if (!tags.includes(t)) e.removeTag(t)
        // Re-apply each declared component's config so configured fields snap
        // back; leave runtime state (mesh handles, timers) untouched.
        for (const { Ctor, data: cfg } of spec) {
          const inst = e.get(Ctor as never) as Record<string, unknown> | undefined
          if (!inst) continue
          const fresh = new Ctor(cfg) as unknown as Record<string, unknown>
          for (const k of Object.keys(cfg)) if (k in inst) inst[k] = fresh[k]
        }
        // Classic games: position the MeshPrimitive collision/visual proxy.
        const mp = e.get(MeshPrimitiveComponent)
        if (mp && typeof d.x === 'number') {
          mp.position[0] = d.x
          mp.position[1] = d.y ?? 0
          mp.position[2] = d.z ?? 0
        }
        // Per-spawn dynamics: the spawner sets pose/velocity/owner here or on
        // the acquired entity directly.
        this.eventBus.emit(PoolEvents.ACQUIRED, { pool: name, entityId: e.id, data: d })
      },
    })

    // The blueprint has done its job (its component keys registered their
    // Systems at scene-load; its config seeded the slots). Consume it so it
    // isn't a stray live instance.
    //
    // Blind it first. PoolSystem runs early in the frame, so the blueprint is
    // usually removed BEFORE MeshPrimitiveSystem has built its mesh — and that
    // system's removal hook returns early when there's no handle yet, so the
    // mesh gets created afterwards with nobody left to own or hide it. The
    // result is a stray primitive parked at the world origin for the life of
    // the scene: the twin-stick arena had a bullet-sized sphere sitting under
    // the player's feet. Marking the component invisible works in both
    // orderings, since the create path paints `comp.visible` on the new mesh.
    const bpMesh = blueprint.get(MeshPrimitiveComponent)
    if (bpMesh) bpMesh.visible = false
    w.removeEntity(blueprint)
  }

  private handleSpawn(e: PoolSpawnEvent): void {
    const w = this.world
    if (!w || !this.registered.has(e.pool)) return
    const ent = w.acquire(e.pool, e)
    if (!ent) {
      this.eventBus.emit(PoolEvents.EXHAUSTED, { pool: e.pool })
      return
    }
    this.poolOf.set(ent.id, e.pool)
    this.eventBus.emit(PoolEvents.SPAWNED, { pool: e.pool, entityId: ent.id, spawnerId: e.spawnerId })
  }

  private release(entityId: string): void {
    const w = this.world
    if (!w) return
    const ent = w.getEntity(entityId)
    if (!ent) return
    if (w.release(ent)) {
      this.eventBus.emit(PoolEvents.RELEASED, { pool: this.poolOf.get(entityId) ?? '', entityId })
    }
  }
}
export { PoolEvents, PoolInputEvents } from './Pool.events';

Pool.defs.test.ts

2 ✓

PoolComponent

defaults name to "" (use entity id) and size to 16
round-trips its config through serialize (name omitted when empty)

Last run 2026-10-08

Pool.defs.test.ts

import { describe, it, expect } from 'vitest'
import { PoolComponent } from './Pool.defs'

describe('PoolComponent', () => {
  it('defaults name to "" (use entity id) and size to 16', () => {
    const c = new PoolComponent()
    expect(c.name).toBe('')
    expect(c.size).toBe(16)
  })

  it('round-trips its config through serialize (name omitted when empty)', () => {
    expect(new PoolComponent({ size: 256 }).serialize()).toEqual({ name: undefined, size: 256 })
    expect(new PoolComponent({ name: 'ammo', size: 8 }).serialize()).toEqual({ name: 'ammo', size: 8 })
  })
})

Pool.test.ts

12 ✓

PoolSystem

pre-allocates parked slots from the blueprint, emits READY, and consumes the blueprint
pool name defaults to the blueprint entity id; an explicit name overrides
acquire unparks a slot, positions the MeshPrimitive proxy, and emits ACQUIRED
re-applies the blueprint config on reuse (HP snaps back after a slot is recycled)
emits EXHAUSTED when a spawn can't be served, and ignores spawns for unknown pools
a release for an unknown or non-pooled entity is a no-op
spawn without a position leaves the proxy untouched (no x override)
leaves no stray blueprint primitive behind at the origin
drives spawn/release through the pool.spawn / pool.release events too

PoolSystem › a blueprint carrying a visual Mesh

hides the MeshPrimitive proxy and moves the shadow onto the model
leaves a Mesh-less blueprint drawing its primitive as before
keeps the demotion across a park + reacquire, not just the first build

Last run 2026-10-08

Pool.test.ts

/**
 * PoolSystem tests — the blueprint-driven factory. A blueprint is a scene entity
 * carrying a `Pool` marker beside the components its instances get; the system
 * pre-allocates parked copies, consumes the blueprint, and serves slots via
 * `world.acquire` / the `pool.spawn` event.
 *
 * (System REGISTRATION of the offspring — the reason the template lives in the
 * scene — is an ArcadeGame/scene-load concern proven by the spaceshooter render, not
 * here; these tests wire the offspring systems by hand.)
 */
import { PoolEvents, PoolInputEvents } from './Pool.events';
import { describe, it, expect } from 'vitest'
import { EventBus, World, SceneLoader, MockRendererAdapter } from '@babylonjsmarket/ecs'
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.defs';
import { MeshPrimitiveSystem } from '../MeshPrimitive/MeshPrimitive';
import { HealthComponent } from '../Health/Health.defs';
import { HealthSystem } from '../Health/Health';
import { ShadowComponent } from '../Shadow/Shadow.defs';
import { ShadowSystem } from '../Shadow/Shadow';
import { MeshComponent } from '../Mesh/Mesh.defs';
import { PoolComponent, PoolSystem } from './Pool'

function setup(
  poolData: ConstructorParameters<typeof PoolComponent>[0],
  offspring: { tags?: string[]; mp?: Record<string, unknown>; health?: Record<string, unknown> } = {},
  blueprintId = 'Bullets',
) {
  const eventBus = new EventBus()
  const renderer = new MockRendererAdapter()
  const sceneLoader = new SceneLoader(eventBus)
  sceneLoader.registerComponent('MeshPrimitive', MeshPrimitiveComponent, MeshPrimitiveSystem)
  sceneLoader.registerComponent('Health', HealthComponent, HealthSystem)
  sceneLoader.registerComponent('Pool', PoolComponent, PoolSystem)
  const world = new World({ eventBus, renderer, sceneLoader, detectRaces: false })

  // Blueprint entity: the Pool marker beside the offspring's own components.
  const bp = world.createEntity(blueprintId)
  bp.add(new PoolComponent(poolData))
  for (const t of offspring.tags ?? []) bp.addTag(t)
  bp.add(new MeshPrimitiveComponent(offspring.mp ?? { primitive: 'sphere', diameter: 1 }))
  bp.add(new HealthComponent(offspring.health ?? { hp: 2, maxHp: 2 }))

  for (const s of [
    new MeshPrimitiveSystem(eventBus),
    new HealthSystem(eventBus),
    new PoolSystem(eventBus),
  ]) {
    world.addSystem(s)
  }
  return { eventBus, renderer, world, blueprintId }
}

const slotMeshes = (renderer: MockRendererAdapter, pool: string) =>
  renderer.calls.filter(
    (c) => c.method === 'createMesh' && new RegExp(`^${pool}-\\d`).test(String(c.args[0])),
  )

describe('PoolSystem', () => {
  it('pre-allocates parked slots from the blueprint, emits READY, and consumes the blueprint', () => {
    const ready: unknown[] = []
    const { eventBus, renderer, world } = setup({ size: 4 }, { tags: ['bullet'] })
    eventBus.on(PoolEvents.READY, (e) => ready.push(e))

    world.update(1 / 60)

    // 4 slots built (one mesh each), and all parked (inactive).
    expect(slotMeshes(renderer, 'Bullets').length).toBe(4)
    expect(world.getEntitiesByTag('bullet').filter((e) => e.active).length).toBe(0)
    expect(world.getEntitiesByTag('bullet').length).toBe(4)
    expect(ready).toEqual([{ pool: 'Bullets', size: 4 }])
    // The blueprint template is gone — it was only there to seed slots + register systems.
    expect(world.getEntity('Bullets')).toBeUndefined()
  })

  it('pool name defaults to the blueprint entity id; an explicit name overrides', () => {
    const { world } = setup({ size: 2, name: 'ammo' }, {}, 'Bullets')
    world.update(1 / 60)
    expect(world.acquire('ammo', {})).not.toBeNull()
    expect(world.acquire('Bullets', {})).toBeNull() // the id is NOT the pool name when overridden
  })

  it('acquire unparks a slot, positions the MeshPrimitive proxy, and emits ACQUIRED', () => {
    const acquired: Array<{ pool: string; entityId: string }> = []
    const { eventBus, world } = setup({ size: 3 }, { tags: ['bullet'] })
    eventBus.on(PoolEvents.ACQUIRED, (e) => acquired.push(e as never))
    world.update(1 / 60)

    const ent = world.acquire('Bullets', { x: 5, y: 6, z: 7 })
    expect(ent).not.toBeNull()
    expect(ent!.active).toBe(true)
    const mp = ent!.get(MeshPrimitiveComponent)!
    expect([mp.position[0], mp.position[1], mp.position[2]]).toEqual([5, 6, 7])
    expect(acquired.length).toBe(1)
    expect(acquired[0].pool).toBe('Bullets')
  })

  it('re-applies the blueprint config on reuse (HP snaps back after a slot is recycled)', () => {
    const { world } = setup({ size: 1 }, { health: { hp: 2, maxHp: 2 } })
    world.update(1 / 60)

    const first = world.acquire('Bullets', { x: 0, y: 0, z: 0 })!
    first.get(HealthComponent)!.hp = 0 // "damaged" during its life
    world.removeEntity(first) // pool-owned → parked back

    const reused = world.acquire('Bullets', { x: 1, y: 1, z: 1 })!
    expect(reused).toBe(first) // same slot recycled
    expect(reused.get(HealthComponent)!.hp).toBe(2) // config re-applied
  })

  it('emits EXHAUSTED when a spawn can\'t be served, and ignores spawns for unknown pools', () => {
    const exhausted: unknown[] = []
    const spawned: unknown[] = []
    const { eventBus, world } = setup({ size: 0 }, { tags: ['bullet'] })
    eventBus.on(PoolEvents.EXHAUSTED, (e) => exhausted.push(e))
    eventBus.on(PoolEvents.SPAWNED, (e) => spawned.push(e))
    world.update(1 / 60)

    eventBus.emit(PoolInputEvents.SPAWN, { pool: 'Bullets', x: 0, y: 0, z: 0 }) // size 0 → exhausted
    eventBus.emit(PoolInputEvents.SPAWN, { pool: 'nope', x: 0, y: 0, z: 0 }) // unknown → ignored
    expect(exhausted).toEqual([{ pool: 'Bullets' }])
    expect(spawned).toEqual([])
  })

  it('a release for an unknown or non-pooled entity is a no-op', () => {
    const released: unknown[] = []
    const { eventBus, world } = setup({ size: 1 }, { tags: ['bullet'] })
    eventBus.on(PoolEvents.RELEASED, (e) => released.push(e))
    world.update(1 / 60)

    eventBus.emit(PoolInputEvents.RELEASE, { entityId: 'does-not-exist' }) // getEntity → undefined
    const plain = world.createEntity('plain') // not pool-owned
    eventBus.emit(PoolInputEvents.RELEASE, { entityId: plain.id }) // world.release → false
    expect(released).toEqual([])
  })

  it('spawn without a position leaves the proxy untouched (no x override)', () => {
    const { eventBus, world } = setup({ size: 1 }, { tags: ['bullet'], mp: { primitive: 'sphere', diameter: 1 } })
    world.update(1 / 60)
    const ent = world.acquire('Bullets', {}) // no x/y/z
    const mp = ent!.get(MeshPrimitiveComponent)!
    expect([mp.position[0], mp.position[1], mp.position[2]]).toEqual([0, 0, 0])
  })

  it('leaves no stray blueprint primitive behind at the origin', () => {
    // The blueprint is an ordinary entity, so MeshPrimitiveSystem will happily
    // build it a mesh. Consuming the blueprint has to blind that mesh, or the
    // scene keeps a spare sphere parked at 0,0,0 forever.
    const { world, renderer } = setup({ size: 2 }, { tags: ['bullet'] })
    world.update(1 / 60)
    world.update(1 / 60)

    // Whichever order the two systems ran in, nothing of the blueprint's own
    // mesh may survive: never minted at all (the World no longer hands a
    // mid-destroy entity back to MeshPrimitiveSystem, which is how the stray
    // used to get built), or painted false at creation if Pool got there
    // first, or disposed on the removal flush if MeshPrimitive did.
    const isBlueprintMesh = (h: unknown) =>
      (h as { __mockHandle?: string })?.__mockHandle === 'mesh:Bullets'
    const created = renderer.calls.filter((c) => c.method === 'createMesh' && c.args[0] === 'Bullets')
    if (created.length > 0) {
      const painted = renderer.calls
        .filter((c) => c.method === 'setMeshVisible' && isBlueprintMesh(c.args[0]))
        .pop()
      const disposed = renderer.calls.some((c) => c.method === 'disposeMesh' && isBlueprintMesh(c.args[0]))
      expect(disposed || painted?.args[1] === false).toBe(true)
    }
    expect(world.getEntity('Bullets')).toBeUndefined()
  })

  // A blueprint that draws a GLB has two bodies: the model you see and the
  // MeshPrimitive underneath it doing collision. Drawing both put a red sphere
  // inside every robot in TwinStickArena — this is the demotion EntityPool did
  // for its `components` map, carried over to the blueprint form.
  describe('a blueprint carrying a visual Mesh', () => {
    function withMesh(mesh?: Record<string, unknown>) {
      const eventBus = new EventBus()
      const sceneLoader = new SceneLoader(eventBus)
      sceneLoader.registerComponent('MeshPrimitive', MeshPrimitiveComponent, MeshPrimitiveSystem)
      sceneLoader.registerComponent('Shadow', ShadowComponent, ShadowSystem)
      sceneLoader.registerComponent('Mesh', MeshComponent)
      sceneLoader.registerComponent('Pool', PoolComponent, PoolSystem)
      const world = new World({ eventBus, renderer: new MockRendererAdapter(), sceneLoader, detectRaces: false })

      const bp = world.createEntity('Enemies')
      bp.add(new PoolComponent({ size: 2, name: 'enemy' }))
      bp.add(new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2 }))
      bp.add(new ShadowComponent({ castShadow: true, receiveShadow: false }))
      if (mesh) bp.add(new MeshComponent(mesh))
      for (const s of [new MeshPrimitiveSystem(eventBus), new ShadowSystem(eventBus), new PoolSystem(eventBus)]) {
        world.addSystem(s)
      }
      world.update(1 / 60)
      return world
    }

    it('hides the MeshPrimitive proxy and moves the shadow onto the model', () => {
      const slot = withMesh({ src: '/bot.glb', instanced: true, follow: true })!.acquire('enemy')!
      expect(slot.get(MeshPrimitiveComponent)!.visible).toBe(false)
      expect(slot.get(ShadowComponent)!.castShadow).toBe(false)
    })

    it('leaves a Mesh-less blueprint drawing its primitive as before', () => {
      const slot = withMesh()!.acquire('enemy')!
      expect(slot.get(MeshPrimitiveComponent)!.visible).toBe(true)
      expect(slot.get(ShadowComponent)!.castShadow).toBe(true)
    })

    it('keeps the demotion across a park + reacquire, not just the first build', () => {
      const world = withMesh({ src: '/bot.glb', instanced: true, follow: true })
      const first = world.acquire('enemy')!
      first.get(MeshPrimitiveComponent)!.visible = true // a live system flips it back on
      world.removeEntity(first.id)
      const again = world.acquire('enemy')!
      expect(again.get(MeshPrimitiveComponent)!.visible).toBe(false)
    })
  })

  it('drives spawn/release through the pool.spawn / pool.release events too', () => {
    const spawned: Array<{ entityId: string }> = []
    const released: unknown[] = []
    const { eventBus, world } = setup({ size: 2 }, { tags: ['bullet'] })
    eventBus.on(PoolEvents.SPAWNED, (e) => spawned.push(e as never))
    eventBus.on(PoolEvents.RELEASED, (e) => released.push(e))
    world.update(1 / 60)

    eventBus.emit(PoolInputEvents.SPAWN, { pool: 'Bullets', x: 0, y: 0, z: 0 })
    expect(spawned.length).toBe(1)
    expect(world.getEntitiesByTag('bullet').filter((e) => e.active).length).toBe(1)

    eventBus.emit(PoolInputEvents.RELEASE, { entityId: spawned[0].entityId })
    expect(released.length).toBe(1)
    expect(world.getEntitiesByTag('bullet').filter((e) => e.active).length).toBe(0)
  })
})

Pool

Pool

What it does

Use it in a scene

Props

Events

Dependencies

Notes

Pool.defs.ts

Pool.events.ts

Pool.ts

Pool.defs.test.ts

Pool.defs.test.ts

Pool.test.ts

Pool.test.ts

More like this

Was this page helpful?