bloody-engine 1.0.8 → 1.0.10

package/README.md

@@ -1,15 +1,19 @@
 # Bloody Engine
 
-A WebGL-based 2.5D graphics engine for isometric rendering on Node.js, written in TypeScript. Designed for server-side rendering and headless graphics processing.
+A WebGL-based 2.5D graphics engine for isometric rendering on Node.js, written in TypeScript. Designed for server-side rendering, headless graphics processing, and networked multiplayer games.
 
 ## Features
 
-- **2.5D Rendering** - Optimized for isometric and dimetric projections
+- **2.5D Rendering** - Optimized for isometric and dimetric projections with depth sorting
 - **Server-Side Rendering** - Headless WebGL rendering on Node.js using `gl` and `@kmamal/sdl`
 - **Batch Rendering** - Efficient sprite batching with GPU-accelerated transformations
-- **Resource Management** - Unified asset loading pipeline for textures and resources
+- **Resource Management** - Unified asset loading pipeline for textures and shaders
+- **Input System** - Command queue pattern supporting SDL and network input sources
+- **Networking** - Client-side prediction, server reconciliation, and state synchronization
+- **Simulation** - Pure game logic simulation system with entity management
+- **Game Loop** - Fixed timestep ticker for deterministic game logic
 - **TypeScript** - Fully typed for excellent developer experience
-- **Depth Sorting** - Proper 2.5D occlusion handling
+- **Object Pooling** - Memory-efficient object reuse patterns
 - **Window Management** - SDL-based window creation for interactive applications
 
 ## Installation
@@ -18,15 +22,73 @@ A WebGL-based 2.5D graphics engine for isometric rendering on Node.js, written i
 npm install bloody-engine
 ```
 
+## API Overview
+
+### Core Graphics
+
+| Class | Description |
+|-------|-------------|
+| [GraphicsDevice](src/core/grahpic-device.ts) | Main graphics device with WebGL context management |
+| [Shader](src/core/shader.ts) | Shader program compilation and uniform/attribute management |
+| [Texture](src/core/texture.ts) | Texture creation, binding, and management |
+| [VertexBuffer](src/core/buffer.ts) / [IndexBuffer](src/core/buffer.ts) | GPU buffer management for geometry |
+| [Camera](src/rendering/camera.ts) | 2D camera with position, zoom, and view matrix |
+
+### Rendering
+
+| Class | Description |
+|-------|-------------|
+| [BatchRenderer](src/rendering/batch-renderer.ts) | Generic quad batch rendering |
+| [SpriteBatchRenderer](src/rendering/batch-renderer.ts) | Sprite-specific batch renderer with depth sorting |
+| [ProjectionConfig](src/rendering/projection.ts) | Isometric/dimetric projection utilities |
+| [SpatialHash](src/rendering/spatial-hash.ts) | Spatial partitioning for efficient queries |
+
+### Resource Loading
+
+| Class | Description |
+|-------|-------------|
+| [NodeResourceLoader](src/platforms/node/node-resource-loader.ts) | File system resource loader for Node.js |
+| [NodeTextureLoader](src/platforms/node/node-texture-loader.ts) | PNG texture loading for Node.js |
+| [ResourcePipeline](src/core/resource-pipeline.ts) | Batch resource loading with caching |
+| [TextureAtlas](src/core/sprite-atlas.ts) | Sprite atlas packing and UV coordinate management |
+
+### Input System
+
+| Class | Description |
+|-------|-------------|
+| [CommandQueue](src/input/command-queue.ts) | Thread-safe command queue for input |
+| [SDLInputSource](src/input/sdl-input-source.ts) | SDL keyboard/mouse input |
+| [NetworkInputSource](src/input/networking-input-source.ts) | Network-based input for multiplayer |
+
+### Simulation & Networking
+
+| Class | Description |
+|-------|-------------|
+| [Ticker](src/core/ticker.ts) | Fixed timestep game loop |
+| [Entity](src/simulation/entity.ts) / [EntityManager](src/simulation/entity-manager.ts) | Entity component system |
+| [SimulationLoop](src/simulation/simulation-loop.ts) | Deterministic game logic simulation |
+| [ClientPredictor](src/networking/client-predictor.ts) | Client-side prediction for lag compensation |
+| [ServerReconciler](src/networking/server-reconciler.ts) | Server-side reconciliation |
+| [StateSnapshot](src/networking/state-snapshot.ts) | World state serialization |
+| [BinarySerializer](src/networking/binary-serializer.ts) | Efficient binary serialization |
+
+### Utilities
+
+| Class | Description |
+|-------|-------------|
+| [ObjectPool](src/core/object-pool.ts) | Generic object pooling for GC optimization |
+| [Matrix4Pool](src/core/matrix-pool.ts) | Matrix4 specific pooling |
+| [lerp](src/core/interpolation.ts), [lerpVec2](src/core/interpolation.ts), [lerpVec3](src/core/interpolation.ts) | Interpolation utilities |
+
 ## Quick Start
 
+### Basic Rendering Setup
+
 ```typescript
