prismarine-world 3.6.0 → 3.6.2

package/.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: event-promise
+    versions:
+    - ">= 1.a, < 2"
+  - dependency-name: mkdirp
+    versions:
+    - ">= 1.a, < 2"

package/.github/workflows/ci.yml

@@ -1,6 +1,3 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
 name: CI
 
 on:
@@ -25,4 +22,4 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm install
-    - run: npm test
+    - run: npm test

package/.github/workflows/publish.yml

@@ -13,13 +13,20 @@ jobs:
     - name: Set up Node.js
       uses: actions/setup-node@master
       with:
-        node-version: 10.0.0
-    - name: Publish if version has been updated
-      uses: pascalgn/npm-publish-action@4f4bf159e299f65d21cd1cbd96fc5d53228036df
-      with: # All of theses inputs are optional
-        tag_name: "%s"
-        tag_message: "%s"
-        commit_pattern: "^Release (\\S+)"
-      env: # More info about the environment variables in the README
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Leave this as is, it's automatically generated
-        NPM_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }} # You need to set this in your repo settings
+        node-version: 14.0.0
+    - id: publish
+      uses: JS-DevTools/npm-publish@v1
+      with:
+        token: ${{ secrets.NPM_AUTH_TOKEN }}
+    - name: Create Release
+      if: steps.publish.outputs.type != 'none'
+      id: create_release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ steps.publish.outputs.version }}
+        release_name: Release ${{ steps.publish.outputs.version }}
+        body: ${{ steps.publish.outputs.version }}
+        draft: false
+        prerelease: false

package/README.md

