prismarine-item 1.11.0

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: "@types/node"
+    versions:
+    - 15.0.0
+  - dependency-name: minecraft-data
+    versions:
+    - 2.80.0

package/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm install
+    - run: npm test

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,25 @@
+name: npm-publish
+on:
+  push:
+    branches:
+      - master # Change this to your default branch
+jobs:
+  npm-publish:
+    name: npm-publish
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@master
+    - 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

package/README.md

@@ -0,0 +1,174 @@
+# prismarine-item
+[![NPM version](https://img.shields.io/npm/v/prismarine-item.svg)](http://npmjs.com/package/prismarine-item)
+[![Build Status](https://github.com/PrismarineJS/prismarine-item/workflows/CI/badge.svg)](https://github.com/PrismarineJS/prismarine-item/actions?query=workflow%3A%22CI%22)
+
+Represent a minecraft item with its associated data
+
+## Usage
+
+```js
+const Item = require('prismarine-item')('1.8')
+
+const ironShovelItem = new Item(256, 1)
+console.log(ironShovelItem)
+
+const notchItem = Item.toNotch(ironShovelItem)
+console.log(notchItem)
+console.log(Item.fromNotch(notchItem))
+```
+
+## API
+
+### Item(type, count[, metadata], nbt)
+
+#### Item.toNotch(item)
+
+Take an `item` in the format of the minecraft packets and return an `Item` instance.
+
+#### Item.fromNotch(item)
+
+Take an `Item` instance and return it in the format of the minecraft packets.
+
+### Item.anvil(itemOne, itemTwo, creative[, newName])
+
+Take two seperate `item` instances, and makes one item using the same combining done by the vanilla anvil
+
+### Item.equal(itemOne, itemTwo[, matchStackSize])
+
+`itemOne` - first item
+
+`itemTwo` - second item
+
+`matchStackSize` - whether to check for count equality
+
+Checks equality between two items based on itemType, count, metadata, and stringified nbt
+
+#### item.type
+
+Numerical id.
+
+#### item.count
+
+#### item.metadata
+
+Number which represents different things depending on the item.
+See http://www.minecraftwiki.net/wiki/Data_values#Data
+
+#### item.nbt
+
+Buffer.
+
+#### item.name
+
+#### item.displayName
+
+#### item.stackSize
+
+#### item.equal(otherItem)
+
+Return true if items are equal.
+
+#### item.durabilityUsed
+
+A getter/setter for abstracting the underlying nbt
+
+#### item.customName
+
+the item's custom name (ie. anvil name)
+
+#### item.customLore
+
+the item's custom lore (ie. set in give command)
+
+#### item.enchants
+
+A getter/setter for abstracting the underlying nbt (does calculations) 
+
+#### item.repairCost
+
+A getter/setter for abstracting the underlying nbt.
+See https://minecraft.gamepedia.com/Anvil_mechanics#Anvil_Uses
+
+#### item.spawnEggMobName
+
+A getter for abstracting the underlying nbt, get's the mob name from a spawn egg Item. e.g. a zombie spawn egg on 1.8 will return `Zombie`
+
+
+## History
+
+## 1.11.0
+
+* fix typings
+* add .customLore
+* .customName now returns null when there is no custom name
+
+## 1.10.1
+
+* update typings (thanks @stzups)
+
+## 1.10.0
+
+* add item.spawnEggMobName (thanks @U9G)
+
+## 1.9.1
+
+* fix item present detection (thanks @U9G)
+
+## 1.9.0
+
+* Revise typings (thanks @extremeheat)
+* Revise deps (thanks @rom1504)
+* Correctly identify null items in MC 1.13 (thanks @u9g)
+
+## 1.8.0
+
+* add matchStackSize option on Item.equal (thanks @u9g)
+
+## 1.7.0
+
+* Item.equal checks nbt equality (thanks @u9g)
+
+## 1.6.0
+
+* Item.anvil added, along with a ton of getters & setters for Item (thanks @u9g)
+
+### 1.5.0
+
+* 1.16 support (thanks @DrakoTrogdor)
+
+### 1.4.0
+
+* typescripts definitions (thanks @IdanHo)
+
+### 1.3.0
+
+* 1.15 support
+
+### 1.2.0
+
+* 1.14 support
+
+### 1.1.1
+
+* allow unknown items
+
+### 1.1.0
+
+* 1.13 support
+
+### 1.0.2
+
+* make nbt default to null
+* display the item id if it is not found in minecraft data
+
+### 1.0.1
+
+* bump mcdata
+
+### 1.0.0
+
+* bump dependencies
+
+### 0.0.0
+
+* Import from mineflayer

package/example.js

@@ -0,0 +1,21 @@
+const Item = require('./')('1.8')
+
+const ironShovelItem = new Item(256, 1)
+
+console.log(ironShovelItem)
+
+const notchItem = Item.toNotch(ironShovelItem)
+console.log(notchItem)
+
+console.log(Item.fromNotch(notchItem))
+
+const Item113 = require('./')('1.13.2')
+
+const ironShovelItem2 = new Item113(472, 1)
+
+console.log(ironShovelItem2)
+
+const notchItem2 = Item113.toNotch(ironShovelItem2)
+console.log(notchItem2)
+
+console.log(Item113.fromNotch(notchItem2))

package/index.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+
+import { Tags, TagType } from 'prismarine-nbt'
+
+type ItemLike = Item | null
+
+declare class Item {
+    constructor(type: number, count: number, metadata?: number, nbt?: object);
+    type: number;
+    slot: number;
+    count: number;
+    metadata: number;
+    nbt: Tags[TagType] | null;
+    name: string;
+    displayName: string;
+    stackSize: number;
+    durabilityUsed: number;
+    enchants: NormalizedEnchant[];
+    repairCost: number;
+    customName: string | null;
+    customLore: string | null;
+    readonly spawnEggMobName: string;
+    static equal(item1: Item, item2: Item, matchStackSize: boolean): boolean;
+    static toNotch(item: ItemLike): NotchItem;
+    static fromNotch(item: NotchItem): ItemLike;
+    static anvil (itemOne: ItemLike, itemTwo: ItemLike, creative: boolean, rename: string | undefined): { xpCost: number, item: ItemLike }
+}
+
+declare interface NotchItem {
+    // 1.8 - 1.12
+    blockId?: number;
+    itemDamage?: number;
+    // 1.13 - 1.15
+    present?: boolean;
+    itemId?: number;
+
+    itemCount?: number;
+    nbtData?: Buffer;
+}
+
+declare interface NormalizedEnchant {
+    name: string;
+    lvl: number
+}
+
+export default function loader(mcVersion: string): typeof Item;

package/index.js

@@ -0,0 +1,197 @@
+const nbt = require('prismarine-nbt')
+function loader (version) {
+  const mcData = require('minecraft-data')(version)
+  class Item {
+    constructor (type, count, metadata, nbt) {
+      if (type == null) return
+
+      if (metadata instanceof Object && metadata !== null) {
+        nbt = metadata
+        metadata = 0
+      }
+
+      this.type = type
+      this.count = count
+      this.metadata = metadata == null ? 0 : metadata
+      this.nbt = nbt || null
+
+      const itemEnum = mcData.findItemOrBlockById(type)
+      if (itemEnum) {
+        this.name = itemEnum.name
+        this.displayName = itemEnum.displayName
+        if ('variations' in itemEnum) {
+          for (const i in itemEnum.variations) {
+            if (itemEnum.variations[i].metadata === metadata) { this.displayName = itemEnum.variations[i].displayName }
+          }
+        }
+        this.stackSize = itemEnum.stackSize
+      } else {
+        this.name = 'unknown'
+        this.displayName = 'unknown'
+        this.stackSize = 1
+      }
+    }
+
+    static equal (item1, item2, matchStackSize = true) {
+      if (item1 == null && item2 == null) {
+        return true
+      } else if (item1 == null) {
+        return false
+      } else if (item2 == null) {
+        return false
+      } else {
+        return (item1.type === item2.type &&
+            (matchStackSize ? item1.count === item2.count : true) &&
+            item1.metadata === item2.metadata &&
+            JSON.stringify(item1.nbt) === JSON.stringify(item2.nbt))
+      }
+    }
+
+    static toNotch (item) {
+      if (mcData.isNewerOrEqualTo('1.13')) {
+        if (item == null) return { present: false }
+        const notchItem = {
+          present: true,
+          itemId: item.type,
+          itemCount: item.count
+        }
+        if (item.nbt && item.nbt.length !== 0) { notchItem.nbtData = item.nbt }
+        return notchItem
+      } else {
+        if (item == null) return { blockId: -1 }
+        const notchItem = {
+          blockId: item.type,
+          itemCount: item.count,
+          itemDamage: item.metadata
+        }
+        if (item.nbt && item.nbt.length !== 0) { notchItem.nbtData = item.nbt }
+        return notchItem
+      }
+    }
+
+    static fromNotch (item) {
+      if (mcData.isNewerOrEqualTo('1.14')) {
+        if (item.present === false) return null
+        return new Item(item.itemId, item.itemCount, item.nbtData)
+      } else if (mcData.isNewerOrEqualTo('1.13')) {
+        if (item.itemId === -1 || item.present === false) return null
+        return new Item(item.itemId, item.itemCount, item.nbtData)
+      } else {
+        if (item.blockId === -1) return null
+        return new Item(item.blockId, item.itemCount, item.itemDamage, item.nbtData)
+      }
+    }
+
+    get customName () {
+      if (Object.keys(this).length === 0) return null
+      return this?.nbt?.value?.display?.value?.Name?.value ?? null
+    }
+
+    set customName (newName) {
+      if (!this.nbt) this.nbt = { name: '', type: 'compound', value: {} }
+      if (!this.nbt.value.display) this.nbt.value.display = { type: 'compound', value: {} }
+      this.nbt.value.display.value.Name = { type: 'string', value: newName }
+    }
+
+    get customLore () {
+      if (Object.keys(this).length === 0) return null
+      return this?.nbt?.value?.display?.value?.Name?.value ?? null
+    }
+
+    set customLore (newLore) {
+      if (!this.nbt) this.nbt = { name: '', type: 'compound', value: {} }
+      if (!this.nbt.value.display) this.nbt.value.display = { type: 'compound', value: {} }
+      this.nbt.value.display.value.Lore = { type: 'string', value: newLore }
+    }
+
+    // gets the cost based on previous anvil uses
+    get repairCost () {
+      if (Object.keys(this).length === 0) return 0
+      return this?.nbt?.value?.RepairCost?.value ?? 0
+    }
+
+    set repairCost (value) {
+      if (!this?.nbt) this.nbt = { name: '', type: 'compound', value: {} }
+      this.nbt.value.RepairCost = { type: 'int', value }
+    }
+
+    get enchants () {
+      if (Object.keys(this).length === 0) return []
+      if (mcData.isOlderThan('1.13')) {
+        let itemEnch
+        if (this.name === 'enchanted_book' && this?.nbt?.value?.StoredEnchantments) {
+          itemEnch = nbt.simplify(this.nbt).StoredEnchantments
+        } else if (this?.nbt?.value?.ench) {
+          itemEnch = nbt.simplify(this.nbt).ench
+        } else {
+          itemEnch = []
+        }
+        return itemEnch.map(ench => ({ lvl: ench.lvl, name: mcData.enchantments[ench.id].name }))
+      } else {
+        let itemEnch = []
+        if (this?.nbt?.value?.Enchantments) {
+          itemEnch = nbt.simplify(this.nbt).Enchantments
+        } else if (this?.nbt?.value?.StoredEnchantments) {
+          itemEnch = nbt.simplify(this.nbt).StoredEnchantments
+        } else {
+          itemEnch = []
+        }
+        return itemEnch.map(ench => ({ lvl: ench.lvl, name: ench.id.replace(/minecraft:/, '') }))
+      }
+    }
+
+    set enchants (normalizedEnchArray) {
+      const isBook = this.name === 'enchanted_book'
+      const postEnchantChange = mcData.isOlderThan('1.13')
+      const enchListName = postEnchantChange ? 'ench' : 'Enchantments'
+      const type = postEnchantChange ? 'short' : 'string'
+      if (!this.nbt) this.nbt = { name: '', type: 'compound', value: {} }
+
+      const enchs = normalizedEnchArray.map(({ name, lvl }) => {
+        const value = postEnchantChange ? mcData.enchantmentsByName[name].id : `minecraft:${mcData.enchantmentsByName[name].name}`
+        return { id: { type, value }, lvl: { type: 'short', value: lvl } }
+      })
+
+      if (enchs.length !== 0) {
+        this.nbt.value[isBook ? 'StoredEnchantments' : enchListName] = { type: 'list', value: { type: 'compound', value: enchs } }
+      }
+
+      if (mcData.isNewerOrEqualTo('1.13') && mcData.itemsByName[this.name].maxDurability) this.nbt.value.Damage = { type: 'int', value: 0 }
+    }
+
+    get durabilityUsed () {
+      if (Object.keys(this).length === 0) return null
+      if (mcData.isNewerOrEqualTo('1.13')) {
+        return this?.nbt?.value?.Damage?.value ?? 0
+      } else {
+        return this.metadata ?? 0
+      }
+    }
+
+    set durabilityUsed (value) {
+      if (mcData.isNewerOrEqualTo('1.13')) {
+        if (!this?.nbt) this.nbt = { name: '', type: 'compound', value: {} }
+        this.nbt.value.Damage = { type: 'int', value }
+      } else {
+        this.metadata = value
+      }
+    }
+
+    get spawnEggMobName () {
+      if (mcData.isOlderThan('1.9')) {
+        return mcData.entitiesArray.find(o => o.internalId === this.metadata).name
+      }
+      if (mcData.isOlderThan('1.13')) {
+        const data = nbt.simplify(this.nbt)
+        const entityName = data.EntityTag.id
+        return entityName.replace('minecraft:', '')
+      }
+      return this.name.replace('_spawn_egg', '')
+    }
+  }
+
+  Item.anvil = require('./lib/anvil.js')(mcData, Item)
+  return Item
+}
+
+module.exports = loader

package/lib/anvil.js

@@ -0,0 +1,173 @@
+function loader (mcData, Item) {
+  function combine (itemOne, itemTwo, creative, renamedName) {
+    const rename = typeof renamedName === 'string'
+    const data = {
+      finalEnchs: [],
+      fixedDurability: 0
+    }
+    let onlyRename = false // to tell if its just a rename
+    if (!combinePossible(itemOne, itemTwo) && itemTwo !== null) return { xpCost: 0, item: null }
+    let cost = 0
+    if (rename) {
+      onlyRename = true
+      const renameCost = getRenameCost(itemOne)
+      if (renameCost === -1) return { xpCost: 0, item: null }
+      cost += renameCost
+    }
+    if (itemOne.durabilityUsed !== 0) {
+      onlyRename = false
+      const { xpLevelCost: repairCost, fixedDurability, usedMats } = getRepairCost(itemOne, itemTwo)
+      data.fixedDurability = fixedDurability
+      data.usedMats = usedMats
+      cost += repairCost
+    }
+    if (itemTwo && (itemTwo.name === itemOne.name || itemTwo.name === 'enchanted_book')) {
+      onlyRename = false
+      const { xpLevelCost: enchantCost, finalEnchs } = combineEnchants(itemOne, itemTwo, creative)
+      data.finalEnchs = finalEnchs
+      if (enchantCost === 0 && !rename && itemOne.metadata === 0) return { xpCost: 0, item: null } // no change
+      cost += enchantCost
+    }
+    if (itemTwo === null && itemOne.customName === renamedName) return { xpCost: 0, item: null } // no change
+    cost += itemOne.repairCost + (itemTwo?.repairCost ?? 0)
+
+    if (cost > 39 && onlyRename) cost = 39
+    else if (cost >= 40) return { xpCost: 0, item: null } // show too expensive message
+
+    let finalItem = null
+    if (itemOne) {
+      finalItem = new Item(itemOne.type, itemOne.count, 0, JSON.parse(JSON.stringify(itemOne.nbt)))
+      const repairCost = Math.max(itemOne.repairCost, (itemTwo?.repairCost ?? 0)) * 2 + 1
+      if (data?.finalEnchs.length > 0) finalItem.enchants = data.finalEnchs
+      if (rename) finalItem.customName = renamedName
+      finalItem.repairCost = repairCost
+      if (itemOne.name !== 'enchanted_book') finalItem.durabilityUsed = itemOne.durabilityUsed - data.fixedDurability
+    }
+    return { xpCost: cost, item: finalItem, usedMats: data.usedMats }
+  }
+
+  /**
+   *
+   * @param {Item} itemOne left hand item
+   * @param {Item} itemTwo right hand item
+   * @returns {xpLevelCost, finalEnchs}
+   * xpLevelCost is enchant data that is strictly from combining enchants
+   * finalEnchs is the array of enchants on the final object
+   */
+  function combineEnchants (itemOne, itemTwo, creative) {
+    const rightIsBook = itemTwo.name === 'enchanted_book'
+    const finalEnchs = itemOne.enchants
+    const finalEnchsByName = finalEnchs.map(x => x.name)
+    const itemTwoEnch = itemTwo.enchants
+    let xpLevelCost = 0
+    for (const ench of itemTwoEnch) {
+      const enchOnItemOne = finalEnchs.find(x => x.name === ench.name)
+      let { exclude, maxLevel, category, weight } = mcData.enchantmentsByName[ench.name]
+      const multiplier = getMultipliers(weight, rightIsBook)
+      if (!(itemOne.name === 'enchanted_book' && rightIsBook) && !mcData.itemsByName[itemOne.name].enchantCategories.includes(category) && !creative) continue
+      else if (enchOnItemOne === undefined) { // first item doesn't have this ench
+        exclude = exclude.map(name => mcData.enchantmentsByName[name].name)
+        if (exclude.some(excludedEnch => finalEnchsByName.includes(excludedEnch))) { // has an excluded enchant
+          xpLevelCost++
+        } else {
+          const finalLevel = ench.lvl
+          xpLevelCost += finalLevel * multiplier
+          finalEnchs.push({ name: ench.name, lvl: ench.lvl })
+        }
+      } else {
+        let finalLevel = 0
+        const itemOneLevel = enchOnItemOne.lvl
+        const itemTwoLevel = ench.lvl
+        if (itemOneLevel === itemTwoLevel) {
+          finalLevel = Math.min(itemOneLevel + 1, maxLevel)
+          enchOnItemOne.lvl = finalLevel
+        } else if (itemTwoLevel > itemOneLevel) {
+          finalLevel = itemTwoLevel
+          enchOnItemOne.lvl = finalLevel
+        } else if (itemOneLevel > itemTwoLevel) {
+          finalLevel = itemOneLevel
+        }
+        xpLevelCost += finalLevel * multiplier
+      }
+    }
+    return { xpLevelCost, finalEnchs }
+  }
+
+  // converts enchant weight to enchant cost multiplier
+  function getMultipliers (weight, isBook) {
+    const itemMultiplier = {
+      10: 1,
+      5: 2,
+      2: 4,
+      1: 8
+    }[weight]
+    return isBook ? Math.max(1, itemMultiplier / 2) : itemMultiplier
+  }
+
+  /**
+   *
+   * @param {Item} itemOne left hand item
+   * @param {Item} itemTwo right hand item
+   * @returns {xpLevelCost, fixedDurability, usedMats}
+   * xpLevelCost is the number of xp levels used for repair (if any)
+   * fixedDurability is duribility after using the anvil
+   * usedMats is the number of materials used to fix the broken item (if many mats is used)
+   */
+  function getRepairCost (itemOne, itemTwo) {
+    if (itemTwo === null) return { xpLevelCost: 0, fixedDurability: 0, usedMats: 0 } // air
+    else if (itemTwo.name === 'enchanted_book') return { xpLevelCost: 0, fixedDurability: 0, usedMats: 0 }
+
+    const maxDurability = mcData.itemsByName[itemOne.name].maxDurability
+    const durabilityLost = itemOne.durabilityUsed
+    const fixMaterials = mcData.itemsByName[itemOne.name].repairWith.concat([itemOne.name])
+    if (!fixMaterials.includes(itemTwo.name) && itemOne.name !== itemTwo.name) {
+      return 0 // Enchanted book can't fix
+    }
+    let results = {
+      fixedDurability: 0,
+      xpLevelCost: 0,
+      usedMats: 0
+    }
+    if (itemTwo.name === itemOne.name) {
+      const possibleFixedDura = Math.floor(0.12 * maxDurability) + itemTwo.metadata
+      results = {
+        fixedDurability: itemOne.metadata < possibleFixedDura ? itemOne.durabilityUsed : possibleFixedDura,
+        xpLevelCost: 2,
+        usedMats: 1
+      }
+    } else if (durabilityLost !== 0) {
+      const durabilityFixedPerMat = Math.floor(maxDurability * 0.25)
+      const matsToFullyRepair = Math.ceil(durabilityLost / durabilityFixedPerMat)
+      if (itemTwo.count > matsToFullyRepair) { // takeall of itemTwo
+        results = {
+          fixedDurability: maxDurability - itemOne.durabilityUsed,
+          xpLevelCost: matsToFullyRepair, // 1 exp lvl per mat used
+          usedMats: matsToFullyRepair
+        }
+      } else if (itemOne && itemTwo) {
+        results = {
+          fixedDurability: Math.min(itemOne.durabilityUsed, durabilityFixedPerMat * itemTwo.count),
+          xpLevelCost: itemTwo.count, // 1 exp lvl per mat used
+          usedMats: itemTwo.count
+        }
+      }
+    }
+    return results
+  }
+
+  function getRenameCost (item) {
+    if (item?.nbt?.value?.RepairCost?.value === 0x7fffffff) return -1
+    return 1
+  }
+
+  function combinePossible (itemOne, itemTwo) {
+    if (!itemOne?.name || !itemTwo?.name || (!itemOne?.name && !itemTwo?.name)) return false
+    let fixMaterials = (mcData.itemsByName[itemOne.name].repairWith ?? []).concat([itemOne.name])
+    if (itemOne.name !== 'enchanted_book') fixMaterials = fixMaterials.concat(['enchanted_book'])
+    return fixMaterials.includes(itemTwo.name)
+  }
+
+  return combine
+}
+
+module.exports = loader