Active item half functional

ADDITIONS.md

@@ -1,4 +1,8 @@
 
+# Modding changes
+
+This document briefly documents what have been added (or removed) regarding modding capabilities
+
 ## JSON additions
 
 ---------------
@@ -56,6 +60,7 @@ val color: TileColor = TileColor.DEFAULT
 ---------------
 
 ### Prototypes
+ * `damageTable` can be defined directly, without referencing other JSON file (experimental feature)
 
 #### Items
  * `inventoryIcon` additions if specified as array:
@@ -72,12 +77,13 @@ val color: TileColor = TileColor.DEFAULT
    * Used by world tile rendering code (render piece rule `Connects`)
    * And finally, used by `canPlaceMaterial` to determine whenever player can place blocks next to it (at least one such tile should be present for player to be able to place blocks next to it)
 
----------------
+## Scripting
 
-### Scripting
+---------------
 
 #### Random
  * Added `random:randn(deviation: double, mean: double): double`, returns normally distributed double, where `deviation` stands for [Standard deviation](https://en.wikipedia.org/wiki/Standard_deviation), and `mean` specifies middle point
+ * Removed `random:addEntropy`
 
 #### animator
 

CHANGES.md

@@ -1,15 +1,4 @@
 
-## Differences between original game engine and KStarbound
-
-Despite these two pieces of software try to achieve the same
-goal of providing environment for mods and their content (including base game,
-which is technically a mod), they have different ways of doing so.
-
-While it is no secret that KStarbound contains bits of original code,
-whenever be it runtime constants, or json deserialization structures,
-they are never copied directly. This file covers most notable differences
-between engines which end-users will see.
-
 ### Technical differences
 
 * Lighting engine is based off original code, but is heavily modified, such as:
@@ -20,12 +9,3 @@ between engines which end-users will see.
 * Chunk rendering is split into render regions, which size can be adjusted in settings
   * Increasing render region size will decrease CPU load when rendering world and increase GPU utilization efficiency, while hurting CPU performance on chunk updates, and vice versa
   * Render region size themselves align with world borders, so 3000x2000 world would have 30x25 sized render regions
-
-### Modding differences
- * Generally, object orientation and parameters can override more properties on fly
-   * Space scan of sprite on atlas is not supported yet (original engine does not support this)
- * While original game engine is quite lenient about what it can load, KStarbound aims to be more strict about inputs. This implies KStarbound validates input much more than original engine, while also giving more clear hints at whats wrong with prototypes
-
-### Modding API changes
- * Objects
-   * `damageTable` can be defined directly, without referencing other JSON file

CREDITS.md

@@ -1,26 +1,26 @@
 
-### Libraries making this project possible
+### Libraries which made this project possible
 
-* [OpenJDK - Reference Java Virtual Machine and Java Standard Library implementations](https://openjdk.org/)
+ * [OpenJDK - Reference Java Virtual Machine and Java Standard Library implementations](https://openjdk.org/)
-* [Kotlin programming language](https://kotlinlang.org/)
+ * [Kotlin programming language](https://kotlinlang.org/) as well as Kotlin Coroutines
-* [LWJGL - Lightweight Java Game Library](https://www.lwjgl.org/)
+ * [LWJGL - Lightweight Java Game Library](https://www.lwjgl.org/)
-* [Lua, embeddable scripting language](https://www.lua.org/)
+ * [Lua, embeddable scripting language](https://www.lua.org/) and it's [JVM Implementation](https://github.com/mjanicek/rembulan) by [Miroslav Janíček](https://github.com/mjanicek) (and updated [fork](https://github.com/kroepke/luna))
-* [mimalloc, a compact general purpose allocator with excellent performance](https://github.com/microsoft/mimalloc)
+ * [fastutil - extends the Java™ Collections Framework by providing type-specific maps, sets, lists and queues. ](https://github.com/vigna/fastutil)
-* [fastutil - extends the Java™ Collections Framework by providing type-specific maps, sets, lists and queues. ](https://github.com/vigna/fastutil)
+ * [Guava - Google core libraries for Java](https://github.com/google/guava)
-* [box2d - 2D Physics Engine](https://github.com/erincatto/box2d)
+ * [Gson - A Java serialization/deserialization library to convert Java Objects into JSON and back](https://github.com/google/gson)
-* [Guava - Google core libraries for Java](https://github.com/google/guava)
+ * [Log4j - Apache Log4j 2 is a versatile, feature-rich, efficient logging API and backend for Java](https://github.com/apache/logging-log4j2)
-* [Gson - A Java serialization/deserialization library to convert Java Objects into JSON and back](https://github.com/google/gson)
+
-* [Log4j - Apache Log4j 2 is a versatile, feature-rich, efficient logging API and backend for Java](https://github.com/apache/logging-log4j2)
+and all transitional dependencies
 
 ### Snippets of code making this project possible
 
-* [Super Fast Ray Casting in Tiled Worlds using DDA by javidx9](https://www.youtube.com/watch?v=NbSee-XM7WA)
+ * [Super Fast Ray Casting in Tiled Worlds using DDA by javidx9](https://www.youtube.com/watch?v=NbSee-XM7WA)
-* [Efficient HSV convertor inside Fragment Shader by Sam Hocevar](https://stackoverflow.com/questions/15095909/from-rgb-to-hsv-in-opengl-glsl)
+ * [Efficient HSV convertor inside Fragment Shader by Sam Hocevar](https://stackoverflow.com/questions/15095909/from-rgb-to-hsv-in-opengl-glsl)
 
 ### Special Thanks
 
-* JetBrains
+ * JetBrains
-  * for creating amazing programming language Kotlin
+   * for creating amazing programming language Kotlin
-  * for providing IntelliJ IDEA Community Edition free of charge for making these projects possible to write
+   * for providing IntelliJ IDEA Community Edition free of charge for making these projects possible to write
-* Curtis Schweitzer, your ability to make atmospheric music can not be described by words
+ * Curtis Schweitzer, your ability to make atmospheric music can not be described by words
-* Starbound Community, for being passionate and determinant in keeping game alive
+ * Starbound Community, for being passionate and determinant in keeping game alive

README.md

@@ -7,3 +7,20 @@ Make sure to specify next settings as startup options to JVM:
 -Dfile.encoding=UTF8
 ```
 
+#### Differences between original game engine and this engine
+
+Despite these two pieces of software try to achieve the same
+goal of providing environment for mods and their content (including base game,
+which is technically a mod), they have different ways of doing so.
+
+While it is no secret that this engine contains chunks of original code,
+whenever be it runtime constants, json deserialization structures, or business logic algorithms,
+they are generally not copied directly.
+
+Reminder to everyone that comes across this project is that it has
+no evil goals of harming Chucklefish in any way, and exists solely
+to fix issues present in original engine while also extending moddability.
+
+It is expected you use legitimate copy of game when using this project.
+If we suspect that you are not using legitimate copy and unable to prove otherwise,
+we deserve the right to not help you.

src/main/kotlin/ru/dbotthepony/kstarbound/Starbound.kt

@@ -419,8 +419,10 @@ object Starbound : BlockableEventLoop("Universe Thread"), Scheduler, ISBFileLoca
 			KOptional(JsonPatch.apply(ELEMENTS_ADAPTER.read(file.jsonReader()), findPatches))
 		}.orNull() ?: return null
 
-		val pathTraverser = if (jsonPath == null) JsonPath.EMPTY else JsonPath.query(jsonPath)
+		if (jsonPath == null)
-		return pathTraverser.get(json)
+			return json
+
+		return JsonPath.query(jsonPath).get(json)
 	}
 
 	private val fileSystems = ArrayList<IStarboundFile>()

src/main/kotlin/ru/dbotthepony/kstarbound/defs/Damage.kt

@@ -132,7 +132,7 @@ data class DamageSource(
 		stream.readInt(),
 		EntityDamageTeam(stream, isLegacy),
 		stream.readNullableString(),
-		stream.readNullableDouble(),
+		stream.readNullableDouble(isLegacy),
 		stream.readInternedString(),
 		ImmutableList.copyOf(stream.readCollection { EphemeralStatusEffect(stream, isLegacy) }),
 		stream.readMVariant2({ readDouble(isLegacy) }, { readVector2d(isLegacy) }) ?: throw IllegalArgumentException("Empty MVariant knockback"),
@@ -165,7 +165,7 @@ data class DamageSource(
 		stream.writeInt(sourceEntityId)
 		team.write(stream, isLegacy)
 		stream.writeNullable(damageRepeatGroup, DataOutputStream::writeBinaryString)
-		stream.writeNullable(damageRepeatTimeout, DataOutputStream::writeDouble)
+		stream.writeNullable(damageRepeatTimeout) { writeDouble(it, isLegacy) }
 		stream.writeBinaryString(damageSourceKind)
 		stream.writeCollection(statusEffects) { it.write(stream, isLegacy) }
 		stream.writeMVariant2(knockback, { writeDouble(it, isLegacy) }, { writeStruct2d(it, isLegacy) })

src/main/kotlin/ru/dbotthepony/kstarbound/defs/PhysicsForceRegion.kt

@@ -0,0 +1,129 @@
+package ru.dbotthepony.kstarbound.defs
+
+import com.google.common.collect.ImmutableSet
+import ru.dbotthepony.kommons.io.readCollection
+import ru.dbotthepony.kommons.io.writeBinaryString
+import ru.dbotthepony.kommons.io.writeCollection
+import ru.dbotthepony.kommons.vector.Vector2d
+import ru.dbotthepony.kstarbound.io.readDouble
+import ru.dbotthepony.kstarbound.io.readInternedString
+import ru.dbotthepony.kstarbound.io.readNullableDouble
+import ru.dbotthepony.kstarbound.io.readVector2d
+import ru.dbotthepony.kstarbound.io.writeDouble
+import ru.dbotthepony.kstarbound.io.writeNullableDouble
+import ru.dbotthepony.kstarbound.io.writeStruct2d
+import ru.dbotthepony.kstarbound.math.Line2d
+import ru.dbotthepony.kstarbound.network.syncher.legacyCodec
+import ru.dbotthepony.kstarbound.network.syncher.nativeCodec
+import ru.dbotthepony.kstarbound.world.physics.Poly
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import java.util.function.Predicate
+
+sealed class PhysicsForceRegion {
+	abstract fun write(stream: DataOutputStream, isLegacy: Boolean)
+
+	// enum class Type int32_t
+	// type -> isBlacklist
+	class Filter(val isBlacklist: Boolean, val categories: Set<String>) : Predicate<String> {
+		constructor(stream: DataInputStream, isLegacy: Boolean) : this(if (isLegacy) stream.readInt() > 0 else stream.readBoolean(), ImmutableSet.copyOf(stream.readCollection { readInternedString() }))
+
+		fun write(stream: DataOutputStream, isLegacy: Boolean) {
+			if (isLegacy)
+				stream.writeInt(if (isBlacklist) 1 else 0)
+			else
+				stream.writeBoolean(isBlacklist)
+
+			stream.writeCollection(categories) { writeBinaryString(it) }
+		}
+
+		fun test(categories: Collection<String>): Boolean {
+			if (isBlacklist) {
+				return categories.any { it in this.categories }
+			} else {
+				return categories.any { it in this.categories }
+			}
+		}
+
+		override fun test(t: String): Boolean {
+			if (isBlacklist) {
+				return t !in this.categories
+			} else {
+				return t in this.categories
+			}
+		}
+	}
+
+	data class Directional(val region: Poly, val xTargetVelocity: Double?, val yTargetVelocity: Double?, val controlForce: Double, val filter: Filter) : PhysicsForceRegion() {
+		constructor(stream: DataInputStream, isLegacy: Boolean) : this(
+			Poly.read(stream, isLegacy),
+			stream.readNullableDouble(isLegacy),
+			stream.readNullableDouble(isLegacy),
+			stream.readDouble(isLegacy),
+			Filter(stream, isLegacy)
+		)
+
+		override fun write(stream: DataOutputStream, isLegacy: Boolean) {
+			stream.writeByte(0)
+			region.write(stream, isLegacy)
+			stream.writeNullableDouble(xTargetVelocity, isLegacy)
+			stream.writeNullableDouble(yTargetVelocity, isLegacy)
+			stream.writeDouble(controlForce, isLegacy)
+			filter.write(stream, isLegacy)
+		}
+	}
+
+	data class Radial(val center: Vector2d, val outerRadius: Double, val innerRadius: Double, val targetRadialVelocity: Double, val controlForce: Double, val filter: Filter) : PhysicsForceRegion() {
+		constructor(stream: DataInputStream, isLegacy: Boolean) : this(
+			stream.readVector2d(isLegacy),
+			stream.readDouble(isLegacy),
+			stream.readDouble(isLegacy),
+			stream.readDouble(isLegacy),
+			stream.readDouble(isLegacy),
+			Filter(stream, isLegacy)
+		)
+
+		override fun write(stream: DataOutputStream, isLegacy: Boolean) {
+			stream.writeByte(1)
+			stream.writeStruct2d(center, isLegacy)
+			stream.writeDouble(outerRadius, isLegacy)
+			stream.writeDouble(innerRadius, isLegacy)
+			stream.writeDouble(targetRadialVelocity, isLegacy)
+			stream.writeDouble(controlForce, isLegacy)
+			filter.write(stream, isLegacy)
+		}
+	}
+
+	data class Gradient(val region: Poly, val gradient: Line2d, val baseTargetVelocity: Double, val baseControlForce: Double, val filter: Filter) : PhysicsForceRegion() {
+		constructor(stream: DataInputStream, isLegacy: Boolean) : this(
+			Poly.read(stream, isLegacy),
+			Line2d(stream, isLegacy),
+			stream.readDouble(isLegacy),
+			stream.readDouble(isLegacy),
+			Filter(stream, isLegacy)
+		)
+
+		override fun write(stream: DataOutputStream, isLegacy: Boolean) {
+			stream.writeByte(2)
+			region.write(stream, isLegacy)
+			gradient.write(stream, isLegacy)
+			stream.writeDouble(baseTargetVelocity, isLegacy)
+			stream.writeDouble(baseControlForce, isLegacy)
+			filter.write(stream, isLegacy)
+		}
+	}
+
+	companion object {
+		val CODEC = nativeCodec(::read, PhysicsForceRegion::write)
+		val LEGACY_CODEC = legacyCodec(::read, PhysicsForceRegion::write)
+
+		fun read(stream: DataInputStream, isLegacy: Boolean): PhysicsForceRegion {
+			return when (val type = stream.readUnsignedByte()) {
+				0 -> Directional(stream, isLegacy)
+				1 -> Radial(stream, isLegacy)
+				2 -> Gradient(stream, isLegacy)
+				else -> throw IllegalArgumentException("Unknown force region type $type!")
+			}
+		}
+	}
+}

src/main/kotlin/ru/dbotthepony/kstarbound/defs/item/ItemDescriptor.kt

@@ -163,10 +163,6 @@ data class ItemDescriptor(
 		return "ItemDescriptor[$name, $count, $parameters]"
 	}
 
-	fun makeStack(): ItemStack {
-		return ItemStack.create(this)
-	}
-
 	private fun toJsonStruct() = JsonObject().also {
 		it.add("name", JsonPrimitive(name))
 		it.add("count", JsonPrimitive(count))
@@ -197,8 +193,13 @@ data class ItemDescriptor(
 		}
 	}
 
-	fun build(level: Double? = null, seed: Long? = null, random: RandomGenerator? = null): ItemDescriptor {
+	/**
-		val builder = ref.json["builder"]?.asString ?: return this
+	 * This is fragile, to some extent, because it is SOLE RESPONSIBILITY of builder script to store
+	 * [level] and/or [seed] inside item parameters once it is built (otherwise we will get different or
+	 * reset stats on next item load from serialized state)
+	 */
+	fun build(level: Double? = null, seed: Long? = null, random: RandomGenerator? = null): ItemStack {
+		val builder = ref.json["builder"]?.asString ?: return ref.type.factory(ref, ref.json, parameters.deepCopy(), count)
 
 		try {
 			val lua = LuaEnvironment()
@@ -208,26 +209,13 @@ data class ItemDescriptor(
 
 			val (config, parameters) = lua.invokeGlobal("build", ref.directory, lua.from(ref.json), lua.from(parameters), level, seed)
 
-			// we don't care about "config" here since it is treated equally by code as "parameters"
 			val jConfig = toJsonFromLua(config).asJsonObject
 			val jParameters = toJsonFromLua(parameters).asJsonObject
 
-			// so, lets promote changed "config" parameters to item parameters
+			return ref.type.factory(ref, jConfig, jParameters, count)
-			for ((k, v) in jConfig.entrySet()) {
-				if (ref.json[k] != v) {
-					if (k !in jParameters) {
-						jParameters[k] = v
-					} else {
-						// existing parameters override changed config parameters
-						jParameters[k] = mergeJson(v, jParameters[k])
-					}
-				}
-			}
-
-			return ItemDescriptor(name, count, jParameters)
 		} catch (err: Throwable) {
 			LOGGER.error("Error while generating randomized item '$name' using script $builder", err)
-			return this
+			return ref.type.factory(ref, ref.json, parameters.deepCopy(), count)
 		}
 	}
 

src/main/kotlin/ru/dbotthepony/kstarbound/defs/item/ItemType.kt

@@ -1,8 +1,12 @@
 package ru.dbotthepony.kstarbound.defs.item
 
+import com.google.gson.JsonObject
+import ru.dbotthepony.kstarbound.item.ActiveItemStack
+import ru.dbotthepony.kstarbound.item.ItemRegistry
+import ru.dbotthepony.kstarbound.item.ItemStack
 import ru.dbotthepony.kstarbound.json.builder.IStringSerializable
 
-enum class ItemType(override val jsonName: String, val extension: String?) : IStringSerializable {
+enum class ItemType(override val jsonName: String, val extension: String?, val factory: (entry: ItemRegistry.Entry, config: JsonObject, parameters: JsonObject, count: Long) -> ItemStack = ::ItemStack) : IStringSerializable {
 	GENERIC             ("generic",            "item"),
 	LIQUID              ("liquid",             "liqitem"),
 	MATERIAL            ("material",           "matitem"),
@@ -26,6 +30,6 @@ enum class ItemType(override val jsonName: String, val extension: String?) : ISt
 	PLAYING_INSTRUMENT  ("instrument",         "instrument"),
 	THROWABLE           ("thrownitem",         "thrownitem"),
 	UNLOCK              ("unlockitem",         "unlock"),
-	ACTIVE              ("activeitem",         "activeitem"),
+	ACTIVE              ("activeitem",         "activeitem",            ::ActiveItemStack),
 	AUGMENT             ("augmentitem",        "augment");
 }

src/main/kotlin/ru/dbotthepony/kstarbound/defs/item/TreasurePoolDefinition.kt

@@ -22,6 +22,7 @@ import ru.dbotthepony.kommons.gson.get
 import ru.dbotthepony.kommons.vector.Vector2d
 import ru.dbotthepony.kstarbound.Starbound
 import ru.dbotthepony.kstarbound.collect.WeightedList
+import ru.dbotthepony.kstarbound.item.ItemStack
 import ru.dbotthepony.kstarbound.json.jsonArrayOf
 import ru.dbotthepony.kstarbound.json.stream
 import ru.dbotthepony.kstarbound.util.WriteOnce
@@ -44,7 +45,7 @@ class TreasurePoolDefinition(pieces: List<Piece>) {
 		.sorted { o1, o2 -> o1.startingLevel.compareTo(o2.startingLevel) }
 		.collect(ImmutableList.toImmutableList())
 
-	fun evaluate(random: RandomGenerator, level: Double, visitedPools: Object2IntMap<String> = Object2IntArrayMap()): List<ItemDescriptor> {
+	fun evaluate(random: RandomGenerator, level: Double, visitedPools: Object2IntMap<String> = Object2IntArrayMap()): List<ItemStack> {
 		require(level >= 0.0) { "Invalid loot level: $level" }
 
 		val new = visitedPools.getInt(name) + 1
@@ -71,7 +72,7 @@ class TreasurePoolDefinition(pieces: List<Piece>) {
 		}
 	}
 
-	fun evaluate(seed: Long, level: Double): List<ItemDescriptor> {
+	fun evaluate(seed: Long, level: Double): List<ItemStack> {
 		return evaluate(random(seed), level)
 	}
 
@@ -83,20 +84,20 @@ class TreasurePoolDefinition(pieces: List<Piece>) {
 		val allowDuplication: Boolean = true,
 		val levelVariance: Vector2d = Vector2d.ZERO
 	) {
-		fun evaluate(random: RandomGenerator, level: Double, visitedPools: Object2IntMap<String>): List<ItemDescriptor> {
+		fun evaluate(random: RandomGenerator, level: Double, visitedPools: Object2IntMap<String>): List<ItemStack> {
-			val result = ArrayList<ItemDescriptor>()
+			val result = ArrayList<ItemStack>()
 			val previousDescriptors = HashSet<ItemDescriptor>()
 
 			for (entry in fill) {
 				entry.map({
 			          val stack = it.build(level = level + random.nextRange(levelVariance), random = random, seed = random.nextLong())
 
-			          if (stack.isNotEmpty && (allowDuplication || previousDescriptors.add(stack.copy(count = 1L)))) {
+			          if (stack.isNotEmpty && (allowDuplication || previousDescriptors.add(stack.createDescriptor().copy(count = 1L)))) {
 				          result.add(stack)
 			          }
 		          }, {
 			          it.value?.evaluate(random, level + random.nextRange(levelVariance), visitedPools)?.forEach {
-				          if (allowDuplication || previousDescriptors.add(it.copy(count = 1L)))
+				          if (allowDuplication || previousDescriptors.add(it.createDescriptor().copy(count = 1L)))
 					          result.add(it)
 			          }
 		          })
@@ -107,12 +108,12 @@ class TreasurePoolDefinition(pieces: List<Piece>) {
 					pool.sample(random).orThrow { RuntimeException() }.map({
 						val stack = it.build(level = level + random.nextRange(levelVariance), random = random, seed = random.nextLong())
 
-						if (stack.isNotEmpty && (allowDuplication || previousDescriptors.add(stack.copy(count = 1L)))) {
+						if (stack.isNotEmpty && (allowDuplication || previousDescriptors.add(stack.createDescriptor().copy(count = 1L)))) {
 							result.add(stack)
 						}
 					}, {
 						it.value?.evaluate(random, level + random.nextRange(levelVariance), visitedPools)?.forEach {
-							if (allowDuplication || previousDescriptors.add(it.copy(count = 1L)))
+							if (allowDuplication || previousDescriptors.add(it.createDescriptor().copy(count = 1L)))
 								result.add(it)
 						}
 					})

src/main/kotlin/ru/dbotthepony/kstarbound/item/ActiveItemStack.kt

@@ -0,0 +1,94 @@
+package ru.dbotthepony.kstarbound.item
+
+import com.google.gson.JsonNull
+import com.google.gson.JsonObject
+import ru.dbotthepony.kommons.io.koptional
+import ru.dbotthepony.kommons.util.KOptional
+import ru.dbotthepony.kommons.util.getValue
+import ru.dbotthepony.kommons.util.setValue
+import ru.dbotthepony.kstarbound.Starbound
+import ru.dbotthepony.kstarbound.defs.DamageSource
+import ru.dbotthepony.kstarbound.defs.PhysicsForceRegion
+import ru.dbotthepony.kstarbound.defs.animation.AnimationDefinition
+import ru.dbotthepony.kstarbound.defs.item.ItemDescriptor
+import ru.dbotthepony.kstarbound.json.mergeJson
+import ru.dbotthepony.kstarbound.network.syncher.InternedStringCodec
+import ru.dbotthepony.kstarbound.network.syncher.JsonElementCodec
+import ru.dbotthepony.kstarbound.network.syncher.NetworkedGroup
+import ru.dbotthepony.kstarbound.network.syncher.NetworkedList
+import ru.dbotthepony.kstarbound.network.syncher.NetworkedMap
+import ru.dbotthepony.kstarbound.network.syncher.NetworkedStatefulItemStack
+import ru.dbotthepony.kstarbound.network.syncher.networkedBoolean
+import ru.dbotthepony.kstarbound.network.syncher.networkedData
+import ru.dbotthepony.kstarbound.network.syncher.networkedFixedPoint2
+import ru.dbotthepony.kstarbound.util.AssetPathStack
+import ru.dbotthepony.kstarbound.world.Direction
+import ru.dbotthepony.kstarbound.world.entities.Animator
+import ru.dbotthepony.kstarbound.world.physics.Poly
+
+class ActiveItemStack(entry: ItemRegistry.Entry, config: JsonObject, parameters: JsonObject, size: Long) : ItemStack(entry, config, parameters, size), NetworkedStatefulItemStack.Stateful {
+	override val networkElement = NetworkedGroup()
+
+	val animator: Animator
+
+	init {
+		val animationPath = AssetPathStack.relativeTo(entry.directory, lookupProperty("animation").asString)
+		var animationConfig = Starbound.loadJsonAsset(animationPath) ?: JsonNull.INSTANCE
+		val animationCustom = lookupProperty("animationCustom")
+
+		if (!animationCustom.isJsonNull) {
+			animationConfig = mergeJson(animationConfig.deepCopy(), animationCustom)
+		}
+
+		try {
+			if (animationCustom.isJsonNull) {
+				animator = Animator()
+			} else {
+				animator = Animator(Starbound.gson.fromJson(animationConfig, AnimationDefinition::class.java))
+			}
+		} catch (err: Throwable) {
+			throw RuntimeException("Unable to instance animator for ${entry.name} (animation config: $animationPath)", err)
+		}
+
+		networkElement.add(animator.networkGroup)
+	}
+
+	var holdingItem by networkedBoolean(true).also { networkElement.add(it) }
+	var backArmFrame by networkedData(KOptional(), InternedStringCodec.koptional()).also { networkElement.add(it) }
+	var frontArmFrame by networkedData(KOptional(), InternedStringCodec.koptional()).also { networkElement.add(it) }
+	var twoHandedGrip by networkedBoolean().also { networkElement.add(it) }
+	var recoil by networkedBoolean().also { networkElement.add(it) }
+	var outsideOfHand by networkedBoolean().also { networkElement.add(it) }
+	var armAngle by networkedFixedPoint2(0.01).also { networkElement.add(it) }
+	var facingDirection by networkedData(KOptional(), Direction.CODEC.koptional()).also { networkElement.add(it) }
+
+	val damageSources = NetworkedList(DamageSource.CODEC, DamageSource.LEGACY_CODEC).also { networkElement.add(it) }
+	val itemDamageSources = NetworkedList(DamageSource.CODEC, DamageSource.LEGACY_CODEC).also { networkElement.add(it) }
+	val shieldPolys = NetworkedList(Poly.CODEC, Poly.LEGACY_CODEC).also { networkElement.add(it) }
+	val itemShieldPolys = NetworkedList(Poly.CODEC, Poly.LEGACY_CODEC).also { networkElement.add(it) }
+	val forceRegions = NetworkedList(PhysicsForceRegion.CODEC, PhysicsForceRegion.LEGACY_CODEC).also { networkElement.add(it) }
+	val itemForceRegions = NetworkedList(PhysicsForceRegion.CODEC, PhysicsForceRegion.LEGACY_CODEC).also { networkElement.add(it) }
+
+	val scriptedAnimationParameters = NetworkedMap(InternedStringCodec, JsonElementCodec).also { networkElement.add(it, false) }
+
+	init {
+		for ((k, v) in lookupProperty("animationParts", JsonObject()).asJsonObject.entrySet()) {
+			animator.setPartTag(k, "partImage", v.asString)
+		}
+
+		val scriptedAnimationParameters = lookupProperty("scriptedAnimationParameters")
+
+		if (scriptedAnimationParameters is JsonObject) {
+			for ((k, v) in scriptedAnimationParameters.entrySet()) {
+				this.scriptedAnimationParameters[k] = v.deepCopy()
+			}
+		}
+	}
+
+	override fun copy(size: Long): ItemStack {
+		if (isEmpty)
+			return EMPTY
+
+		return ActiveItemStack(entry, config, parameters.deepCopy(), size)
+	}
+}

src/main/kotlin/ru/dbotthepony/kstarbound/item/IContainer.kt

@@ -102,7 +102,7 @@ interface IContainer {
 			if (item.isNotEmpty)
 				nonEmpty++
 
-			read.add(ItemStack.create(item))
+			read.add(item.build())
 		}
 
 		if (read.size > size) {

src/main/kotlin/ru/dbotthepony/kstarbound/item/ItemStack.kt

@@ -50,9 +50,12 @@ import kotlin.properties.Delegates
 
 /**
  * Base class for instanced items in game
+ *
+ * [config] is JsonObject returned by "builder" Lua script, or [entry]'s json if no such script exists
+ * or it has failed
  */
 @JsonAdapter(ItemStack.Adapter::class)
-open class ItemStack(descriptor: ItemDescriptor) {
+open class ItemStack(val entry: ItemRegistry.Entry, val config: JsonObject, parameters: JsonObject, size: Long) {
 	/**
 	 * unique number utilized to determine whenever stack has changed
 	 */
@@ -67,7 +70,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 		changeset = CHANGESET.incrementAndGet()
 	}
 
-	var size: Long = descriptor.count
+	var size: Long = size
 		set(value) {
 			val newValue = value.coerceAtLeast(0L)
 
@@ -77,21 +80,20 @@ open class ItemStack(descriptor: ItemDescriptor) {
 			}
 		}
 
-	val config: ItemRegistry.Entry = descriptor.ref
+	var parameters: JsonObject = parameters
-	var parameters: JsonObject = descriptor.parameters.deepCopy()
 		protected set
 
 	protected val parametersLazies = ObjectArrayList<ManualLazy<*>>() // no CME checks
 
 	protected val mergedJson = ManualLazy {
-		mergeJson(config.json.deepCopy(), parameters)
+		mergeJson(config.deepCopy(), parameters)
 	}.also { parametersLazies.add(it) }
 
 	val isEmpty: Boolean
-		get() = size <= 0 || config.isEmpty
+		get() = size <= 0 || entry.isEmpty
 
 	val isNotEmpty: Boolean
-		get() = size > 0 && !config.isEmpty
+		get() = size > 0 && !entry.isEmpty
 
 	fun grow(amount: Long) {
 		size += amount
@@ -190,7 +192,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 			for (drawable in inventoryIcon.asJsonArray) {
 				drawable as JsonObject
 
-				val image = SpriteReference.create(AssetPathStack.relativeTo(config.directory, drawable["image"].asString))
+				val image = SpriteReference.create(AssetPathStack.relativeTo(entry.directory, drawable["image"].asString))
 				val position: Vector2f
 
 				if ("position" in drawable) {
@@ -219,7 +221,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 
 			setIconDrawables(drawables)
 		} else {
-			val image = SpriteReference.create(AssetPathStack.relativeTo(config.directory, inventoryIcon.asString))
+			val image = SpriteReference.create(AssetPathStack.relativeTo(entry.directory, inventoryIcon.asString))
 			val transforms = Drawable.CENTERED
 			val drawable = Drawable.Image(image, Either.right(transforms))
 			setIconDrawables(listOf(drawable))
@@ -249,7 +251,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 				return AgingResult(null, true)
 			} else {
 				// item got replaced by something else
-				return AgingResult(create(updated), true)
+				return AgingResult(updated.build(), true)
 			}
 		}
 
@@ -260,7 +262,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 		if (isEmpty)
 			return ItemDescriptor.EMPTY
 
-		return ItemDescriptor(config.name, size, parameters.deepCopy())
+		return ItemDescriptor(entry.name, size, parameters.deepCopy())
 	}
 
 	// faster than creating an item descriptor and writing it (because it avoids copying and allocation)
@@ -270,7 +272,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 			stream.writeVarLong(0L)
 			stream.writeJsonElement(JsonNull.INSTANCE)
 		} else {
-			stream.writeBinaryString(config.name)
+			stream.writeBinaryString(entry.name)
 			stream.writeVarLong(size)
 			stream.writeJsonElement(parameters)
 		}
@@ -323,14 +325,14 @@ open class ItemStack(descriptor: ItemDescriptor) {
 		if (isEmpty)
 			return "ItemStack.EMPTY"
 
-		return "ItemStack[${config.name}, count = $size, params = $parameters]"
+		return "ItemStack[${entry.name}, count = $size, params = $parameters]"
 	}
 
 	open fun copy(size: Long = this.size): ItemStack {
 		if (isEmpty)
-			return this
+			return EMPTY
 
-		return ItemStack(ItemDescriptor(config.name, size, parameters.deepCopy()))
+		return ItemStack(entry, config, parameters.deepCopy(), size)
 	}
 
 	fun toJson(): JsonObject? {
@@ -338,7 +340,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 			return null
 
 		return JsonObject().also {
-			it.add("name", JsonPrimitive(config.name))
+			it.add("name", JsonPrimitive(entry.name))
 			it.add("count", JsonPrimitive(size))
 			it.add("parameters", parameters.deepCopy())
 		}
@@ -350,7 +352,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 		}
 
 		return allocator.newTable(0, 3).also {
-			it.rawset("name", config.name)
+			it.rawset("name", entry.name)
 			it.rawset("count", size)
 			it.rawset("parameters", allocator.from(parameters))
 		}
@@ -370,7 +372,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 			if (`in`.consumeNull())
 				return EMPTY
 
-			return create(ItemDescriptor(Starbound.ELEMENTS_ADAPTER.read(`in`)))
+			return ItemDescriptor(Starbound.ELEMENTS_ADAPTER.read(`in`)).build()
 		}
 	}
 
@@ -378,7 +380,7 @@ open class ItemStack(descriptor: ItemDescriptor) {
 		private val CHANGESET = AtomicLong()
 
 		@JvmField
-		val EMPTY = ItemStack(ItemDescriptor.EMPTY)
+		val EMPTY = ItemStack(ItemRegistry.AIR, ItemRegistry.AIR.json, JsonObject(), 0L)
 
 		private val vectors by lazy {
 			Starbound.gson.getAdapter(object : TypeToken<Vector2f>() {})
@@ -391,12 +393,5 @@ open class ItemStack(descriptor: ItemDescriptor) {
 		private val colors by lazy {
 			Starbound.gson.getAdapter(object : TypeToken<RGBAColor>() {})
 		}
-
-		fun create(descriptor: ItemDescriptor): ItemStack {
-			if (descriptor.isEmpty)
-				return EMPTY
-
-			return ItemStack(descriptor)
-		}
 	}
 }

src/main/kotlin/ru/dbotthepony/kstarbound/lua/Conversions.kt

@@ -154,7 +154,7 @@ fun Table.toJson(forceObject: Boolean = false): JsonElement {
 		for ((k, v) in arrayValues) {
 			val ik = k.toInt() - 1
 
-			while (list.size() < ik) {
+			while (list.size() <= ik) {
 				list.add(JsonNull.INSTANCE)
 			}
 

src/main/kotlin/ru/dbotthepony/kstarbound/lua/bindings/WorldObjectBindings.kt

@@ -1,14 +1,17 @@
 package ru.dbotthepony.kstarbound.lua.bindings
 
+import com.google.common.collect.ImmutableList
 import com.google.gson.JsonNull
 import com.google.gson.JsonPrimitive
 import org.classdump.luna.ByteString
+import org.classdump.luna.LuaRuntimeException
 import org.classdump.luna.Table
 import ru.dbotthepony.kommons.util.KOptional
 import ru.dbotthepony.kstarbound.Registries
 import ru.dbotthepony.kstarbound.Starbound
 import ru.dbotthepony.kstarbound.defs.DamageSource
 import ru.dbotthepony.kstarbound.defs.quest.QuestArcDescriptor
+import ru.dbotthepony.kstarbound.defs.quest.QuestDescriptor
 import ru.dbotthepony.kstarbound.json.JsonPath
 import ru.dbotthepony.kstarbound.lua.LuaEnvironment
 import ru.dbotthepony.kstarbound.lua.from
@@ -182,8 +185,13 @@ fun provideWorldObjectBindings(self: WorldObject, lua: LuaEnvironment) {
 
 		if (quests != null) {
 			for ((_, v) in quests) {
-				v as Table
+				if (v is Table) {
-				self.offeredQuests.add(Starbound.gson.fromJson(v.toJson(), QuestArcDescriptor::class.java))
+					self.offeredQuests.add(Starbound.gson.fromJson(v.toJson(), QuestArcDescriptor::class.java))
+				} else if (v is ByteString) {
+					self.offeredQuests.add(QuestArcDescriptor(ImmutableList.of(QuestDescriptor(v.decode()))))
+				} else {
+					throw LuaRuntimeException("Unknown quest arc descriptor type: $v")
+				}
 			}
 		}
 	}

src/main/kotlin/ru/dbotthepony/kstarbound/network/syncher/Factories.kt

@@ -105,6 +105,11 @@ fun OutputStream.writePointer(value: Long) {
 fun networkedFloat(value: Double = 0.0) = FloatingNetworkedElement.float(value)
 fun networkedDouble(value: Double = 0.0) = FloatingNetworkedElement.double(value)
 fun networkedFixedPoint(base: Double, value: Double = 0.0) = FloatingNetworkedElement.fixed(base, value)
+
+/**
+ * also uses fixed point on native protocol
+ */
+fun networkedFixedPoint2(base: Double, value: Double = 0.0) = FloatingNetworkedElement.fixed(base, value)
 fun networkedSignedInt(value: Int = 0) = BasicNetworkedElement(value, VarIntValueCodec)
 fun networkedUnsignedInt(value: Int = 0) = BasicNetworkedElement(value, UnsignedVarIntCodec)
 fun networkedSignedLong(value: Long = 0L) = BasicNetworkedElement(value, VarLongValueCodec)

src/main/kotlin/ru/dbotthepony/kstarbound/network/syncher/FloatingNetworkedElement.kt

@@ -287,5 +287,9 @@ class FloatingNetworkedElement(private var value: Double = 0.0, val ops: Ops, va
 		fun fixed(base: Double, value: Double = 0.0): FloatingNetworkedElement {
 			return FloatingNetworkedElement(value, DoubleOps, FixedPointOps(base))
 		}
+
+		fun fixed2(base: Double, value: Double = 0.0): FloatingNetworkedElement {
+			return FloatingNetworkedElement(value, FixedPointOps(base))
+		}
 	}
 }

src/main/kotlin/ru/dbotthepony/kstarbound/network/syncher/NetworkedGroup.kt

@@ -38,15 +38,19 @@ class NetworkedGroup() : NetworkedElement() {
 	}
 
 	override fun enableInterpolation(extrapolation: Double) {
-		isInterpolating = true
+		if (!isInterpolating || extrapolation != this.extrapolation) {
-		this.extrapolation = extrapolation
+			isInterpolating = true
-		elements.forEach { it.first.enableInterpolation(extrapolation) }
+			this.extrapolation = extrapolation
+			elements.forEach { it.first.enableInterpolation(extrapolation) }
+		}
 	}
 
 	override fun disableInterpolation() {
-		isInterpolating = false
+		if (isInterpolating) {
-		extrapolation = 0.0
+			isInterpolating = false
-		elements.forEach { it.first.disableInterpolation() }
+			extrapolation = 0.0
+			elements.forEach { it.first.disableInterpolation() }
+		}
 	}
 
 	override fun tickInterpolation(delta: Double) {

src/main/kotlin/ru/dbotthepony/kstarbound/network/syncher/NetworkedItemStack.kt

@@ -12,10 +12,9 @@ import java.io.DataOutputStream
 // event driven updates due to their complexity.
 // Creating more efficient system for this case will be major complication of entire system,
 // and major complications with little improvement are bad.
-open class NetworkedItemStack(private var itemStack: ItemStack = ItemStack.EMPTY) : NetworkedElement(), Delegate<ItemStack> {
+open class NetworkedItemStack(protected var itemStack: ItemStack = ItemStack.EMPTY) : NetworkedElement(), Delegate<ItemStack> {
 	override fun readInitial(data: DataInputStream, isLegacy: Boolean) {
-		val read = ItemDescriptor(data)
+		itemStack = ItemDescriptor(data).build()
-		itemStack = ItemStack.create(read)
 		observedVersion = itemStack.changeset
 		bumpVersion()
 	}

src/main/kotlin/ru/dbotthepony/kstarbound/network/syncher/NetworkedStatefulItemStack.kt

@@ -16,17 +16,17 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 	override fun enableInterpolation(extrapolation: Double) {
 		isInterpolating = true
 		this.extrapolation = extrapolation
-		(get() as? Stateful)?.networkElement?.enableInterpolation(extrapolation)
+		(itemStack as? Stateful)?.networkElement?.enableInterpolation(extrapolation)
 	}
 
 	override fun disableInterpolation() {
 		isInterpolating = false
-		(get() as? Stateful)?.networkElement?.disableInterpolation()
+		(itemStack as? Stateful)?.networkElement?.disableInterpolation()
 	}
 
 	override fun specifyVersioner(versionCounter: LongSupplier) {
 		super.specifyVersioner(versionCounter)
-		(get() as? Stateful)?.networkElement?.disableInterpolation()
+		(itemStack as? Stateful)?.networkElement?.disableInterpolation()
 	}
 
 	override fun hasChangedSince(version: Long): Boolean {
@@ -50,19 +50,31 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 	}
 
 	override fun readBlankDelta(interpolationDelay: Double) {
-		super.readBlankDelta(interpolationDelay)
+		(itemStack as? Stateful)?.networkElement?.readBlankDelta(interpolationDelay)
+	}
 
-		if (isInterpolating) {
+	override fun tickInterpolation(delta: Double) {
-			(get() as? Stateful)?.networkElement?.readBlankDelta(interpolationDelay)
+		(itemStack as? Stateful)?.networkElement?.tickInterpolation(delta)
-		}
+	}
+
+	override fun toString(): String {
+		return "NetworkedStatefulItemStack[$itemStack]"
 	}
 
 	override fun readInitial(data: DataInputStream, isLegacy: Boolean) {
 		super.readInitial(data, isLegacy)
 
-		val stack = get()
+		val stack = itemStack
 
 		if (stack is Stateful) {
+			val versionCounter = versionCounter
+
+			if (versionCounter != null)
+				stack.networkElement.specifyVersioner(versionCounter)
+
+			if (isInterpolating)
+				stack.networkElement.enableInterpolation(extrapolation)
+
 			stack.networkElement.readInitial(data, isLegacy)
 		}
 	}
@@ -70,7 +82,7 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 	override fun writeInitial(data: DataOutputStream, isLegacy: Boolean) {
 		super.writeInitial(data, isLegacy)
 
-		val stack = get()
+		val stack = itemStack
 
 		if (stack is Stateful) {
 			stack.networkElement.writeInitial(data, isLegacy)
@@ -83,16 +95,16 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 				0 -> break
 
 				1 -> {
-					super.readDelta(data, interpolationDelay, isLegacy)
+					super.readInitial(data, isLegacy)
 
-					val stack = get()
+					val stack = itemStack
 
 					if (stack is Stateful) {
-						if (versionCounter != null) {
+						val versionCounter = versionCounter
-							stack.networkElement.specifyVersioner(versionCounter!!)
-						}
 
-						stack.networkElement.readInitial(data, isLegacy)
+						if (versionCounter != null) {
+							stack.networkElement.specifyVersioner(versionCounter)
+						}
 
 						if (isInterpolating) {
 							stack.networkElement.enableInterpolation(extrapolation)
@@ -101,7 +113,7 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 				}
 
 				2 -> {
-					val stack = get()
+					val stack = itemStack
 
 					if (stack is Stateful) {
 						stack.networkElement.readInitial(data, isLegacy)
@@ -111,7 +123,7 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 				}
 
 				3 -> {
-					val stack = get()
+					val stack = itemStack
 
 					if (stack is Stateful) {
 						stack.networkElement.readDelta(data, interpolationDelay, isLegacy)
@@ -128,21 +140,21 @@ class NetworkedStatefulItemStack(value: ItemStack = ItemStack.EMPTY) : Networked
 	override fun writeDelta(data: DataOutputStream, remoteVersion: Long, isLegacy: Boolean) {
 		if (super.hasChangedSince(remoteVersion)) {
 			data.writeByte(1)
-			super.writeDelta(data, remoteVersion, isLegacy)
+			super.writeInitial(data, isLegacy)
 
-			val stack = get()
+			val stack = itemStack
 
 			if (stack is Stateful) {
 				data.writeByte(2)
 				stack.networkElement.writeInitial(data, isLegacy)
 			}
-		}
+		} else {
+			val stack = itemStack
 
-		val stack = get()
+			if (stack is Stateful && stack.networkElement.hasChangedSince(remoteVersion)) {
-
+				data.writeByte(3)
-		if (stack is Stateful && stack.networkElement.hasChangedSince(remoteVersion)) {
+				stack.networkElement.writeDelta(data, remoteVersion, isLegacy)
-			data.writeByte(3)
+			}
-			stack.networkElement.writeDelta(data, remoteVersion, isLegacy)
 		}
 
 		data.writeByte(0)

src/main/kotlin/ru/dbotthepony/kstarbound/world/Direction.kt

@@ -4,6 +4,7 @@ import ru.dbotthepony.kommons.io.StreamCodec
 import ru.dbotthepony.kommons.vector.Vector2d
 import ru.dbotthepony.kstarbound.json.builder.IStringSerializable
 
+// uint8_t
 enum class Direction(val normal: Vector2d, override val jsonName: String, val luaValue: Long, val isRight: Boolean, val isLeft: Boolean) : IStringSerializable {
 	LEFT(Vector2d.NEGATIVE_X, "left", -1L, false, true) {
 		override val opposite: Direction

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/Animator.kt

@@ -226,9 +226,17 @@ class Animator() {
 			val getState = states[state] ?: return false
 
 			if (activeState?.name != getState.name || alwaysStart) {
-				activeState = getState
+				noPropagate = true
-				timer = 0.0
+
-				startedEvent.trigger()
+				try {
+					activeState = getState
+					stateIndex.accept(getState.index.toLong())
+					timer = 0.0
+					startedEvent.trigger()
+				} finally {
+					noPropagate = false
+				}
+
 				return true
 			}
 
@@ -257,7 +265,11 @@ class Animator() {
 				} else {
 					try {
 						noPropagate = true
-						set(states.keys.elementAtOrNull(it.toInt()) ?: throw IllegalArgumentException("Unknown animation state $it!"), true)
+						val newState = states[states.keys.elementAtOrNull(it.toInt()) ?: throw IllegalArgumentException("Unknown animation state $it!")]!!
+						activeState = newState
+						timer = 0.0
+						// don't call startedEvent since this change originates from remote, and it sets "startedEvent" on its own
+						// startedEvent.trigger()
 					} finally {
 						noPropagate = false
 					}

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/ItemDropEntity.kt

@@ -61,7 +61,7 @@ class ItemDropEntity() : DynamicEntity() {
 	}
 
 	constructor(item: ItemDescriptor) : this() {
-		this.item = ItemStack.create(item)
+		this.item = item.build()
 		this.owningEntity = 0
 		this.state = State.AVAILABLE
 	}
@@ -73,7 +73,7 @@ class ItemDropEntity() : DynamicEntity() {
 	}
 
 	constructor(stream: DataInputStream, isLegacy: Boolean) : this() {
-		item = ItemStack.create(ItemDescriptor(stream))
+		item = ItemDescriptor(stream).build()
 		shouldNotExpire = stream.readBoolean()
 		age.read(stream, isLegacy)
 		intangibleTimer = GameTimer(stream, isLegacy)

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/tile/ContainerObject.kt

@@ -128,7 +128,7 @@ class ContainerObject(config: Registry.Entry<ObjectDefinition>) : WorldObject(co
 
 			if (!initialItems.isJsonNull) {
 				for (item in initialItems.asJsonArray) {
-					items.add(ItemStack.create(ItemDescriptor(item).build(level, seed)))
+					items.add(ItemDescriptor(item).build(level, seed))
 				}
 			}
 
@@ -143,7 +143,7 @@ class ContainerObject(config: Registry.Entry<ObjectDefinition>) : WorldObject(co
 					LOGGER.error("Unknown treasure pool $get! Can't generate container contents at $tilePosition.")
 				} else {
 					for (item in treasurePool.value.evaluate(random, level)) {
-						val leftover = items.add(ItemStack.create(item))
+						val leftover = items.add(item)
 
 						if (leftover.isNotEmpty) {
 							LOGGER.warn("Tried to overfill container at $tilePosition")
@@ -217,7 +217,7 @@ class ContainerObject(config: Registry.Entry<ObjectDefinition>) : WorldObject(co
 				items.fill(ItemStack.EMPTY)
 
 				for (i in 0 until setItemsSize) {
-					items[i] = ItemStack(ItemDescriptor(stream))
+					items[i] = ItemDescriptor(stream).build()
 				}
 			} else {
 				size = data.readVarInt()
@@ -226,7 +226,7 @@ class ContainerObject(config: Registry.Entry<ObjectDefinition>) : WorldObject(co
 				while (true) {
 					val index = data.readVarInt() - 1
 					if (index == -1) break
-					items[index] = ItemStack(ItemDescriptor(data))
+					items[index] = ItemDescriptor(data).build()
 				}
 			}
 		}
@@ -269,7 +269,7 @@ class ContainerObject(config: Registry.Entry<ObjectDefinition>) : WorldObject(co
 					while (true) {
 						val index = data.readVarInt() - 1
 						if (index == -1) break
-						items[index] = ItemStack(ItemDescriptor(data))
+						items[index] = ItemDescriptor(data).build()
 					}
 				}
 			}