@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/performance/ObjectPooling.js

@@ -1,638 +1,604 @@
-/**
- * @file ObjectPooling.ts
- * @description Automatic object pool management for bullets, particles, etc.
- * PRO-1.5: Runtime & Performance
- *
- * Features:
- * - Generic object pooling
- * - Automatic pool expansion
- * - Pool warming
- * - Pool shrinking/compaction
- * - Multiple pool types
- * - Statistics tracking
- * - Async object creation
- * - Pool groups/categories
- */
-// ============================================================
-// Default Configuration
-// ============================================================
 const DEFAULT_POOL_CONFIG = {
-    initialSize: 10,
-    maxSize: 1000,
-    growthFactor: 2,
-    shrinkThreshold: 0.25,
-    shrinkDelay: 10000,
-    warmOnCreate: true,
-    resetOnRelease: true,
-    validateOnAcquire: false,
+  initialSize: 10,
+  maxSize: 1e3,
+  growthFactor: 2,
+  shrinkThreshold: 0.25,
+  shrinkDelay: 1e4,
+  warmOnCreate: true,
+  resetOnRelease: true,
+  validateOnAcquire: false
 };
-// ============================================================
-// Object Pool
-// ============================================================
 class ObjectPool {
-    constructor(config) {
-        this.available = [];
-        this.active = new Set();
-        this.shrinkTimer = null;
-        this.lastLowUsageTime = 0;
-        this.config = { ...DEFAULT_POOL_CONFIG, ...config };
-        this.stats = {
-            name: this.config.name,
-            totalCreated: 0,
-            activeCount: 0,
-            availableCount: 0,
-            peakUsage: 0,
-            acquireCount: 0,
-            releaseCount: 0,
-            missCount: 0,
-            growCount: 0,
-            shrinkCount: 0,
-            lastUsed: Date.now(),
-        };
-        if (this.config.warmOnCreate) {
-            this.warm(this.config.initialSize);
-        }
-    }
-    /**
-     * Pre-create objects to fill the pool
-     */
-    warm(count) {
-        const toCreate = Math.min(count, this.config.maxSize - this.totalSize());
-        for (let i = 0; i < toCreate; i++) {
-            const obj = this.createObject();
-            this.available.push(obj);
-        }
-        this.stats.availableCount = this.available.length;
-    }
-    /**
-     * Acquire an object from the pool
-     */
-    acquire() {
-        this.stats.acquireCount++;
-        this.stats.lastUsed = Date.now();
-        // Try to get from available pool
-        let obj = this.available.pop();
-        // If empty, try to grow
-        if (!obj) {
-            if (this.totalSize() < this.config.maxSize) {
-                this.grow();
-                obj = this.available.pop();
-            }
-        }
-        if (!obj) {
-            this.stats.missCount++;
-            return null;
-        }
-        // Validate if configured
-        if (this.config.validateOnAcquire && this.config.validator) {
-            if (!this.config.validator(obj)) {
-                // Object is invalid, create a new one
-                obj = this.createObject();
-            }
-        }
-        this.active.add(obj);
-        this.stats.activeCount = this.active.size;
-        this.stats.availableCount = this.available.length;
-        this.stats.peakUsage = Math.max(this.stats.peakUsage, this.active.size);
-        if (obj.isActive !== undefined) {
-            obj.isActive = true;
-        }
-        obj.onAcquire?.();
-        // Cancel shrink timer while pool is active
-        this.cancelShrink();
-        return obj;
-    }
-    /**
-     * Acquire multiple objects at once
-     */
-    acquireMultiple(count) {
-        const objects = [];
-        for (let i = 0; i < count; i++) {
-            const obj = this.acquire();
-            if (obj) {
-                objects.push(obj);
-            }
-            else {
-                break;
-            }
-        }
-        return objects;
-    }
-    /**
-     * Release an object back to the pool
-     */
-    release(obj) {
-        if (!this.active.has(obj)) {
-            return;
-        }
-        this.stats.releaseCount++;
-        this.stats.lastUsed = Date.now();
-        this.active.delete(obj);
-        if (obj.isActive !== undefined) {
-            obj.isActive = false;
-        }
-        obj.onRelease?.();
-        if (this.config.resetOnRelease) {
-            obj.reset();
-        }
-        this.available.push(obj);
-        this.stats.activeCount = this.active.size;
-        this.stats.availableCount = this.available.length;
-        // Check for shrinking
-        this.checkShrink();
-    }
-    /**
-     * Release all active objects
-     */
-    releaseAll() {
-        for (const obj of this.active) {
-            if (obj.isActive !== undefined) {
-                obj.isActive = false;
-            }
-            obj.onRelease?.();
-            if (this.config.resetOnRelease) {
-                obj.reset();
-            }
-            this.available.push(obj);
-        }
-        this.stats.releaseCount += this.active.size;
-        this.active.clear();
-        this.stats.activeCount = 0;
-        this.stats.availableCount = this.available.length;
-    }
-    /**
-     * Clear the pool completely
-     */
-    clear() {
-        this.active.clear();
-        this.available = [];
-        this.stats.activeCount = 0;
-        this.stats.availableCount = 0;
-        this.cancelShrink();
-    }
-    /**
-     * Get current statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Get pool configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Update pool configuration
-     */
-    setConfig(config) {
-        this.config = { ...this.config, ...config };
-    }
-    /**
-     * Check if an object belongs to this pool
-     */
-    contains(obj) {
-        return this.active.has(obj) || this.available.includes(obj);
-    }
-    /**
-     * Get iterator over active objects
-     */
-    getActive() {
-        return this.active.values();
-    }
-    /**
-     * Execute callback for each active object
-     */
-    forEachActive(callback) {
-        for (const obj of this.active) {
-            callback(obj);
-        }
-    }
-    // ─── Private Methods ───────────────────────────────────
-    totalSize() {
-        return this.active.size + this.available.length;
-    }
-    createObject() {
-        const obj = this.config.factory();
-        this.stats.totalCreated++;
-        return obj;
-    }
-    grow() {
-        const currentSize = this.totalSize();
-        const newSize = Math.min(Math.ceil(currentSize * this.config.growthFactor), this.config.maxSize);
-        const toCreate = newSize - currentSize;
-        for (let i = 0; i < toCreate; i++) {
-            const obj = this.createObject();
-            this.available.push(obj);
-        }
-        this.stats.growCount++;
-        this.stats.availableCount = this.available.length;
-    }
-    checkShrink() {
-        const currentSize = this.totalSize();
-        const usage = this.active.size / currentSize;
-        if (usage < this.config.shrinkThreshold && currentSize > this.config.initialSize) {
-            if (this.lastLowUsageTime === 0) {
-                this.lastLowUsageTime = Date.now();
-            }
-            if (!this.shrinkTimer) {
-                this.shrinkTimer = setTimeout(() => {
-                    this.shrink();
-                }, this.config.shrinkDelay);
-            }
-        }
-        else {
-            this.lastLowUsageTime = 0;
-            this.cancelShrink();
-        }
-    }
-    shrink() {
-        this.cancelShrink();
-        const currentSize = this.totalSize();
-        const targetSize = Math.max(this.config.initialSize, Math.ceil(this.active.size * 2));
-        const toRemove = currentSize - targetSize;
-        if (toRemove > 0) {
-            this.available.splice(0, Math.min(toRemove, this.available.length));
-            this.stats.shrinkCount++;
-            this.stats.availableCount = this.available.length;
-        }
-        this.lastLowUsageTime = 0;
-    }
-    cancelShrink() {
-        if (this.shrinkTimer) {
-            clearTimeout(this.shrinkTimer);
-            this.shrinkTimer = null;
-        }
-    }
+  constructor(config) {
+    this.available = [];
+    this.active = /* @__PURE__ */ new Set();
+    this.shrinkTimer = null;
+    this.lastLowUsageTime = 0;
+    this.config = { ...DEFAULT_POOL_CONFIG, ...config };
+    this.stats = {
+      name: this.config.name,
+      totalCreated: 0,
+      activeCount: 0,
+      availableCount: 0,
+      peakUsage: 0,
+      acquireCount: 0,
+      releaseCount: 0,
+      missCount: 0,
+      growCount: 0,
+      shrinkCount: 0,
+      lastUsed: Date.now()
+    };
+    if (this.config.warmOnCreate) {
+      this.warm(this.config.initialSize);
+    }
+  }
+  /**
+   * Pre-create objects to fill the pool
+   */
+  warm(count) {
+    const toCreate = Math.min(count, this.config.maxSize - this.totalSize());
+    for (let i = 0; i < toCreate; i++) {
+      const obj = this.createObject();
+      this.available.push(obj);
+    }
+    this.stats.availableCount = this.available.length;
+  }
+  /**
+   * Acquire an object from the pool
+   */
+  acquire() {
+    this.stats.acquireCount++;
+    this.stats.lastUsed = Date.now();
+    let obj = this.available.pop();
+    if (!obj) {
+      if (this.totalSize() < this.config.maxSize) {
+        this.grow();
+        obj = this.available.pop();
+      }
+    }
+    if (!obj) {
+      this.stats.missCount++;
+      return null;
+    }
+    if (this.config.validateOnAcquire && this.config.validator) {
+      if (!this.config.validator(obj)) {
+        obj = this.createObject();
+      }
+    }
+    this.active.add(obj);
+    this.stats.activeCount = this.active.size;
+    this.stats.availableCount = this.available.length;
+    this.stats.peakUsage = Math.max(this.stats.peakUsage, this.active.size);
+    if (obj.isActive !== void 0) {
+      obj.isActive = true;
+    }
+    obj.onAcquire?.();
+    this.cancelShrink();
+    return obj;
+  }
+  /**
+   * Acquire multiple objects at once
+   */
+  acquireMultiple(count) {
+    const objects = [];
+    for (let i = 0; i < count; i++) {
+      const obj = this.acquire();
+      if (obj) {
+        objects.push(obj);
+      } else {
+        break;
+      }
+    }
+    return objects;
+  }
+  /**
+   * Release an object back to the pool
+   */
+  release(obj) {
+    if (!this.active.has(obj)) {
+      return;
+    }
+    this.stats.releaseCount++;
+    this.stats.lastUsed = Date.now();
+    this.active.delete(obj);
+    if (obj.isActive !== void 0) {
+      obj.isActive = false;
+    }
+    obj.onRelease?.();
+    if (this.config.resetOnRelease) {
+      obj.reset();
+    }
+    this.available.push(obj);
+    this.stats.activeCount = this.active.size;
+    this.stats.availableCount = this.available.length;
+    this.checkShrink();
+  }
+  /**
+   * Release all active objects
+   */
+  releaseAll() {
+    for (const obj of this.active) {
+      if (obj.isActive !== void 0) {
+        obj.isActive = false;
+      }
+      obj.onRelease?.();
+      if (this.config.resetOnRelease) {
+        obj.reset();
+      }
+      this.available.push(obj);
+    }
+    this.stats.releaseCount += this.active.size;
+    this.active.clear();
+    this.stats.activeCount = 0;
+    this.stats.availableCount = this.available.length;
+  }
+  /**
+   * Clear the pool completely
+   */
+  clear() {
+    this.active.clear();
+    this.available = [];
+    this.stats.activeCount = 0;
+    this.stats.availableCount = 0;
+    this.cancelShrink();
+  }
+  /**
+   * Get current statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Get pool configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update pool configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Check if an object belongs to this pool
+   */
+  contains(obj) {
+    return this.active.has(obj) || this.available.includes(obj);
+  }
+  /**
+   * Get iterator over active objects
+   */
+  getActive() {
+    return this.active.values();
+  }
+  /**
+   * Execute callback for each active object
+   */
+  forEachActive(callback) {
+    for (const obj of this.active) {
+      callback(obj);
+    }
+  }
+  // ─── Private Methods ───────────────────────────────────
+  totalSize() {
+    return this.active.size + this.available.length;
+  }
+  createObject() {
+    const obj = this.config.factory();
+    this.stats.totalCreated++;
+    return obj;
+  }
+  grow() {
+    const currentSize = this.totalSize();
+    const newSize = Math.min(
+      Math.ceil(currentSize * this.config.growthFactor),
+      this.config.maxSize
+    );
+    const toCreate = newSize - currentSize;
+    for (let i = 0; i < toCreate; i++) {
+      const obj = this.createObject();
+      this.available.push(obj);
+    }
+    this.stats.growCount++;
+    this.stats.availableCount = this.available.length;
+  }
+  checkShrink() {
+    const currentSize = this.totalSize();
+    const usage = this.active.size / currentSize;
+    if (usage < this.config.shrinkThreshold && currentSize > this.config.initialSize) {
+      if (this.lastLowUsageTime === 0) {
+        this.lastLowUsageTime = Date.now();
+      }
+      if (!this.shrinkTimer) {
+        this.shrinkTimer = setTimeout(() => {
+          this.shrink();
+        }, this.config.shrinkDelay);
+      }
+    } else {
+      this.lastLowUsageTime = 0;
+      this.cancelShrink();
+    }
+  }
+  shrink() {
+    this.cancelShrink();
+    const currentSize = this.totalSize();
+    const targetSize = Math.max(this.config.initialSize, Math.ceil(this.active.size * 2));
+    const toRemove = currentSize - targetSize;
+    if (toRemove > 0) {
+      this.available.splice(0, Math.min(toRemove, this.available.length));
+      this.stats.shrinkCount++;
+      this.stats.availableCount = this.available.length;
+    }
+    this.lastLowUsageTime = 0;
+  }
+  cancelShrink() {
+    if (this.shrinkTimer) {
+      clearTimeout(this.shrinkTimer);
+      this.shrinkTimer = null;
+    }
+  }
 }
