prismarine-world 3.6.1 → 3.6.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/HISTORY.md

@@ -1,5 +1,12 @@
 ## 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

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "prismarine-world",
-  "version": "3.6.1",
+  "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",
@@ -32,19 +33,19 @@
   "homepage": "https://github.com/PrismarineJS/prismarine-world",
   "devDependencies": {
     "buffer-equal": "^1.0.0",
+    "expect": "^29.1.0",
     "flatmap": "0.0.3",
     "minecraft-data": "^3.0.0",
     "mkdirp": "^0.5.1",
-    "prismarine-chunk": "^1.14.0",
-    "prismarine-world": "file:.",
+    "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",
-    "expect": "^27.3.1",
-    "mocha": "^9.1.3"
+    "standard": "^17.0.0"
   },
   "dependencies": {
     "vec3": "^0.1.7"

package/src/iterators.js

@@ -24,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--
@@ -217,7 +221,7 @@ class SpiralIterator2d {
    * 20 21 22 23 24
    * (maxDistance = 2; points returned = 25)
    * ```
-   * Copy and past warrior source: https://stackoverflow.com/questions/3706219/algorithm-for-iterating-over-an-outward-spiral-on-a-discrete-2d-grid-from-the-or
+   * 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
    */

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

@@ -1,8 +1,8 @@
 /* eslint-env mocha */
 
-const { SpiralIterator2d } = require('../src/iterators')
+const { SpiralIterator2d, ManhattanIterator } = require('../src/iterators')
 const { Vec3 } = require('vec3')
-const expect = require('expect')
+const expect = require('expect').default
 
 describe('Spiral iterator', () => {
   it('simple function test', async () => {
@@ -15,3 +15,25 @@ describe('Spiral iterator', () => {
     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/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;
+}