@@ -8,7 +8,7 @@
 
 [![Try it on gitpod](https://img.shields.io/badge/try-on%20gitpod-brightgreen.svg)](https://gitpod.io/#https://github.com/PrismarineJS/prismarine-world)
 
-Provides a minecraft world: an infinite collection of 16x256x26 chunks.
+Provides a minecraft world: an infinite collection of 16x256x16 chunks.
 
 ## Usage
 

package/docs/API.md

@@ -179,3 +179,20 @@ It steps exactly 1 block at a time, returning the block coordinates and the face
 #### next()
 
 return null or the next position (Vec3)
+
+### SpiralIterator2d (pos, maxDistance)
+
+`pos` is Vec3
+
+`maxDistance` is number
+
+Iterates outwards along x and z axis in a cubic spiral. First position returned is the starting position. Every step is 1 step away form the previous and next point. 
+
+#### next()
+
+return null or the next position (Vec3)
+
+#### NUMBER_OF_POINTS
+
+Number of points the iterator will return.
+

package/docs/HISTORY.md

@@ -1,5 +1,16 @@
 ## History
 
+### 3.6.2
+
+* Fix chunk saving reference errors (@kf106 & @moonborrow) [#100](https://github.com/PrismarineJS/prismarine-world/pull/100)
+* Fix typo in README.md (@takeru) [#108](https://github.com/PrismarineJS/prismarine-world/pull/108)
+* Improved types (@TRCYX) [#99](https://github.com/PrismarineJS/prismarine-world/pull/99)
+* Fix ManhattanIterator [#101](https://github.com/PrismarineJS/prismarine-world/pull/101) (@IceTank)
+
+### 3.6.1
+
+* Update mcdata
+
 ### 3.6.0
 
 * Added match while check intersect (@sefirosweb)

package/examples/iterator.js

@@ -1,12 +1,70 @@
 const Vec3 = require('vec3').Vec3
-const { OctahedronIterator } = require('../index').iterators
+const { ManhattanIterator, SpiralIterator2d, OctahedronIterator } = require('../index').iterators
 
-const iterator = new OctahedronIterator(new Vec3(0, 0, 0), 5)
+console.info('Octahedron Iterator 3D:\n' + iterate3d(new OctahedronIterator(new Vec3(0, 0, 0), 2)))
+console.info('ManhattanIterator Iterator:\n' + iterate2d(new ManhattanIterator(0, 0, 5)))
+console.info('SpiralIterator2d Iterator:\n' + iterate2d(new SpiralIterator2d(new Vec3(0, 0, 0), 4)))
 
-while (true) {
-  const n = iterator.next()
-  if (n === null) {
-    break
+function iterate3d (iter) {
+  let n = iter.next()
+  const result = []
+  const size = 3
+  let counter = 0
+  for (let x = 0; x < size * 2; x++) {
+    for (let y = 0; y < size * 2; y++) {
+      if (!result[x]) result[x] = []
+      for (let z = 0; z < size * 2; z++) {
+        if (!result[x][y]) result[x][y] = []
+        result[x][y][z] = '   '
+      }
+    }
   }
-  console.log(n)
+  console.info(result)
+  while (n) {
+    result[n.x + size][n.y + size][n.z + size] = pad(counter)
+    counter = counter + 1
+    n = iter.next()
+  }
+  let str = 'Layer 0:  ...\n'
+  for (let x = 0; x < size * 2; x++) {
+    let line = ''
+    for (let y = 0; y < size * 2; y++) {
+      for (let z = 0; z < size * 2; z++) {
+        line += '|' + pad(result[x][y][z])
+      }
+      line += '  '
+    }
+    str += line + '\n'
+  }
+  return str
+}
+
+function iterate2d (iter) {
+  let n = iter.next()
+  const result = []
+  const size = 5
+  let counter = 0
+  for (let x = 0; x < size * 2; x++) {
+    for (let z = 0; z < size * 2; z++) {
+      if (!result[x]) result[x] = []
+      result[x][z] = '   '
+    }
+  }
+  while (n) {
+    result[n.x + size][n.z + size] = pad(counter)
+    counter = counter + 1
+    n = iter.next()
+  }
+  let str = ''
+  for (let x = 0; x < size * 2; x++) {
+    for (let z = 0; z < size * 2; z++) {
+      str += '|' + result[x][z]
+    }
+    str += '|\n'
+  }
+  return str
+}
+
+function pad (num) {
+  return num.toString().padStart(3, ' ')
 }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "prismarine-world",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "description": "The core implementation of the world for prismarine",
   "main": "index.js",
+  "types": "./types/index.d.ts",
   "scripts": {
     "pretest": "npm run lint",
     "lint": "standard",
     "fix": "standard --fix",
-    "test": "jest --verbose"
+    "test": "mocha --reporter spec --exit"
   },
   "repository": {
     "type": "git",
@@ -21,7 +22,7 @@
     "game"
   ],
   "engines": {
-    "nodejs": ">=8.0.0"
+    "node": ">=8.0.0"
   },
   "enginesStrict": true,
   "author": "Will Franzen <wtfranzen@gmail.com> (http://will.xyz/)",
@@ -32,17 +33,19 @@
   "homepage": "https://github.com/PrismarineJS/prismarine-world",
   "devDependencies": {
     "buffer-equal": "^1.0.0",
+    "expect": "^29.1.0",
     "flatmap": "0.0.3",
-    "jest": "^26.0.1",
-    "minecraft-data": "^2.47.0",
+    "minecraft-data": "^3.0.0",
     "mkdirp": "^0.5.1",
-    "prismarine-chunk": "^1.14.0",
+    "mocha": "^10.0.0",
+    "prismarine-chunk": "^1.31.0",
     "prismarine-provider-anvil": "^2.0.0",
     "prismarine-provider-raw": "^1.0.1",
+    "prismarine-world": "file:.",
+    "process": "^0.11.0",
     "range": "0.0.3",
     "rimraf": "^3.0.2",
-    "standard": "^16.0.1",
-    "process": "^0.11.0"
+    "standard": "^17.0.0"
   },
   "dependencies": {
     "vec3": "^0.1.7"

package/src/iterators.js

@@ -1,11 +1,21 @@
 const { Vec3 } = require('vec3')
 
+const BlockFace = {
+  UNKNOWN: -999,
+  BOTTOM: 0,
+  TOP: 1,
+  NORTH: 2,
+  SOUTH: 3,
+  WEST: 4,
+  EAST: 5
+}
+
 // 2D spiral iterator, useful to iterate on
 // columns that are centered on bot position
 // https://en.wikipedia.org/wiki/Taxicab_geometry
 class ManhattanIterator {
   constructor (x, y, maxDistance) {
-    this.maxDistance = maxDistance
+    this.maxDistance = Math.floor(maxDistance)
     this.startx = x
     this.starty = y
     this.x = 2
@@ -14,11 +24,15 @@ class ManhattanIterator {
     this.leg = -1
   }
 
+  /**
+   * Returns the next position. If the iterator is at the end, returns null. Position will be 2d along the x z plane and y always being 0.
+   * @returns {Vec3 | null}
+   */
   next () {
     if (this.leg === -1) {
       // use -1 as the center
       this.leg = 0
-      return { x: this.startx, y: this.starty }
+      return new Vec3(this.startx, 0, this.starty)
     } else if (this.leg === 0) {
       if (this.maxDistance === 1) return null
       this.x--
@@ -90,16 +104,6 @@ class OctahedronIterator {
   }
 }
 
-const BlockFace = {
-  UNKNOWN: -999,
-  BOTTOM: 0,
-  TOP: 1,
-  NORTH: 2,
-  SOUTH: 3,
-  WEST: 4,
-  EAST: 5
-}
-
 // This iterate along a ray starting at `pos` in `dir` direction
 // It steps exactly 1 block at a time, returning the block coordinates
 // and the face by which the ray entered the block.
@@ -204,10 +208,75 @@ class RaycastIterator {
   }
 }
 
+class SpiralIterator2d {
+  /**
+   * Spiral outwards from a central position in growing squares.
+   * Every point has a constant distance to its previous and following position of 1. First point returned is the starting position.
+   * Generates positions like this:
+   * ```text
+   * 16 15 14 13 12
+   * 17  4  3  2 11
+   * 18  5  0  1 10
+   * 19  6  7  8  9
+   * 20 21 22 23 24
+   * (maxDistance = 2; points returned = 25)
+   * ```
+   * Copy and paste warrior source: https://stackoverflow.com/questions/3706219/algorithm-for-iterating-over-an-outward-spiral-on-a-discrete-2d-grid-from-the-or
+   * @param {Vec3} pos Starting position
+   * @param {number} maxDistance Max distance from starting position
+   */
+  constructor (pos, maxDistance) {
+    this.start = pos
+    this.maxDistance = maxDistance
+
+    this.NUMBER_OF_POINTS = Math.floor(Math.pow((Math.floor(maxDistance) - 0.5) * 2, 2))
+
+    // (di, dj) is a vector - direction in which we move right now
+    this.di = 1
+    this.dj = 0
+    // length of current segment
+    this.segment_length = 1
+    // current position (i, j) and how much of current segment we passed
+    this.i = 0
+    this.j = 0
+    this.segment_passed = 0
+    // current iteration
+    this.k = 0
+  }
+
+  next () {
+    if (this.k >= this.NUMBER_OF_POINTS) return null
+    const output = this.start.offset(this.i, 0, this.j)
+
+    // make a step, add 'direction' vector (di, dj) to current position (i, j)
+    this.i += this.di
+    this.j += this.dj
+    this.segment_passed += 1
+
+    if (this.segment_passed === this.segment_length) {
+      // done with current segment
+      this.segment_passed = 0
+
+      // 'rotate' directions
+      const buffer = this.di
+      this.di = -this.dj
+      this.dj = buffer
+
+      // increase segment length if necessary
+      if (this.dj === 0) {
+        this.segment_length += 1
+      }
+    }
+    this.k += 1
+    return output
+  }
+}
+
 module.exports = {
   ManhattanIterator,
   ManathanIterator: ManhattanIterator, // backward compatibility
   OctahedronIterator,
   RaycastIterator,
+  SpiralIterator2d,
   BlockFace
 }

package/src/world.js

@@ -16,7 +16,9 @@ class World extends EventEmitter {
   constructor (chunkGenerator, storageProvider = null, savingInterval = 1000) {
     super()
     this.savingQueue = new Map()
+    this.unloadQueue = new Map()
     this.finishedSaving = Promise.resolve()
+    this.currentlySaving = false // semaphore for saving
     this.columns = {}
     this.chunkGenerator = chunkGenerator
     this.storageProvider = storageProvider
@@ -123,6 +125,17 @@ class World extends EventEmitter {
 
   unloadColumn (chunkX, chunkZ) {
     const key = columnKeyXZ(chunkX, chunkZ)
+    if (this.storageProvider && this.savingQueue.has(key)) {
+      this.unloadQueue.set(key, { chunkX, chunkZ })
+    } else {
+      this.forceUnloadColumn(key, chunkX, chunkZ)
+    }
+  }
+
+  forceUnloadColumn (key, chunkX, chunkZ) {
+    if (this.unloadQueue.has(key)) {
+      this.unloadQueue.delete(key)
+    }
     delete this.columns[key]
     const columnCorner = new Vec3(chunkX * 16, 0, chunkZ * 16)
     this.emit('chunkColumnUnload', columnCorner)
@@ -136,15 +149,24 @@ class World extends EventEmitter {
     // interval. The set structure is maintaining the order of insertion
     for (const [key, { chunkX, chunkZ }] of this.savingQueue.entries()) {
       this.finishedSaving = Promise.all([this.finishedSaving,
-        this.storageProvider.save(chunkX, chunkZ, this.columns[key])])
+        this.storageProvider.save(chunkX, chunkZ, this.columns[key])
+      ])
     }
+    await this.finishedSaving
     this.savingQueue.clear()
+    for (const [key, { chunkX, chunkZ }] of this.unloadQueue.entries()) {
+      this.forceUnloadColumn(key, chunkX, chunkZ)
+    }
     this.emit('doneSaving')
   }
 
   startSaving () {
     this.savingInt = setInterval(async () => {
-      await this.saveNow()
+      if (this.currentlySaving === false) {
+        this.currentlySaving = true
+        await this.saveNow()
+        this.currentlySaving = false
+      }
     }, this.savingInterval)
   }
 

package/test/iterator.test.js

@@ -0,0 +1,39 @@
+/* eslint-env mocha */
+
+const { SpiralIterator2d, ManhattanIterator } = require('../src/iterators')
+const { Vec3 } = require('vec3')
+const expect = require('expect').default
+
+describe('Spiral iterator', () => {
+  it('simple function test', async () => {
+    const startPos = new Vec3(0, 0, 0)
+    const iter = new SpiralIterator2d(startPos, 2)
+    const first = iter.next()
+    const second = iter.next()
+
+    expect(first.x === startPos.x && first.y === startPos.y && first.z === startPos.z).toBeTruthy()
+    expect(second.x === startPos.x && second.y === startPos.y && second.z === startPos.z).toBeFalsy()
+  })
+})
+
+describe('ManhattanIterator iterator', () => {
+  it('First position is same as start', () => {
+    const start = new Vec3(1, 2, 3)
+    const iter = new ManhattanIterator(start.x, start.z, 5)
+    const first = iter.next()
+    expect(first.x === start.x && first.z === start.z).toBeTruthy()
+  })
+
+  it('Sample positions match', () => {
+    const start = new Vec3(1, 2, 3)
+    const iter = new ManhattanIterator(start.x, start.z, 5)
+    const sample = [new Vec3(1, 0, 3), new Vec3(2, 0, 3), new Vec3(1, 0, 4), new Vec3(0, 0, 3)]
+    let counter = 0
+    let next = iter.next()
+    while (next && counter < sample.length) {
+      expect(next.x === sample[counter].x && next.z === sample[counter].z).toBeTruthy()
+      next = iter.next()
+      counter++
+    }
+  })
+})

package/test/raycast.test.js

@@ -1,4 +1,4 @@
-/* eslint-env jest */
+/* eslint-env mocha */
 
 const World = require('prismarine-world')('1.16.4')
 const Chunk = require('prismarine-chunk')('1.16.4')

package/test/test.js

@@ -1,4 +1,4 @@
-/* eslint-env jest */
+/* eslint-env mocha */
 
 const flatMap = require('flatmap')
 const range = require('range').range
@@ -28,11 +28,11 @@ describe('saving and loading works', function () {
   }
 
   const regionPath = 'world/testRegion'
-  beforeAll((cb) => {
+  before((cb) => {
     mkdirp(regionPath, cb)
   })
 
-  afterAll(cb => {
+  after(cb => {
     rimraf(regionPath, cb)
   })
 
@@ -87,11 +87,11 @@ describe('Synchronous saving and loading works', function () {
   }
 
   const regionPath = 'world/testRegionSync'
-  beforeAll((cb) => {
+  before((cb) => {
     mkdirp(regionPath, cb)
   })
 
-  afterAll(cb => {
+  after(cb => {
     rimraf(regionPath, cb)
   })
 

package/types/index.d.ts

@@ -0,0 +1,10 @@
+import { World } from "./world";
+
+export * as iterators from "./iterators";
+
+// Make public the types related to World, but not the classes
+// (since they aren't exported in js)
+import type * as world from "./world";
+export { world };
+
+export default function loader(mcVersion: string): typeof World;

package/types/iterators.d.ts

@@ -0,0 +1,145 @@
+import type { Vec3 } from "vec3";
+
+export declare enum BlockFace {
+    UNKNOWN = -999,
+    BOTTOM = 0,
+    TOP = 1,
+    NORTH = 2,
+    SOUTH = 3,
+    WEST = 4,
+    EAST = 5,
+}
+
+export type RaycastBlock = {
+    x: number;
+    y: number;
+    z: number;
+    face: BlockFace;
+};
+
+export type RaycastIntersection = {
+    pos: Vec3;
+    face: BlockFace;
+};
+
+/** [x0, y0, z0, x1, y1, z1] */
+export type Shape = [number, number, number, number, number, number];
+
+export interface Iterator<T> {
+    next(): T | null;
+}
+
+// 2D spiral iterator, useful to iterate on
+// columns that are centered on bot position
+// https://en.wikipedia.org/wiki/Taxicab_geometry
+export declare class ManhattanIterator implements Iterator<Vec3> {
+    public readonly maxDistance: number;
+    public readonly startx: number;
+    public readonly starty: number;
+    private x: number;
+    private y: number;
+    private layer: number;
+    private leg: number;
+
+    constructor(x: number, y: number, maxDistance: number);
+
+    /**
+     * @returns {Vec3 | null} The current position of the iterator OR null if exceeded maxDistance.
+     */
+    next(): Vec3 | null;
+}
+
+export declare class OctahedronIterator implements Iterator<Vec3> {
+    public readonly start: Vec3;
+    public readonly maxDistance: number;
+    private apothem: number;
+    private x: number;
+    private y: number;
+    private z: number;
+    private L: number;
+    private R: number;
+
+    constructor(start: Vec3, maxDistance: number);
+
+    /**
+     * @returns {Vec3 | null} The current position of the iterator OR null if exceeded maxDistance.
+     */
+    next(): Vec3 | null;
+}
+
+// This iterate along a ray starting at `pos` in `dir` direction
+// It steps exactly 1 block at a time, returning the block coordinates
+// and the face by which the ray entered the block.
+export declare class RaycastIterator implements Iterator<RaycastBlock> {
+    private block: RaycastBlock;
+    public readonly pos: Vec3;
+    public readonly dir: Vec3;
+    private invDirX: number;
+    private invDirY: number;
+    private invDirZ: number;
+    private stepX: number;
+    private stepY: number;
+    private stepZ: number;
+    private tDeltaX: number;
+    private tDeltaY: number;
+    private tDeltaZ: number;
+    private tMaxX: number;
+    private tMaxY: number;
+    private tMaxZ: number;
+    public readonly maxDistance: number;
+
+    constructor(pos: Vec3, dir: Vec3, distance: number);
+
+    /**
+     * @param {Shape[]} shapes Takes shapes from block.shapes.
+     * @param {Vec3} offset Offset from original position to start the intersect calculation from.
+     * @returns {RaycastIntersection | null} A possible intersection.
+     */
+    intersect(shapes: Shape[], offset: Vec3): RaycastIntersection | null;
+
+    /**
+     * @returns {RaycastBlock | null} The block the raycast is currently passing through (not hit detection, just the general AABB of a block if it were there).
+     */
+    next(): RaycastBlock | null;
+}
+
+/**
+ * Spiral outwards from a central position in growing squares.
+ * Every point has a constant distance to its previous and following position of 1. First point returned is the starting position.
+ * Generates positions like this:
+ * ```text
+ * 16 15 14 13 12
+ * 17  4  3  2 11
+ * 18  5  0  1 10
+ * 19  6  7  8  9
+ * 20 21 22 23 24
+ * (maxDistance = 2; points returned = 25)
+ * ```
+ * Copy and paste warrior source: https://stackoverflow.com/questions/3706219/algorithm-for-iterating-over-an-outward-spiral-on-a-discrete-2d-grid-from-the-or
+ */
+export declare class SpiralIterator2d implements Iterator<Vec3> {
+    public readonly start: Vec3;
+    public readonly maxDistance: number;
+    private di: number;
+    private dj: number;
+    private i: number;
+    private j: number;
+    private k: number;
+    private segment_passed: number;
+    private segment_length: number;
+    private readonly NUMBER_OF_POINTS: number;
+
+    /**
+     * @param {Vec3} pos Starting position
+     * @param {number} maxDistance Max distance from starting position
+     */
+    constructor(pos: Vec3, maxDistance: number);
+
+
+    /**
+     * @returns {Vec3 | null} The current position of the iterator OR null if exceeded maxDistance.
+     */
+    next(): Vec3 | null;
+}
+
+export declare const ManathanIterator: ManhattanIterator;

package/types/world.d.ts

@@ -0,0 +1,215 @@
+import type { EventEmitter } from "events";
+import type { Vec3 } from "vec3";
+import type { Block } from "prismarine-block";
+import loaderOfChunk from "prismarine-chunk";
+import type { RaycastBlock } from "./iterators";
+
+export type Chunk = InstanceType<ReturnType<typeof loaderOfChunk>>;
+
+export type ChunkGenerator = (chunkX: number, chunkZ: number) => Chunk;
+export type ChunkCoordinates = { chunkX: number, chunkZ: number };
+export type ChunkCoordsAndColumn = { chunkX: number, chunkZ: number, column: Chunk };
+
+export interface StorageProvider {
+    load(chunkX: number, chunkZ: number): Promise<Chunk>;
+    save(chunkX: number, chunkZ: number, chunk: Chunk): Promise<void>;
+}
+
+export declare class World extends EventEmitter {
+
+    private readonly savingQueue: Map<String, ChunkCoordinates>;
+    private finishedSaving: Promise<unknown>;
+    private readonly columns: { [key: string]: Chunk };
+    public readonly chunkGenerator: ChunkGenerator | null | undefined;
+    public readonly storageProvider: StorageProvider | null | undefined;
+    public readonly savingInterval: number;
+    public readonly sync: WorldSync;
+
+    /**
+     * @param {ChunkGenerator} chunkGenerator A generator that requires X and Z coordinates of lower left of chunk. Returns a {Chunk} chunk object.
+     * @param {StorageProvider} storageProvider The provider the world uses to save chunks. See "prismarine-provider-anvil" or "prismarine-provider-raw".
+     * @param {number} savingInterval The duration in milliseconds between saves.
+     */
+    constructor(
+        chunkGenerator?: ChunkGenerator | null | undefined,
+        storageProvider?: StorageProvider | null | undefined,
+        savingInterval?: number,
+    );
+
+    public initialize(
+        iniFunc: (x: number, y: number, z: number) => Block,
+        length: number,
+        width: number,
+        height?: number,
+        iniPos?: Vec3,
+    ): Promise<ChunkCoordinates[]>;
+
+    /**
+     * 
+     * @param {Vec3} from Position to start raycasting from.
+     * @param {Vec3} direction Normalized vector, direction of raycast.
+     * @param {number} range Maximum range to raycast.
+     * @param {(block: Block) => boolean} matcher Optional function with a block parameter, return true if the raycast should stop at this block, false otherwise.
+     */
+    public raycast(
+        from: Vec3,
+        direction: Vec3,
+        range: number,
+        matcher?: (block: Block) => boolean,
+    ): Promise<RaycastBlock | null>;
+
+    public getLoadedColumn(chunkX: number, chunkZ: number): Chunk;
+
+    public getColumn(chunkX: number, chunkZ: number): Promise<Chunk>;
+
+    private _emitBlockUpdate(
+        oldBlock: Block,
+        newBlock: Block,
+        position: Vec3,
+    ): void;
+
+    public setLoadedColumn(
+        chunkX: number,
+        chunkZ: number,
+        chunk: Chunk,
+        save?: boolean,
+    ): void;
+
+    public setColumn(
+        chunkX: number,
+        chunkZ: number,
+        chunk: Chunk,
+        save?: boolean,
+    ): Promise<void>;
+
+    public unloadColumn(chunkX: number, chunkZ: number): void;
+
+    public saveNow(): Promise<void>;
+
+    public startSaving(): void;
+
+    public waitSaving(): Promise<void>;
+
+    public stopSaving(): void;
+
+    public queueSaving(chunkX: number, chunkZ: number): void;
+
+    public saveAt(pos: Vec3): void;
+
+    public getColumns(): ChunkCoordsAndColumn[];
+
+    public getLoadedColumnAt(pos: Vec3): Chunk;
+
+    public getColumnAt(pos: Vec3): Promise<Chunk>;
+
+    public setBlock(pos: Vec3, block: Block): Promise<void>;
+
+    public getBlock(pos: Vec3): Promise<Block>;
+
+    public getBlockStateId(pos: Vec3): Promise<number>;
+
+    public getBlockType(pos: Vec3): Promise<number>;
+
+    public getBlockData(pos: Vec3): Promise<number>;
+
+    public getBlockLight(pos: Vec3): Promise<number>;
+
+    public getSkyLight(pos: Vec3): Promise<number>;
+
+    public getBiome(pos: Vec3): Promise<number>;
+
+    public setBlockStateId(pos: Vec3, stateId: number): Promise<void>;
+
+    public setBlockType(pos: Vec3, blockType: number): Promise<void>;
+
+    public setBlockData(pos: Vec3, data: number): Promise<void>;
+
+    public setBlockLight(pos: Vec3, light: number): Promise<void>;
+
+    public setSkyLight(pos: Vec3, light: number): Promise<void>;
+
+    public setBiome(pos: Vec3, biome: number): Promise<void>;
+
+}
+
+export declare class WorldSync extends EventEmitter {
+
+    public readonly async: World;
+
+    /**
+     * @param {World} world Async representation of the World object.
+     */
+    constructor(world: World);
+
+
+    public initialize(
+        iniFunc: (x: number, y: number, z: number) => Block,
+        length: number,
+        width: number,
+        height?: number,
+        iniPos?: Vec3,
+    ): void;
+
+    /**
+     * 
+     * @param {Vec3} from Position to start raycasting from.
+     * @param {Vec3} direction Normalized vector, direction of raycast.
+     * @param {number} range Maximum range to raycast.
+     * @param {(block: Block) => boolean} matcher Optional function with a block parameter, return true if the raycast should stop at this block, false otherwise.
+     */
+    public raycast(
+        from: Vec3,
+        direction: Vec3,
+        range: number,
+        matcher?: (block: Block) => boolean,
+    ): RaycastBlock | null;
+
+    private _emitBlockUpdate(
+        oldBlock: Block,
+        newBlock: Block,
+        position: Vec3
+    ): void;
+
+    public getColumns(): ChunkCoordsAndColumn[];
+
+    public getColumn(chunkX: number, chunkZ: number): Chunk;
+
+    public getColumnAt(pos: Vec3): Chunk;
+
+    public setColumn(
+        chunkX: number,
+        chunkZ: number,
+        chunk: Chunk,
+        save?: boolean,
+    ): void;
+
+    public unloadColumn(chunkX: number, chunkZ: number): void;
+
+    public getBlock(pos: Vec3): Block;
+
+    public getBlockStateId(pos: Vec3): number;
+
+    public getBlockType(pos: Vec3): number;
+
+    public getBlockData(pos: Vec3): number;
+
+    public getBlockLight(pos: Vec3): number;
+
+    public getSkyLight(pos: Vec3): number;
+
+    public getBiome(pos: Vec3): number;
+
+    public setBlock(pos: Vec3, block: Block): void;
+
+    public setBlockStateId(pos: Vec3, stateId: number): void;
+
+    public setBlockType(pos: Vec3, blockType: number): void;
+
+    public setBlockData(pos: Vec3, data: number): void;
+
+    public setBlockLight(pos: Vec3, light: number): void;
+
+    public setSkyLight(pos: Vec3, light: number): void;
+
+    public setBiome(pos: Vec3, biome: number): void;
+}