-// ============================================================
-// Pool Manager
-// ============================================================
 class PoolManager {
-    constructor() {
-        this.pools = new Map();
-        this.groups = new Map();
-    }
-    /**
-     * Create a new pool
-     */
-    createPool(config, groupName) {
-        if (this.pools.has(config.name)) {
-            throw new Error(`Pool "${config.name}" already exists`);
-        }
-        const pool = new ObjectPool(config);
-        this.pools.set(config.name, pool);
-        if (groupName) {
-            if (!this.groups.has(groupName)) {
-                this.groups.set(groupName, new Set());
-            }
-            this.groups.get(groupName).add(config.name);
-        }
-        return pool;
-    }
-    /**
-     * Get an existing pool
-     */
-    getPool(name) {
-        return this.pools.get(name);
-    }
-    /**
-     * Remove a pool
-     */
-    removePool(name) {
-        const pool = this.pools.get(name);
-        if (!pool) {
-            return false;
-        }
-        pool.clear();
-        this.pools.delete(name);
-        // Remove from groups
-        for (const group of this.groups.values()) {
-            group.delete(name);
-        }
-        return true;
-    }
-    /**
-     * Acquire from a specific pool
-     */
-    acquire(poolName) {
-        const pool = this.pools.get(poolName);
-        return pool?.acquire() ?? null;
-    }
-    /**
-     * Release to a specific pool
-     */
-    release(poolName, obj) {
-        const pool = this.pools.get(poolName);
-        pool?.release(obj);
-    }
-    /**
-     * Release all objects in a pool
-     */
-    releaseAll(poolName) {
-        this.pools.get(poolName)?.releaseAll();
-    }
-    /**
-     * Release all objects in all pools
-     */
-    releaseAllPools() {
-        for (const pool of this.pools.values()) {
-            pool.releaseAll();
-        }
-    }
-    /**
-     * Clear a specific pool
-     */
-    clearPool(poolName) {
-        this.pools.get(poolName)?.clear();
-    }
-    /**
-     * Clear all pools
-     */
-    clearAll() {
-        for (const pool of this.pools.values()) {
-            pool.clear();
-        }
-    }
-    /**
-     * Warm a specific pool
-     */
-    warmPool(poolName, count) {
-        this.pools.get(poolName)?.warm(count);
-    }
-    /**
-     * Warm all pools to their initial size
-     */
-    warmAllPools() {
-        for (const pool of this.pools.values()) {
-            const config = pool.getConfig();
-            const stats = pool.getStats();
-            const needed = config.initialSize - stats.availableCount;
-            if (needed > 0) {
-                pool.warm(needed);
-            }
-        }
-    }
-    /**
-     * Get stats for a specific pool
-     */
-    getPoolStats(name) {
-        return this.pools.get(name)?.getStats();
-    }
-    /**
-     * Get stats for all pools
-     */
-    getAllStats() {
-        return Array.from(this.pools.values()).map((p) => p.getStats());
-    }
-    /**
-     * Get stats for a pool group
-     */
-    getGroupStats(groupName) {
-        const poolNames = this.groups.get(groupName);
-        if (!poolNames) {
-            return undefined;
-        }
-        let totalActive = 0;
-        let totalAvailable = 0;
-        for (const name of poolNames) {
-            const stats = this.pools.get(name)?.getStats();
-            if (stats) {
-                totalActive += stats.activeCount;
-                totalAvailable += stats.availableCount;
-            }
-        }
-        return {
-            groupName,
-            poolCount: poolNames.size,
-            totalActive,
-            totalAvailable,
-            totalMemory: 0, // Would need size estimation
-        };
-    }
-    /**
-     * Get all pool names
-     */
-    getPoolNames() {
-        return Array.from(this.pools.keys());
-    }
-    /**
-     * Get pool names in a group
-     */
-    getGroupPoolNames(groupName) {
-        return Array.from(this.groups.get(groupName) ?? []);
-    }
+  constructor() {
+    this.pools = /* @__PURE__ */ new Map();
+    this.groups = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new pool
+   */
+  createPool(config, groupName) {
+    if (this.pools.has(config.name)) {
+      throw new Error(`Pool "${config.name}" already exists`);
+    }
+    const pool = new ObjectPool(config);
+    this.pools.set(config.name, pool);
+    if (groupName) {
+      if (!this.groups.has(groupName)) {
+        this.groups.set(groupName, /* @__PURE__ */ new Set());
+      }
+      this.groups.get(groupName).add(config.name);
+    }
+    return pool;
+  }
+  /**
+   * Get an existing pool
+   */
+  getPool(name) {
+    return this.pools.get(name);
+  }
+  /**
+   * Remove a pool
+   */
+  removePool(name) {
+    const pool = this.pools.get(name);
+    if (!pool) {
+      return false;
+    }
+    pool.clear();
+    this.pools.delete(name);
+    for (const group of this.groups.values()) {
+      group.delete(name);
+    }
+    return true;
+  }
+  /**
+   * Acquire from a specific pool
+   */
+  acquire(poolName) {
+    const pool = this.pools.get(poolName);
+    return pool?.acquire() ?? null;
+  }
+  /**
+   * Release to a specific pool
+   */
+  release(poolName, obj) {
+    const pool = this.pools.get(poolName);
+    pool?.release(obj);
+  }
+  /**
+   * Release all objects in a pool
+   */
+  releaseAll(poolName) {
+    this.pools.get(poolName)?.releaseAll();
+  }
+  /**
+   * Release all objects in all pools
+   */
+  releaseAllPools() {
+    for (const pool of this.pools.values()) {
+      pool.releaseAll();
+    }
+  }
+  /**
+   * Clear a specific pool
+   */
+  clearPool(poolName) {
+    this.pools.get(poolName)?.clear();
+  }
+  /**
+   * Clear all pools
+   */
+  clearAll() {
+    for (const pool of this.pools.values()) {
+      pool.clear();
+    }
+  }
+  /**
+   * Warm a specific pool
+   */
+  warmPool(poolName, count) {
+    this.pools.get(poolName)?.warm(count);
+  }
+  /**
+   * Warm all pools to their initial size
+   */
+  warmAllPools() {
+    for (const pool of this.pools.values()) {
+      const config = pool.getConfig();
+      const stats = pool.getStats();
+      const needed = config.initialSize - stats.availableCount;
+      if (needed > 0) {
+        pool.warm(needed);
+      }
+    }
+  }
+  /**
+   * Get stats for a specific pool
+   */
+  getPoolStats(name) {
+    return this.pools.get(name)?.getStats();
+  }
+  /**
+   * Get stats for all pools
+   */
+  getAllStats() {
+    return Array.from(this.pools.values()).map((p) => p.getStats());
+  }
+  /**
+   * Get stats for a pool group
+   */
+  getGroupStats(groupName) {
+    const poolNames = this.groups.get(groupName);
+    if (!poolNames) {
+      return void 0;
+    }
+    let totalActive = 0;
+    let totalAvailable = 0;
+    for (const name of poolNames) {
+      const stats = this.pools.get(name)?.getStats();
+      if (stats) {
+        totalActive += stats.activeCount;
+        totalAvailable += stats.availableCount;
+      }
+    }
+    return {
+      groupName,
+      poolCount: poolNames.size,
+      totalActive,
+      totalAvailable,
+      totalMemory: 0
+      // Would need size estimation
+    };
+  }
+  /**
+   * Get all pool names
+   */
+  getPoolNames() {
+    return Array.from(this.pools.keys());
+  }
+  /**
+   * Get pool names in a group
+   */
+  getGroupPoolNames(groupName) {
+    return Array.from(this.groups.get(groupName) ?? []);
+  }
 }
-// ============================================================
-// Pre-built Poolable Classes
-// ============================================================
-/**
- * Simple poolable vector
- */
 class PoolableVector3 {
-    constructor() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-        this.isActive = false;
-    }
-    reset() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-    }
-    set(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        return this;
-    }
-    copy(other) {
-        this.x = other.x;
-        this.y = other.y;
-        this.z = other.z;
-        return this;
-    }
-    add(other) {
-        this.x += other.x;
-        this.y += other.y;
-        this.z += other.z;
-        return this;
-    }
-    scale(s) {
-        this.x *= s;
-        this.y *= s;
-        this.z *= s;
-        return this;
-    }
-    length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-    }
-    normalize() {
-        const len = this.length();
-        if (len > 0) {
-            this.x /= len;
-            this.y /= len;
-            this.z /= len;
-        }
-        return this;
-    }
+  constructor() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.isActive = false;
+  }
+  reset() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+  }
+  set(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    return this;
+  }
+  copy(other) {
+    this.x = other.x;
+    this.y = other.y;
+    this.z = other.z;
+    return this;
+  }
+  add(other) {
+    this.x += other.x;
+    this.y += other.y;
+    this.z += other.z;
+    return this;
+  }
+  scale(s) {
+    this.x *= s;
+    this.y *= s;
+    this.z *= s;
+    return this;
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  normalize() {
+    const len = this.length();
+    if (len > 0) {
+      this.x /= len;
+      this.y /= len;
+      this.z /= len;
+    }
+    return this;
+  }
 }