-import { GraphicsDevice, Shader, Texture } from 'bloody-engine';
+import { GraphicsDevice, Shader, Texture, VertexBuffer } from 'bloody-engine';
 
-// Create a graphics device with SDL window
+// Create graphics device (800x600)
 const device = new GraphicsDevice(800, 600);
-
-// Get the WebGL context
 const gl = device.getGLContext();
 
 // Create a shader
@@ -46,67 +108,392 @@ const shader = device.createShader(`
   }
 `);
 
-// Create a texture from PNG
-const { PNG } = require('pngjs');
-const fs = require('fs/promises');
-const pngData = await fs.readFile('texture.png');
-const png = PNG.sync.read(pngData);
-const texture = Texture.createFromPNG(gl, png);
+// Create a gradient texture
+const texture = Texture.createGradient(gl, 256, 256);
+
+// Create geometry
+const vertices = new Float32Array([
+  // x, y, z, u, v
+  -0.5, -0.5, 0, 0, 1,
+   0.5, -0.5, 0, 1, 1,
+   0.5,  0.5, 0, 1, 0,
+  -0.5, -0.5, 0, 0, 1,
+   0.5,  0.5, 0, 1, 0,
+  -0.5,  0.5, 0, 0, 0
+]);
+const buffer = new VertexBuffer(gl, vertices, 20); // 5 floats * 4 bytes
 
-// Render
+// Setup and render
 device.clear({ r: 0.1, g: 0.1, b: 0.1, a: 1.0 });
 shader.use();
-// ... rendering code ...
+buffer.bind();
+// ... configure attributes ...
+gl.drawArrays(gl.TRIANGLES, 0, buffer.getVertexCount());
 device.present();
-
-// For headless rendering, capture the output
-const context = device.getRenderingContext();
-const pixels = context.readPixels();
 ```
 
-## Examples
-
-### Sprite Batch Rendering
+### Sprite Batch Rendering with Camera
 
 ```typescript
-import { SpriteBatchRenderer, Camera, Texture } from 'bloody-engine';
+import { SpriteBatchRenderer, Camera, Texture, GraphicsDevice } from 'bloody-engine';
+
+const device = new GraphicsDevice(800, 600);
+const gl = device.getGLContext();
 
+// Create shader (use built-in V2 shader for sprites)
+const shader = device.createShader(vertexSource, fragmentSource);
+
+// Create sprite batch renderer (capacity: 1000 sprites)
 const batchRenderer = new SpriteBatchRenderer(gl, shader, 1000);
-const camera = new Camera(0, 0, 1.0);
+batchRenderer.setTexture(Texture.createGradient(gl, 256, 256));
+
+// Create camera
+const camera = new Camera(0, 0, 1.0); // x=0, y=0, zoom=1x
 
-// Add sprites
+// Add sprites to batch
 batchRenderer.addQuad({
-  x: 100,
-  y: 100,
-  z: 0,
-  width: 64,
-  height: 64,
+  x: 100, y: 100, z: 0,
+  width: 64, height: 64,
   rotation: 0,
   color: { r: 1, g: 1, b: 1, a: 1 },
-  uvRect: { uMin: 0, vMin: 0, uMax: 1, vMax: 1 }
+  texIndex: 0
 });
 
-// Render
+// Render with camera
+device.clear({ r: 0.1, g: 0.1, b: 0.1, a: 1.0 });
 batchRenderer.render(camera);
+device.present();
 ```
 
 ### Resource Loading
 
 ```typescript
-import { NodeResourceLoader } from 'bloody-engine';
-
-const loader = new NodeResourceLoader('./assets');
+import {
+  ResourceLoaderFactory,
+  createResourcePipeline,
+  NodeTextureLoader
+} from 'bloody-engine';
+
+// Create resource pipeline
+const pipeline = await createResourcePipeline({
+  concurrency: 5,
+  cache: true,
+  baseDir: process.cwd()
+});
 
