minecraft-renderer 0.1.79 → 0.1.81

package/src/wasm-mesher/worker/mesherWasmLightDirty.test.ts

@@ -4,8 +4,6 @@ import { sectionYsForLightColumnDirty } from './mesherWasmLightDirty'
 
 describe('sectionYsForLightColumnDirty', () => {
   it('covers every section in a 256-high overworld column', () => {
-    expect(sectionYsForLightColumnDirty(0, 256)).toEqual(
-      Array.from({ length: 16 }, (_, i) => i * 16),
-    )
+    expect(sectionYsForLightColumnDirty(0, 256)).toEqual(Array.from({ length: 16 }, (_, i) => i * 16))
   })
 })

package/src/wasm-mesher/worker/mesherWasmLightDirty.ts

@@ -2,11 +2,7 @@
 import { SECTION_HEIGHT } from '../../mesher-shared/shared'
 
 /** Section Y values to dirty for a column after `update_light` updates the light cache. */
-export function sectionYsForLightColumnDirty (
-  worldMinY: number,
-  worldMaxY: number,
-  sectionHeight = SECTION_HEIGHT,
-): number[] {
+export function sectionYsForLightColumnDirty(worldMinY: number, worldMaxY: number, sectionHeight = SECTION_HEIGHT): number[] {
   const ys: number[] = []
   for (let y = worldMinY; y < worldMaxY; y += sectionHeight) {
     ys.push(y)

package/src/wasm-mesher/worker/mesherWasmRequestTracker.ts

@@ -13,54 +13,54 @@
 //    counter semantics of `dirtySections`.
 
 export class SectionRequestTracker {
-    private readonly counts = new Map<string, number>()
+  private readonly counts = new Map<string, number>()
 
-    /** Register one pending request for `key` (called per dirty-section ingest). */
-    addRequest (key: string): void {
-        this.counts.set(key, (this.counts.get(key) ?? 0) + 1)
-    }
+  /** Register one pending request for `key` (called per dirty-section ingest). */
+  addRequest(key: string): void {
+    this.counts.set(key, (this.counts.get(key) ?? 0) + 1)
+  }
 
-    /** True if at least one request for `key` is still pending. */
-    hasPending (key: string): boolean {
-        return (this.counts.get(key) ?? 0) > 0
-    }
+  /** True if at least one request for `key` is still pending. */
+  hasPending(key: string): boolean {
+    return (this.counts.get(key) ?? 0) > 0
+  }
 
-    /** Pending request count for `key` (0 if none). */
-    pendingCount (key: string): number {
-        return this.counts.get(key) ?? 0
-    }
+  /** Pending request count for `key` (0 if none). */
+  pendingCount(key: string): number {
+    return this.counts.get(key) ?? 0
+  }
 
-    /**
-     * Consume one pending request for `key`. Returns true if a request was
-     * consumed, false if there was nothing pending. Callers in the column
-     * path must treat `false` as a contract violation (the main thread did
-     * not request this key).
-     */
-    consumeOne (key: string): boolean {
-        const c = this.counts.get(key) ?? 0
-        if (c <= 0) return false
-        if (c === 1) this.counts.delete(key)
-        else this.counts.set(key, c - 1)
-        return true
-    }
+  /**
+   * Consume one pending request for `key`. Returns true if a request was
+   * consumed, false if there was nothing pending. Callers in the column
+   * path must treat `false` as a contract violation (the main thread did
+   * not request this key).
+   */
+  consumeOne(key: string): boolean {
+    const c = this.counts.get(key) ?? 0
+    if (c <= 0) return false
+    if (c === 1) this.counts.delete(key)
+    else this.counts.set(key, c - 1)
+    return true
+  }
 
-    /** Clear all pending requests (used on worker reset). */
-    clear (): void {
-        this.counts.clear()
-    }
+  /** Clear all pending requests (used on worker reset). */
+  clear(): void {
+    this.counts.clear()
+  }
 
-    /** Drop all pending requests for one column (`cx`,`cz` = column origin in block coords). */
-    clearColumn (cx: number, cz: number): void {
-        for (const key of [...this.counts.keys()]) {
-            const [x, , z] = key.split(',').map(Number)
-            if (x === cx && z === cz) {
-                this.counts.delete(key)
-            }
-        }
+  /** Drop all pending requests for one column (`cx`,`cz` = column origin in block coords). */
+  clearColumn(cx: number, cz: number): void {
+    for (const key of [...this.counts.keys()]) {
+      const [x, , z] = key.split(',').map(Number)
+      if (x === cx && z === cz) {
+        this.counts.delete(key)
+      }
     }
+  }
 
-    /** Number of distinct keys with pending requests. */
-    size (): number {
-        return this.counts.size
-    }
+  /** Number of distinct keys with pending requests. */
+  size(): number {
+    return this.counts.size
+  }
 }

package/src/worldView/worldView.spiral.test.ts

@@ -7,7 +7,7 @@ describe('WorldView._loadChunks spiral guard', () => {
   it('does not let a superseded spiral reset inLoading or panic state', async () => {
     const world = {
       getColumnAt: () => null,
-      setBlockStateId: vi.fn(),
+      setBlockStateId: vi.fn()
     }
     const view = new WorldView(world, 8, new Vec3(0, 64, 0))
     view.addWaitTime = 0

package/src/worldView/worldView.ts

@@ -30,12 +30,7 @@ export const sectionPos = (pos: { x: number; y: number; z: number }): [number, n
 /**
  * Delayed iterator for chunk loading with configurable delay.
  */
-export const delayedIterator = async <T>(
-  arr: T[],
-  delay: number,
-  exec: (item: T, index: number) => Promise<void>,
-  chunkSize = 1
-): Promise<void> => {
+export const delayedIterator = async <T>(arr: T[], delay: number, exec: (item: T, index: number) => Promise<void>, chunkSize = 1): Promise<void> => {
   for (let i = 0; i < arr.length; i += chunkSize) {
     if (delay) {
       await new Promise(resolve => setTimeout(resolve, delay))
@@ -118,7 +113,7 @@ export interface WorldProvider {
 export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldViewEvents>) {
   spiralNumber = 0
   gotPanicLastTime = false
-  panicChunksReload = () => { }
+  panicChunksReload = () => {}
   loadedChunks: Record<ChunkPosKey, boolean> = {}
   inLoading = false
   chunkReceiveTimes: number[] = []
@@ -127,13 +122,16 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
   panicTimeout?: ReturnType<typeof setTimeout>
   readonly lastPos: Vec3
   eventListeners: Record<string, any> = {}
-  debugChunksInfo: Record<ChunkPosKey, {
-    loads: Array<{
-      dataLength: number
-      reason: string
-      time: number
-    }>
-  }> = {}
+  debugChunksInfo: Record<
+    ChunkPosKey,
+    {
+      loads: Array<{
+        dataLength: number
+        reason: string
+        time: number
+      }>
+    }
+  > = {}
 
   waitingSpiralChunksLoad: Record<ChunkPosKey, (value: boolean) => void> = {}
 
@@ -163,12 +161,12 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
           class: WorldViewWorker.restorerName,
           type: 'event',
           eventName,
-          args: sanitizeWorkerEventArgs(args),
+          args: sanitizeWorkerEventArgs(args)
         })
       }) as any
     }
     return {
-      __restorer: WorldViewWorker.restorerName,
+      __restorer: WorldViewWorker.restorerName
     }
   }
 
@@ -211,9 +209,7 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
     this.emitterGotConnected(bot)
 
     const [botX, botZ] = chunkPos(pos)
-    const positions = generateSpiralMatrix(this.viewDistance).map(
-      ([x, z]) => new Vec3((botX + x) * 16, 0, (botZ + z) * 16)
-    )
+    const positions = generateSpiralMatrix(this.viewDistance).map(([x, z]) => new Vec3((botX + x) * 16, 0, (botZ + z) * 16))
 
     this.lastPos.update(pos)
     await this._loadChunks(positions, pos)
@@ -251,7 +247,7 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
     let continueLoading = true
     this.inLoading = true
 
-    await delayedIterator(positions, this.addWaitTime, async (pos) => {
+    await delayedIterator(positions, this.addWaitTime, async pos => {
       if (!continueLoading || this.loadedChunks[`${pos.x},${pos.z}`]) return
 
       // Wait for chunk to be available from server
@@ -277,25 +273,19 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
   /**
    * Load a chunk at the given position.
    */
-  async loadChunk(
-    pos: { x: number; z: number; y?: number },
-    isLightUpdate = false,
-    reason = 'spiral'
-  ): Promise<void> {
+  async loadChunk(pos: { x: number; z: number; y?: number }, isLightUpdate = false, reason = 'spiral'): Promise<void> {
     const [botX, botZ] = chunkPos(this.lastPos)
     const dx = Math.abs(botX - Math.floor(pos.x / 16))
     const dz = Math.abs(botZ - Math.floor(pos.z / 16))
 
     if (dx <= this.viewDistance && dz <= this.viewDistance) {
-      const column = await this.world.getColumnAt(
-        pos.y !== undefined ? (pos as Vec3) : new Vec3(pos.x, 0, pos.z)
-      )
+      const column = await this.world.getColumnAt(pos.y !== undefined ? (pos as Vec3) : new Vec3(pos.x, 0, pos.z))
 
       if (column) {
         const chunk = column.toJson()
         const worldConfig: WorldSizeParams = {
           minY: column.minY ?? 0,
-          worldHeight: column.worldHeight ?? 256,
+          worldHeight: column.worldHeight ?? 256
         }
 
         this.emit('loadChunk', {
@@ -312,7 +302,7 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
         this.debugChunksInfo[`${pos.x},${pos.z}`].loads.push({
           dataLength: chunk.length,
           reason,
-          time: Date.now(),
+          time: Date.now()
         })
       } else if (this.isPlayground) {
         this.emit('markAsLoaded', { x: pos.x, z: pos.z })
@@ -356,18 +346,23 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
    */
   emitterGotConnected(bot?: any): void {
     // Skip if in offscreen/worker context
-    const isOffscreen = typeof (globalThis as any).WorkerGlobalScope !== 'undefined' &&
-      globalThis instanceof (globalThis as any).WorkerGlobalScope
+    const isOffscreen = typeof (globalThis as any).WorkerGlobalScope !== 'undefined' && globalThis instanceof (globalThis as any).WorkerGlobalScope
 
     if (isOffscreen || !bot) return
 
-    this.emit('blockEntities', new Proxy({}, {
-      get(_target, posKey, receiver) {
-        if (typeof posKey !== 'string') return
-        const [x, y, z] = posKey.split(',').map(Number)
-        return bot.world.getBlock(new Vec3(x, y, z))?.entity
-      },
-    }))
+    this.emit(
+      'blockEntities',
+      new Proxy(
+        {},
+        {
+          get(_target, posKey, receiver) {
+            if (typeof posKey !== 'string') return
+            const [x, y, z] = posKey.split(',').map(Number)
+            return bot.world.getBlock(new Vec3(x, y, z))?.entity
+          }
+        }
+      )
+    )
   }
 
   lastBiomeId: number | null = null

package/src/worldView/worldViewWorkerBridge.test.ts

@@ -7,7 +7,7 @@ describe('WorldViewWorker.restoreTransferred bridge', () => {
     const addSpy = vi.fn()
     const worker = {
       addEventListener: addSpy,
-      removeEventListener: vi.fn(),
+      removeEventListener: vi.fn()
     } as unknown as Worker
 
     WorldViewWorker.restoreTransferred({}, worker)
@@ -26,7 +26,7 @@ describe('WorldViewWorker.restoreTransferred bridge', () => {
       addEventListener: (_type: string, handler: (event: MessageEvent) => void) => {
         listeners.push(handler)
       },
-      removeEventListener: () => {},
+      removeEventListener: () => {}
     } as unknown as Worker
 
     const first = WorldViewWorker.restoreTransferred({}, worker)
@@ -47,8 +47,8 @@ describe('WorldViewWorker.restoreTransferred bridge', () => {
         class: WorldViewWorker.restorerName,
         type: 'event',
         eventName: 'loadChunk',
-        args: [{ x: 0, z: 0, chunk: {}, worldConfig: {}, isLightUpdate: false }],
-      },
+        args: [{ x: 0, z: 0, chunk: {}, worldConfig: {}, isLightUpdate: false }]
+      }
     } as MessageEvent)
 
     expect(firstCalls).toBe(0)