-/**
- * Poolable particle
- */
 class PoolableParticle {
-    constructor() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-        this.vx = 0;
-        this.vy = 0;
-        this.vz = 0;
-        this.life = 0;
-        this.maxLife = 1;
-        this.size = 1;
-        this.color = 0xffffff;
-        this.alpha = 1;
-        this.rotation = 0;
-        this.rotationSpeed = 0;
-        this.isActive = false;
-    }
-    reset() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-        this.vx = 0;
-        this.vy = 0;
-        this.vz = 0;
-        this.life = 0;
-        this.maxLife = 1;
-        this.size = 1;
-        this.color = 0xffffff;
-        this.alpha = 1;
-        this.rotation = 0;
-        this.rotationSpeed = 0;
-    }
-    update(dt) {
-        this.x += this.vx * dt;
-        this.y += this.vy * dt;
-        this.z += this.vz * dt;
-        this.rotation += this.rotationSpeed * dt;
-        this.life += dt;
-    }
-    get normalizedLife() {
-        return this.life / this.maxLife;
-    }
-    get isDead() {
-        return this.life >= this.maxLife;
-    }
+  constructor() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.vx = 0;
+    this.vy = 0;
+    this.vz = 0;
+    this.life = 0;
+    this.maxLife = 1;
+    this.size = 1;
+    this.color = 16777215;
+    this.alpha = 1;
+    this.rotation = 0;
+    this.rotationSpeed = 0;
+    this.isActive = false;
+  }
+  reset() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.vx = 0;
+    this.vy = 0;
+    this.vz = 0;
+    this.life = 0;
+    this.maxLife = 1;
+    this.size = 1;
+    this.color = 16777215;
+    this.alpha = 1;
+    this.rotation = 0;
+    this.rotationSpeed = 0;
+  }
+  update(dt) {
+    this.x += this.vx * dt;
+    this.y += this.vy * dt;
+    this.z += this.vz * dt;
+    this.rotation += this.rotationSpeed * dt;
+    this.life += dt;
+  }
+  get normalizedLife() {
+    return this.life / this.maxLife;
+  }
+  get isDead() {
+    return this.life >= this.maxLife;
+  }
 }
