Feat/battle board + heavy refactor

src/api/WorldComputeProxy.ts

@@ -0,0 +1,165 @@
+import { Box2, Vector3 } from 'three'
+
+import { Block, EntityData, PatchKey } from '../common/types'
+import { EntityChunk, EntityChunkStub } from '../datacontainers/EntityChunk'
+import { GroundPatch, WorldCompute, WorldUtils } from '../index'
+import { parseThreeStub } from '../common/utils'
+
+export enum ComputeApiCall {
+  PatchCompute = 'bakeGroundPatch',
+  BlocksBatchCompute = 'computeBlocksBatch',
+  OvergroundBufferCompute = 'computeOvergroundBuffer',
+  QueryEntities = 'queryEntities',
+  BakeEntities = 'queryBakeEntities',
+  BattleBoardCompute = 'computeBoardData',
+}
+
+export type ComputeApiParams = Partial<{
+  rememberMe: boolean // allow for caching value
+  preCacheRadius: number // pre-caching next requests
+  includeEntitiesBlocks: boolean // skip or include entities blocks
+}>
+
+/**
+ * Exposing world compute api with ability to run inside optional worker
+ * When provided all request are proxied to worker instead of main thread
+ */
+export class WorldComputeProxy {
+  // eslint-disable-next-line no-use-before-define
+  static singleton: WorldComputeProxy
+  // eslint-disable-next-line no-undef
+  workerInstance: Worker | undefined
+  resolvers: Record<number, any> = {}
+  count = 0
+
+  static get instance() {
+    this.singleton = this.singleton || new WorldComputeProxy()
+    return this.singleton
+  }
+
+  get worker() {
+    return this.workerInstance
+  }
+
+  // eslint-disable-next-line no-undef
+  set worker(workerInstance: Worker | undefined) {
+    this.workerInstance = workerInstance
+    if (workerInstance) {
+      workerInstance.onmessage = ({ data }) => {
+        if (data.id !== undefined) {
+          this.resolvers[data.id]?.(data.data)
+          delete this.resolvers[data.id]
+        }
+      }
+
+      workerInstance.onerror = error => {
+        console.error(error)
+      }
+
+      workerInstance.onmessageerror = error => {
+        console.error(error)
+      }
+    }
+  }
+
+  /**
+   * Proxying request to worker
+   */
+  workerCall(apiName: ComputeApiCall, args: any[]) {
+    if (this.worker) {
+      const id = this.count++
+      this.worker.postMessage({ id, apiName, args })
+      return new Promise<any>(resolve => (this.resolvers[id] = resolve))
+    }
+    return null
+  }
+
+  async computeBlocksBatch(
+    blockPosBatch: Vector3[],
+    params = { includeEntitiesBlocks: false },
+  ) {
+    const blocks = !this.worker
+      ? WorldCompute.computeBlocksBatch(blockPosBatch, params)
+      : ((await this.workerCall(ComputeApiCall.BlocksBatchCompute, [
+          blockPosBatch,
+          params,
+        ])?.then((blocksStubs: Block[]) =>
+          // parse worker's data to recreate original objects
+          blocksStubs.map(blockStub => {
+            blockStub.pos = WorldUtils.parseThreeStub(blockStub.pos)
+            return blockStub
+          }),
+        )) as Block[])
+
+    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,
+          [queriedRegion], // [emptyPatch.bbox]
+        )?.then(stubs =>
+          stubs.map((stub: EntityData) => ({
+            ...stub,
+            bbox: parseThreeStub(stub.bbox),
+          })),
+        )) as EntityData[])
+    return entitiesData
+  }
+
+  async *iterPatchCompute(patchKeysBatch: PatchKey[]) {
+    for (const patchKey of patchKeysBatch) {
+      const patch = !this.worker
+        ? WorldCompute.bakeGroundPatch(patchKey)
+        : ((await this.workerCall(
+            ComputeApiCall.PatchCompute,
+            [patchKey], // [emptyPatch.bbox]
+          )?.then(patchStub =>
+            new GroundPatch().fromStub(patchStub),
+          )) as GroundPatch)
+
+      yield patch
+    }
+  }
+
+  async bakeGroundPatch(boundsOrPatchKey: Box2 | string) {
+    const patchStub = !this.worker
+      ? WorldCompute.bakeGroundPatch(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) :
+  //     await this.workerCall(
+  //       ComputeApiCall.BattleBoardCompute,
+  //       [boardCenter, boardParams, lastBoardBounds],
+  //     )
+  //   const board = new BoardContainer().fromStub(boardData)
+  //   return board
+  // }
+}