-// Load a shader
-const vertexSource = await loader.load('shaders/basic.vert');
-const fragmentSource = await loader.load('shaders/basic.frag');
+// Load shaders
+const shaders = await pipeline.loadShaders([
+  { name: 'basic', vertex: 'shaders/basic.vert', fragment: 'shaders/basic.frag' }
+]);
 
-// Batch load multiple resources
-const { succeeded, failed } = await loader.loadMultiple([
+// Batch load resources
+const { succeeded, failed } = await pipeline.loadMultiple([
   'textures/sprite1.png',
-  'textures/sprite2.png',
-  'shaders/shader.vert'
+  'textures/sprite2.png'
 ]);
+
+// Load texture from PNG
+const textureLoader = new NodeTextureLoader();
+const texture = await textureLoader.loadTexture(gl, 'textures/sprite.png');
+```
+
+### Game Loop with Fixed Timestep
+
+```typescript
+import { Ticker, type TickerConfig } from 'bloody-engine';
+
+const config: TickerConfig = {
+  targetFPS: 60,
+  fixedDeltaTime: 1 / 60, // 60 physics updates per second
+  maxFrameTime: 0.25 // Prevent spiral of death
+};
+
+const ticker = new Ticker(config);
+
+ticker.start({
+  update: (deltaTime) => {
+    // Game logic update (fixed timestep)
+    console.log(`Update: ${deltaTime.toFixed(3)}s`);
+  },
+  render: (interpolation) => {
+    // Render with interpolation factor
+    console.log(`Render: interpolation=${interpolation.toFixed(3)}`);
+  }
+});
+
+// Get performance metrics
+const metrics = ticker.getMetrics();
+console.log(`FPS: ${metrics.fps}, Delta Time: ${metrics.deltaTime}s`);
+```
+
+### Entity System
+
+```typescript
+import { Entity, EntityManager, type EntityState } from 'bloody-engine';
+
+// Create entity
+const entity = new Entity({
+  id: 'player-1',
+  x: 0, y: 0, z: 0,
+  rotation: 0,
+  type: 'player',
+  health: 100
+});
+
+// Create entity manager
+const manager = new EntityManager();
+manager.add(entity);
+
+// Query entities
+const players = manager.query({ type: 'player' });
+const nearby = manager.queryInRegion(0, 0, 100);
+
+// Update entity
+entity.x += 10;
+entity.updatedAt = Date.now();
+manager.update(entity);
+```
+
+### Input System with Command Queue
+
+```typescript
+import {
+  CommandQueue,
+  SDLInputSource,
+  createSDLInputSource,
+  CommandType
+} from 'bloody-engine';
+
+// Create command queue
+const queue = new CommandQueue();
+
+// Create SDL input source (requires SDL window)
+const sdlWindow = new SDLWindow(800, 600, 'Game');
+const inputSource = createSDLInputSource(sdlWindow, {
+  keyMapping: {
+    moveUp: ['w', 'arrowup'],
+    moveDown: ['s', 'arrowdown'],
+    moveLeft: ['a', 'arrowleft'],
+    moveRight: ['d', 'arrowright']
+  }
+});
+
+// Process input in game loop
+while (running) {
+  // Collect input commands
+  inputSource.update(queue);
+
+  // Process commands
+  while (queue.hasCommands()) {
+    const command = queue.dequeue();
+    switch (command.type) {
+      case CommandType.Move:
+        handleMove(command);
+        break;
+      case CommandType.Attack:
+        handleAttack(command);
+        break;
+    }
+  }
+}
+```
+
+### Networking - Client-Side Prediction
+
+```typescript
+import {
+  createClientPredictor,
+  ClientPredictor,
+  type ClientInputMessage
+} from 'bloody-engine';
+
+// Create predictor with config
+const predictor = createClientPredictor({
+  maxPredictedTicks: 100,
+  reconciliationDelay: 100 // ms
+});
+
+// Client loop: send input
+const onInput = (input: MoveCommand) => {
+  const tick = currentTick;
+  predictor.addLocalInput(tick, input);
+
+  // Send to server
+  socket.send(JSON.stringify({
+    type: 'client_input',
+    tick,
+    input
+  } as ClientInputMessage));
+};
+
+// Receive server update
+const onServerUpdate = (message: ServerStateUpdateMessage) => {
+  const result = predictor.reconcile(message);
+
+  if (result.corrected) {
+    console.log(`Reconciled: corrected=${result.corrected}, error=${result.error}`);
+  }
+};
+```
+
+### Object Pooling for Performance
+
+```typescript
+import { ObjectPool, type ObjectPoolConfig } from 'bloody-engine';
+
+// Create pool for Vector3 objects
+const pool = new ObjectPool<Vector3>({
+  initialSize: 100,
+  growthFactor: 2,
+  factory: () => ({ x: 0, y: 0, z: 0 }),
+  reset: (obj) => { obj.x = 0; obj.y = 0; obj.z = 0; }
+});
+
+// Acquire from pool
+const vec = pool.acquire();
+vec.x = 10; vec.y = 20; vec.z = 30;
+
+// Return to pool when done
+pool.release(vec);
+
+// Get pool statistics
+const stats = pool.getStats();
+console.log(`Size: ${stats.size}, Active: ${stats.active}, Hits: ${stats.hits}`);
+```
+
+### Isometric Projection
+
+```typescript
+import { ProjectionConfig, gridToScreen, screenToGrid } from 'bloody-engine';
+
+// Configure isometric projection
+const config = new ProjectionConfig({
+  tileWidth: 64,
+  tileHeight: 32,
+  angle: Math.PI / 6, // 30 degrees
+  screenWidth: 800,
+  screenHeight: 600
+});
+
+// Convert grid to screen coordinates
+const gridPos = { xgrid: 5, ygrid: 3, zheight: 0 };
+const screenPos = gridToScreen(gridPos, config);
+console.log(`Screen: x=${screenPos.xscreen}, y=${screenPos.yscreen}`);
+
+// Convert screen to grid coordinates
+const gridPos2 = screenToGrid(screenPos, config);
+```
+
+### Texture Atlas for Sprite Sheets
+
+```typescript
+import { TextureAtlas, AtlasLoader } from 'bloody-engine';
+
+// Load sprite atlas
+const atlas = await AtlasLoader.loadFromJSON(gl, 'atlas.json');
+
+// Get sprite info
+const sprite = atlas.getSprite('player_idle_01');
+
+// Use UV rect for rendering
+batchRenderer.addQuad({
+  x: 100, y: 100, z: 0,
+  width: sprite.pixelRect.width,
+  height: sprite.pixelRect.height,
+  uvRect: sprite.uvRect
+});
+```
+
+## Advanced Examples
+
+### Networked Game Architecture
+
+```typescript
+import {
+  SimulationLoop,
+  Entity,
+  ClientPredictor,
+  ServerReconciler,
+  StateSnapshot,
+  Ticker
+} from 'bloody-engine';
+
+// Server-side simulation
+const serverSim = new SimulationLoop({
+  fixedDeltaTime: 1 / 60
+});
+
+// Client-side prediction
+const clientPredictor = createClientPredictor({
+  maxPredictedTicks: 100
+});
+
+// Server reconciliation
+const serverReconciler = createServerReconciler({
+  maxRewindTicks: 50
+});
+
+// Game loop on client
+const ticker = new Ticker({ targetFPS: 60 });
+ticker.start({
+  update: (deltaTime) => {
+    // 1. Collect input and send to server
+    const input = collectInput();
+    socket.send({ type: 'input', input, tick: currentTick });
+
+    // 2. Predict locally
+    clientPredictor.addLocalInput(currentTick, input);
+    const predictedState = predictState();
+
+    // 3. Handle server updates
+    onServerUpdate = (update) => {
+      clientPredictor.reconcile(update);
+    };
+  },
+  render: (interpolation) => {
+    renderGame(clientPredictor.getLatestState(), interpolation);
+  }
+});
+```
+
+### Deterministic Simulation Testing
+
+```typescript
+import { SimulationLoop, Entity } from 'bloody-engine';
+
+// Create two simulations for testing determinism
+const sim1 = new SimulationLoop({ fixedDeltaTime: 1 / 60, seed: 12345 });
+const sim2 = new SimulationLoop({ fixedDeltaTime: 1 / 60, seed: 12345 });
+
+// Add identical entities
+sim1.addEntity(new Entity({ id: '1', x: 0, y: 0 }));
+sim2.addEntity(new Entity({ id: '1', x: 0, y: 0 }));
+
+// Run simulations
+for (let i = 0; i < 1000; i++) {
+  sim1.update(1 / 60);
+  sim2.update(1 / 60);
+}
+
+// Verify determinism
+const state1 = sim1.getStateSnapshot();
+const state2 = sim2.getStateSnapshot();
+console.log('Deterministic:', JSON.stringify(state1) === JSON.stringify(state2));
+```
+
+## Testing
+
+The engine includes comprehensive tests for determinism and visual regression:
+
+```bash
+# Run all tests
+npm test
+
+# Run specific test suites
+npm run test:determinism    # Test simulation determinism
+npm run test:visual         # Visual regression tests
+npm run test:state-sync     # State synchronization tests
+npm run test:coverage       # Generate coverage report
 ```
 
 ## Dependencies
@@ -115,8 +502,61 @@ const { succeeded, failed } = await loader.loadMultiple([
 - **@kmamal/sdl** - SDL2 bindings for window and input management
 - **pngjs** - PNG image decoding
 
+## Platform Support
+
+| Platform | Status | Notes |
+|----------|--------|-------|
+| Node.js (Linux) | ✅ Full | Headless rendering + SDL window |
+| Node.js (macOS) | ✅ Full | Headless rendering + SDL window |
+| Node.js (Windows) | ✅ Full | Headless rendering + SDL window |
+| Browser | ⚠️ Planned | WebGL rendering planned |
+
 ## Documentation
 
+### Source Code Organization
+
+```
+src/
+├── core/              # Core graphics and utilities
+│   ├── grahpic-device.ts
+│   ├── shader.ts
+│   ├── texture.ts
+│   ├── buffer.ts
+│   ├── object-pool.ts
+│   └── ticker.ts
+├── rendering/         # Rendering systems
+│   ├── batch-renderer.ts
+│   ├── camera.ts
+│   ├── projection.ts
+│   └── spatial-hash.ts
+├── input/             # Input system (command queue)
+│   ├── command-queue.ts
+│   ├── sdl-input-source.ts
+│   └── network-input-source.ts
+├── simulation/        # Game logic simulation
+│   ├── entity.ts
+│   ├── entity-manager.ts
+│   └── simulation-loop.ts
+├── networking/        # Networking for multiplayer
+│   ├── client-predictor.ts
+│   ├── server-reconciler.ts
+│   ├── state-snapshot.ts
+│   └── binary-serializer.ts
+└── platforms/
+    └── node/          # Node.js-specific implementations
+        ├── node-context.ts
+        ├── node-resource-loader.ts
+        └── sdl-window.ts
+```
+
+### Key Concepts
+
+- **Separation of Concerns**: Rendering, input, simulation, and networking are completely separate systems
+- **Deterministic Simulation**: Game logic runs in fixed timestep for consistency across clients
+- **Command Pattern**: All input goes through a command queue for easy recording/replay
+- **Client-Side Prediction**: Reduces perceived lag in networked games
+- **Object Pooling**: Minimizes garbage collection for smooth performance
+
 For detailed documentation and architecture, see [docs/README.MD](docs/README.MD).
 
 ## Building

package/dist/node/index.js

@@ -5237,15 +5237,13 @@ class StateSnapshot {
    * Serialize snapshot to binary format
    */
   toBinary() {
-    const { BinarySerializer: BinarySerializer2 } = require("./binary-serializer");
-    const serializer = new BinarySerializer2();
+    const serializer = new BinarySerializer();
     serializer.writeUint32(this.tick);
     serializer.writeFloat64(this.timestamp);
     serializer.writeUint16(this.entities.size);
     for (const [entityId, state] of this.entities.entries()) {
       serializer.writeString(entityId);
-      const { EntitySerializer: EntitySerializer2 } = require("./entity-serializer");
-      const stateData = EntitySerializer2.serializeEntityState(state);
+      const stateData = EntitySerializer.serializeEntityState(state);
       serializer.writeBytes(stateData);
     }
     return serializer.toBuffer();
@@ -5254,9 +5252,7 @@ class StateSnapshot {
    * Deserialize snapshot from binary format
    */
   static fromBinary(data) {
-    const { BinaryReader: BinaryReader2 } = require("./binary-serializer");
-    const { EntitySerializer: EntitySerializer2 } = require("./entity-serializer");
-    const reader = new BinaryReader2(data);
+    const reader = new BinaryReader(data);
     const tick = reader.readUint32();
     const timestamp = reader.readFloat64();
     const entityCount = reader.readUint16();
@@ -5267,7 +5263,7 @@ class StateSnapshot {
       reader.setOffset(reader.getOffset() - 1);
       const stateDataLength = StateSnapshot.estimateEntityStateSize();
       const actualData = reader.readBytes(stateDataLength);
-      const state = EntitySerializer2.deserializeEntityState(actualData);
+      const state = EntitySerializer.deserializeEntityState(actualData);
       entities.set(entityId, state);
     }
     return new StateSnapshot(tick, entities, timestamp);

package/dist/node/networking/state-snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-snapshot.d.ts","sourceRoot":"","sources":["../../../src/networking/state-snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,aAAc,YAAW,mBAAmB;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM;IAMhF;;OAEG;IACH,MAAM,CAAC,YAAY,CACjB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,GAAE,eAAoB,GAC5B,aAAa;IAsBhB;;OAEG;IACH,MAAM,CAAC,OAAO,CACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACnC,SAAS,CAAC,EAAE,MAAM,GACjB,aAAa;IAchB;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAczD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,aAAa;IAe1C;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa;IA4B1C;;OAEG;IACH,KAAK,IAAI,aAAa;IAItB;;OAEG;IACH,OAAO,IAAI,mBAAmB;IAQ9B;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,mBAAmB,GAAG,aAAa;IAI3D;;OAEG;IACH,QAAQ,IAAI,UAAU;IA+BtB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa;IAkClD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAKtC;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;CA+BtC"}
+{"version":3,"file":"state-snapshot.d.ts","sourceRoot":"","sources":["../../../src/networking/state-snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAI3D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,aAAc,YAAW,mBAAmB;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM;IAMhF;;OAEG;IACH,MAAM,CAAC,YAAY,CACjB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,GAAE,eAAoB,GAC5B,aAAa;IAsBhB;;OAEG;IACH,MAAM,CAAC,OAAO,CACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACnC,SAAS,CAAC,EAAE,MAAM,GACjB,aAAa;IAchB;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAczD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,aAAa;IAe1C;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa;IA4B1C;;OAEG;IACH,KAAK,IAAI,aAAa;IAItB;;OAEG;IACH,OAAO,IAAI,mBAAmB;IAQ9B;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,mBAAmB,GAAG,aAAa;IAI3D;;OAEG;IACH,QAAQ,IAAI,UAAU;IAyBtB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa;IA8BlD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAKtC;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;CA+BtC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloody-engine",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "A WebGL-based 2.5D graphics engine for isometric rendering",
   "license": "MIT",
   "type": "module",

package/dist/node/tests/determinism.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Determinism Test for Bloody Engine
- *
- * This test verifies that the simulation is deterministic:
- * - Runs two instances of the SimulationLoop with the same input seed
- * - Compares the state of all entities after 1000 ticks
- * - They must match perfectly
- */
-export {};
-//# sourceMappingURL=determinism.test.d.ts.map

package/dist/node/tests/determinism.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"determinism.test.d.ts","sourceRoot":"","sources":["../../../src/tests/determinism.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/node/tests/projection.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for 2.5D Isometric Projection Mathematics
- */
-export {};
-//# sourceMappingURL=projection.test.d.ts.map

package/dist/node/tests/projection.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"projection.test.d.ts","sourceRoot":"","sources":["../../../src/tests/projection.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/node/tests/state-sync.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * State Synchronization Integration Test
- *
- * Tests the complete state synchronization pipeline:
- * 1. Binary serialization
- * 2. State snapshots
- * 3. Client-side prediction
- * 4. Server reconciliation
- *
- * Run with: npm run test:state-sync
- */
-export {};
-//# sourceMappingURL=state-sync.test.d.ts.map

package/dist/node/tests/state-sync.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state-sync.test.d.ts","sourceRoot":"","sources":["../../../src/tests/state-sync.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/node/tests/visual-regression.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Visual Regression Test for Bloody Engine
- *
- * This test:
- * 1. Initializes the engine in headless mode
- * 2. Loads a test scene
- * 3. Renders one frame
- * 4. Captures the framebuffer using gl.readPixels
- * 5. Saves as output.png
- * 6. Compares against reference.png (if exists)
- */
-export {};
-//# sourceMappingURL=visual-regression.test.d.ts.map

package/dist/node/tests/visual-regression.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"visual-regression.test.d.ts","sourceRoot":"","sources":["../../../src/tests/visual-regression.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}