-/**
- * Poolable bullet/projectile
- */
 class PoolableBullet {
-    constructor() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-        this.dirX = 0;
-        this.dirY = 0;
-        this.dirZ = 1;
-        this.speed = 10;
-        this.damage = 1;
-        this.ownerId = '';
-        this.lifetime = 0;
-        this.maxLifetime = 5;
-        this.isActive = false;
-    }
-    reset() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-        this.dirX = 0;
-        this.dirY = 0;
-        this.dirZ = 1;
-        this.speed = 10;
-        this.damage = 1;
-        this.ownerId = '';
-        this.lifetime = 0;
-        this.maxLifetime = 5;
-    }
-    update(dt) {
-        this.x += this.dirX * this.speed * dt;
-        this.y += this.dirY * this.speed * dt;
-        this.z += this.dirZ * this.speed * dt;
-        this.lifetime += dt;
-    }
-    get isExpired() {
-        return this.lifetime >= this.maxLifetime;
-    }
+  constructor() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.dirX = 0;
+    this.dirY = 0;
+    this.dirZ = 1;
+    this.speed = 10;
+    this.damage = 1;
+    this.ownerId = "";
+    this.lifetime = 0;
+    this.maxLifetime = 5;
+    this.isActive = false;
+  }
+  reset() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.dirX = 0;
+    this.dirY = 0;
+    this.dirZ = 1;
+    this.speed = 10;
+    this.damage = 1;
+    this.ownerId = "";
+    this.lifetime = 0;
+    this.maxLifetime = 5;
+  }
+  update(dt) {
+    this.x += this.dirX * this.speed * dt;
+    this.y += this.dirY * this.speed * dt;
+    this.z += this.dirZ * this.speed * dt;
+    this.lifetime += dt;
+  }
+  get isExpired() {
+    return this.lifetime >= this.maxLifetime;
+  }
 }
