Feat/schematics

.gitignore

@@ -1,5 +1,6 @@
 node_modules
-.env
 types
 dist/
-.parcel-cache
+.env
+.discarded
+.todo.md

package.json

@@ -22,7 +22,9 @@
   },
   "keywords": [],
   "dependencies": {
+    "@types/pako": "^2.0.3",
     "alea": "^1.0.1",
+    "pako": "^2.1.0",
     "poisson-disk-sampling": "^2.3.1",
     "simplex-noise": "^4.0.3"
   },

src/api/WorldComputeProxy.ts

@@ -1,16 +1,12 @@
-import { Box2, Vector3 } from 'three'
+import { Box2, Vector2 } from 'three'
 
-import { Block, EntityData, PatchKey } from '../common/types'
-import { EntityChunk, EntityChunkStub } from '../datacontainers/EntityChunk'
+import { GroundBlock, PatchKey } from '../common/types'
 import { GroundPatch, WorldCompute, WorldUtils } from '../index'
-import { parseThreeStub } from '../common/utils'
 
 export enum ComputeApiCall {
-  PatchCompute = 'bakeGroundPatch',
+  PatchCompute = 'bakePatch',
   BlocksBatchCompute = 'computeBlocksBatch',
-  OvergroundBufferCompute = 'computeOvergroundBuffer',
-  QueryEntities = 'queryEntities',
-  BakeEntities = 'queryBakeEntities',
+  OvergroundItemsQuery = 'retrieveOvergroundItems',
   BattleBoardCompute = 'computeBoardData',
 }
 
@@ -21,8 +17,9 @@ export type ComputeApiParams = Partial<{
 }>
 
 /**
- * Exposing world compute api with ability to run inside optional worker
- * When provided all request are proxied to worker instead of main thread
+ * World API frontend proxying requests to internal modules: world-compute, world-cache,
+ * When optional worker is provided all compute request are proxied to worker
+ * instead of main thread
  */
 export class WorldComputeProxy {
   // eslint-disable-next-line no-use-before-define
@@ -75,51 +72,39 @@ export class WorldComputeProxy {
   }
 
   async computeBlocksBatch(
-    blockPosBatch: Vector3[],
+    blockPosBatch: Vector2[],
     params = { includeEntitiesBlocks: false },
   ) {
     const blocks = !this.worker
       ? WorldCompute.computeBlocksBatch(blockPosBatch, params)
       : ((await this.workerCall(ComputeApiCall.BlocksBatchCompute, [
           blockPosBatch,
           params,
-        ])?.then((blocksStubs: Block[]) =>
+        ])?.then((blocksStubs: GroundBlock[]) =>
           // parse worker's data to recreate original objects
           blocksStubs.map(blockStub => {
             blockStub.pos = WorldUtils.parseThreeStub(blockStub.pos)
             return blockStub
           }),
-        )) as Block[])
+        )) as GroundBlock[])
 
     return blocks
   }
 
-  // *iterEntitiesBaking(entityKeys: EntityKey[]) {
-  //   for (const entityKey of entityKeys) {
-  //     const entityChunk = WorldCompute.bakeChunkEntity(entityKey)
-  //     yield entityChunk
-  //   }
-  // }
-
-  async queryEntities(queriedRegion: Box2) {
-    const entitiesData = !this.worker
-      ? WorldCompute.queryEntities(queriedRegion)
-      : ((await this.workerCall(
-          ComputeApiCall.QueryEntities,
+  async queryOvergroundItems(queriedRegion: Box2) {
+    const overgroundItems = !this.worker
+      ? WorldCompute.retrieveOvergroundItems(queriedRegion)
+      : await this.workerCall(
+          ComputeApiCall.OvergroundItemsQuery,
           [queriedRegion], // [emptyPatch.bbox]
-        )?.then(stubs =>
-          stubs.map((stub: EntityData) => ({
-            ...stub,
-            bbox: parseThreeStub(stub.bbox),
-          })),
-        )) as EntityData[])
-    return entitiesData
+        )
+    return overgroundItems
   }
 
   async *iterPatchCompute(patchKeysBatch: PatchKey[]) {
     for (const patchKey of patchKeysBatch) {
       const patch = !this.worker
-        ? WorldCompute.bakeGroundPatch(patchKey)
+        ? WorldCompute.bakePatch(patchKey)
         : ((await this.workerCall(
             ComputeApiCall.PatchCompute,
             [patchKey], // [emptyPatch.bbox]
@@ -133,25 +118,13 @@ export class WorldComputeProxy {
 
   async bakeGroundPatch(boundsOrPatchKey: Box2 | string) {
     const patchStub = !this.worker
-      ? WorldCompute.bakeGroundPatch(boundsOrPatchKey)
+      ? WorldCompute.bakePatch(boundsOrPatchKey)
       : await this.workerCall(ComputeApiCall.PatchCompute, [boundsOrPatchKey])
     // ?.then(patchStub => new GroundPatch().fromStub(patchStub)) as GroundPatch
 
     return patchStub
   }
 
-  async bakeEntities(queriedRange: Box2) {
-    const entityChunks = !this.worker
-      ? WorldCompute.queryBakeEntities(queriedRange)
-      : await this.workerCall(ComputeApiCall.BakeEntities, [
-          queriedRange,
-        ])?.then((entityChunks: EntityChunkStub[]) =>
-          // parse worker's data to recreate original objects
-          entityChunks.map(chunkStub => EntityChunk.fromStub(chunkStub)),
-        )
-    return entityChunks
-  }
-
   // async requestBattleBoard(boardCenter: Vector3, boardParams: BoardParams, lastBoardBounds: Box2) {
   //   const boardData = !this.worker ?
   //     WorldCompute.computeBoardData(boardCenter, boardParams, lastBoardBounds) :