src/api/world-compute.ts

@@ -0,0 +1,180 @@
+import { Box2, Vector3 } from 'three'
+
+import { EntityType, GroundPatch } from '../index'
+import { Biome, BlockType } from '../procgen/Biome'
+import { Heightmap } from '../procgen/Heightmap'
+import { Block, EntityData, PatchKey } from '../common/types'
+import { asBox3, asVect2, asVect3 } from '../common/utils'
+import { WorldEntities } from '../procgen/WorldEntities'
+import { EntityChunk, EntityChunkStub } from '../datacontainers/EntityChunk'
+import { BlockData } from '../datacontainers/GroundPatch'
+// import { BoardInputParams } from '../feats/BoardContainer'
+
+/**
+ * Individual blocks requests
+ */
+
+/**
+ *
+ * @param blockPosBatch
+ * @param params
+ * @returns
+ */
+export const computeBlocksBatch = (
+  blockPosBatch: Vector3[],
+  params = { includeEntitiesBlocks: false },
+) => {
+  const { includeEntitiesBlocks } = params
+  const blocksBatch = blockPosBatch.map(({ x, z }) => {
+    const blockPos = new Vector3(x, 0, z)
+    const blockData = computeGroundBlock(blockPos)
+    if (includeEntitiesBlocks) {
+      const entityRange = new Box2().setFromPoints([asVect2(blockPos)])
+      entityRange.max.addScalar(1)
+      const [foundEntity] = queryEntities(entityRange).map(entityData => {
+        const { min, max } = entityData.bbox
+        const custChunkBox = asBox3(entityRange)
+        custChunkBox.min.y = min.y
+        custChunkBox.max.y = max.y
+        return new EntityChunk(entityData, custChunkBox)
+      })
+      const blocksBuffer = foundEntity?.voxelize()
+      const lastBlockIndex = blocksBuffer?.findLastIndex(elt => elt)
+      if (blocksBuffer && lastBlockIndex && lastBlockIndex >= 0) {
+        blockData.level += lastBlockIndex
+        blockData.type = blocksBuffer[lastBlockIndex] as BlockType
+      }
+    }
+    blockPos.y = blockData.level
+    const block: Block = {
+      pos: blockPos,
+      data: blockData,
+    }
+    return block
+  })
+  return blocksBatch
+}
+
+export const computeGroundBlock = (blockPos: Vector3) => {
+  const biomeContribs = Biome.instance.getBiomeInfluence(blockPos)
+  const mainBiome = Biome.instance.getMainBiome(biomeContribs)
+  const rawVal = Heightmap.instance.getRawVal(blockPos)
+  const blockTypes = Biome.instance.getBlockType(rawVal, mainBiome)
+  const level = Heightmap.instance.getGroundLevel(
+    blockPos,
+    rawVal,
+    biomeContribs,
+  )
+  // const pos = new Vector3(blockPos.x, level, blockPos.z)
+  const type = blockTypes.grounds[0] as BlockType
+  // const entityType = blockTypes.entities?.[0] as EntityType
+  // let offset = 0
+  // if (lastBlock && entityType) {
+
+  // }
+  // level += offset
+  const block: BlockData = { level, type }
+  return block
+}
+
+/**
+ * Patch requests
+ */
+
+// Ground
+export const bakeGroundPatch = (boundsOrPatchKey: PatchKey | Box2) => {
+  const groundPatch = new GroundPatch(boundsOrPatchKey)
+  const { min, max } = groundPatch.bounds
+  const blocks = groundPatch.iterBlocksQuery(undefined, false)
+  const level = {
+    min: 512,
+    max: 0,
+  }
+  let blockIndex = 0
+  for (const block of blocks) {
+    const blockData = computeGroundBlock(block.pos)
+    level.min = Math.min(min.y, blockData.level)
+    level.max = Math.max(max.y, blockData.level)
+    groundPatch.writeBlockData(blockIndex, blockData)
+    blockIndex++
+  }
+  return groundPatch
+}
+
+// Battle board
+// export const computeBoardData = (boardPos: Vector3, boardParams: BoardInputParams, lastBoardBounds: Box2) => {
+//   const boardMap = new BoardContainer(boardPos, boardParams, lastBoardBounds)
+//   await boardMap.fillGroundData()
+//   await boardMap.populateEntities()
+//   const boardStub = boardMap.toStub()
+//   return boardStub
+// }
+
+/**
+ * Entity queries/baking
+ */
+
+export const queryEntities = (queriedRegion: Box2) => {
+  const spawnablePlaces = WorldEntities.instance.queryDistributionMap(
+    EntityType.TREE_APPLE,
+  )(queriedRegion)
+  const spawnedEntities = spawnablePlaces
+    .map(entLoc =>
+      WorldEntities.instance.getEntityData(
+        EntityType.TREE_PINE,
+        asVect3(entLoc),
+      ),
+    )
+    .filter(entity => confirmFinalizeEntity(entity))
+  return spawnedEntities
+}
+
+/**
+ *
+ * @param entityPos
+ * @returns
+ */
+const confirmFinalizeEntity = (entity: EntityData) => {
+  const entityPos = entity.bbox.getCenter(new Vector3())
+  // use global coords in case entity center is from adjacent patch
+  const rawVal = Heightmap.instance.getRawVal(entityPos)
+  const mainBiome = Biome.instance.getMainBiome(entityPos)
+  const blockTypes = Biome.instance.getBlockType(rawVal, mainBiome)
+  const entityType = blockTypes.entities?.[0] as EntityType
+  // confirm this kind of entity can spawn over here
+  if (entityType) {
+    entity.bbox.min.y = Heightmap.instance.getGroundLevel(entityPos, rawVal)
+    entity.bbox.max.y += entity.bbox.min.y
+    return entity
+  }
+  return null
+}
+
+export const queryBakeEntities = (queriedRange: Box2) => {
+  const entitiesData = queryEntities(queriedRange)
+  return bakeEntitiesBatch(entitiesData)
+}
+
+export const bakeEntitiesBatch = (entities: EntityData[]) => {
+  const entitiesChunks: EntityChunkStub[] = entities
+    .map(entityData => new EntityChunk(entityData))
+    .map(entityChunk => {
+      entityChunk.voxelize()
+      return entityChunk.toStub()
+    })
+  return entitiesChunks
+}
+
+// /**
+//  * return all entity types which can spwawn over specific region
+//  */
+// const getSpawnableEntities = (region: Box2) => {
+//   // TODO
+// }
+
+// /**
+//  * granular check in transition place (spline or biome transitions)
+//  */
+// const confirmSpawnability = () => {
+
+// }

src/common/math.ts

@@ -0,0 +1,19 @@
+import { Box2, Vector2 } from 'three'
+
+export const findBoundingBox = (
+  point: Vector2,
+  points: Vector2[],
+  bounds: Box2,
+) => {
+  const { min, max } = bounds.clone()
+
+  for (const p of points) {
+    min.x = p.x < point.x ? Math.max(p.x, min.x) : min.x
+    min.y = p.y < point.y ? Math.max(p.y, min.y) : min.y
+    max.x = p.x > point.x ? Math.min(p.x, max.x) : max.x
+    max.y = p.y > point.y ? Math.min(p.y, max.y) : max.y
+  }
+
+  const bbox = new Box2(min, max)
+  return bbox
+}