-/**
- * Poolable generic event
- */
 class PoolableEvent {
-    constructor() {
-        this.type = '';
-        this.data = null;
-        this.timestamp = 0;
-        this.handled = false;
-        this.isActive = false;
-    }
-    reset() {
-        this.type = '';
-        this.data = null;
-        this.timestamp = 0;
-        this.handled = false;
-    }
-    init(type, data) {
-        this.type = type;
-        this.data = data;
-        this.timestamp = Date.now();
-        this.handled = false;
-        return this;
-    }
+  constructor() {
+    this.type = "";
+    this.data = null;
+    this.timestamp = 0;
+    this.handled = false;
+    this.isActive = false;
+  }
+  reset() {
+    this.type = "";
+    this.data = null;
+    this.timestamp = 0;
+    this.handled = false;
+  }
+  init(type, data) {
+    this.type = type;
+    this.data = data;
+    this.timestamp = Date.now();
+    this.handled = false;
+    return this;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createPoolManager() {
-    return new PoolManager();
+  return new PoolManager();
 }
 function createObjectPool(config) {
-    return new ObjectPool(config);
+  return new ObjectPool(config);
 }
-function createVector3Pool(name = 'vector3', initialSize = 100) {
-    return new ObjectPool({
-        name,
-        factory: () => new PoolableVector3(),
-        initialSize,
-        maxSize: 10000,
-    });
+function createVector3Pool(name = "vector3", initialSize = 100) {
+  return new ObjectPool({
+    name,
+    factory: () => new PoolableVector3(),
+    initialSize,
+    maxSize: 1e4
+  });
 }
-function createParticlePool(name = 'particles', initialSize = 1000) {
-    return new ObjectPool({
-        name,
-        factory: () => new PoolableParticle(),
-        initialSize,
-        maxSize: 100000,
-    });
+function createParticlePool(name = "particles", initialSize = 1e3) {
+  return new ObjectPool({
+    name,
+    factory: () => new PoolableParticle(),
+    initialSize,
+    maxSize: 1e5
+  });
 }
-function createBulletPool(name = 'bullets', initialSize = 100) {
-    return new ObjectPool({
-        name,
-        factory: () => new PoolableBullet(),
-        initialSize,
-        maxSize: 5000,
-    });
+function createBulletPool(name = "bullets", initialSize = 100) {
+  return new ObjectPool({
+    name,
+    factory: () => new PoolableBullet(),
+    initialSize,
+    maxSize: 5e3
+  });
 }
-function createEventPool(name = 'events', initialSize = 50) {
-    return new ObjectPool({
-        name,
-        factory: () => new PoolableEvent(),
-        initialSize,
-        maxSize: 1000,
-    });
+function createEventPool(name = "events", initialSize = 50) {
+  return new ObjectPool({
+    name,
+    factory: () => new PoolableEvent(),
+    initialSize,
+    maxSize: 1e3
+  });
 }
-
-export { DEFAULT_POOL_CONFIG, ObjectPool, PoolManager, PoolableBullet, PoolableEvent, PoolableParticle, PoolableVector3, createBulletPool, createEventPool, createObjectPool, createParticlePool, createPoolManager, createVector3Pool };
+export {
+  DEFAULT_POOL_CONFIG,
+  ObjectPool,
+  PoolManager,
+  PoolableBullet,
+  PoolableEvent,
+  PoolableParticle,
+  PoolableVector3,
+  createBulletPool,
+  createEventPool,
+  createObjectPool,
+  createParticlePool,
+  createPoolManager,
+  createVector3Pool
+};