Stitch up quantum battery code

src/main/kotlin/ru/dbotthepony/mc/otm/item/QuantumBatteryItem.kt

@@ -24,7 +24,7 @@ import ru.dbotthepony.mc.otm.saveddata.SavedCountingMap
 import ru.dbotthepony.mc.otm.saveddata.SavedMapDelegate
 
 class QuantumBatteryItem : Item {
-	private inner class Power : IMatteryEnergyStorage, ICapabilityProvider, INBTSerializable<IntTag> {
+	private inner class Power(private val stack: ItemStack) : IMatteryEnergyStorage, ICapabilityProvider {
 		private val resolver = LazyOptional.of { this }
 		var delegate = SavedMapDelegate(ImpreciseFraction.ZERO)
 
@@ -45,23 +45,33 @@ class QuantumBatteryItem : Item {
 				return ImpreciseFraction.ZERO
 			}
 
+			if (delegate.parent == null && isServerThread()) {
+				determineQuantumLink()
+
+				if (delegate.parent == null) {
+					return ImpreciseFraction.ZERO
+				}
+			}
+
 			if (isCreative) {
 				val newEnergy = (delegate.value - howMuch).moreThanZero()
+				val diff = delegate.value - newEnergy
 
 				if (!simulate) {
 					delegate.value = newEnergy
 				}
 
-				return delegate.value - newEnergy
+				return diff
 			}
 
 			val newEnergy = (delegate.value - howMuch.coerceAtMost(throughput!!)).moreThanZero()
+			val diff = delegate.value - newEnergy
 
 			if (!simulate) {
 				delegate.value = newEnergy
 			}
 
-			return delegate.value - newEnergy
+			return diff
 		}
 
 		override fun receiveEnergyOuter(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
@@ -73,6 +83,14 @@ class QuantumBatteryItem : Item {
 				return ImpreciseFraction.ZERO
 			}
 
+			if (delegate.parent == null && isServerThread()) {
+				determineQuantumLink()
+
+				if (delegate.parent == null) {
+					return ImpreciseFraction.ZERO
+				}
+			}
+
 			if (isCreative) {
 				if (!simulate) {
 					delegate.value += howMuch
@@ -82,16 +100,23 @@ class QuantumBatteryItem : Item {
 			}
 
 			val newEnergy = (delegate.value + howMuch.coerceAtMost(throughput!!)).coerceAtMost(capacity!!)
+			val diff = newEnergy - delegate.value
 
 			if (!simulate) {
 				delegate.value = newEnergy
 			}
 
-			return newEnergy - delegate.value
+			return diff
 		}
 
 		override val batteryLevel: ImpreciseFraction
-			get() = delegate.value
+			get() {
+				if (delegate.parent == null) {
+					determineQuantumLink()
+				}
+
+				return delegate.value
+			}
 
 		override val maxBatteryLevel: ImpreciseFraction
 			get() = capacity ?: (batteryLevel + ImpreciseFraction.LONG_MAX_VALUE)
@@ -107,23 +132,26 @@ class QuantumBatteryItem : Item {
 			return true
 		}
 
-		override fun serializeNBT(): IntTag {
-			if (isServerThread() && delegate.parent == null) {
+		private fun determineQuantumLink() {
+			if (delegate.parent == null && isServerThread()) {
+				val existing = stack.tag?.getInt("link_id")
+
+				if (existing == null) {
 					val old = delegate
 					delegate = saveData!!.factorize()
 					delegate.value = old.value
+					stack.tagNotNull["link_id"] = delegate.index
+				} else {
+					delegate = saveData?.computeIfAbsent(existing) ?: SavedMapDelegate(null, existing, delegate.value)
 				}
+			} else if (!isServerThread()) {
+				// client
+				val existing = stack.tag?.getInt("link_id") ?: return
 
-			return IntTag.valueOf(if (delegate.parent == null) Int.MIN_VALUE else delegate.index)
+				if (existing != delegate.index) {
+					delegate = SavedMapDelegate(delegate.parent, existing, delegate.value)
 				}
-
-		override fun deserializeNBT(nbt: IntTag) {
-			if (nbt.asInt == Int.MIN_VALUE) {
-				delegate = SavedMapDelegate(ImpreciseFraction.ZERO)
-				return
 			}
-
-			delegate = saveData?.computeIfAbsent(nbt.asInt) ?: SavedMapDelegate(null, nbt.asInt, delegate.value)
 		}
 	}
 
@@ -160,7 +188,7 @@ class QuantumBatteryItem : Item {
 	}
 
 	override fun initCapabilities(stack: ItemStack, nbt: CompoundTag?): ICapabilityProvider {
-		return Power()
+		return Power(stack)
 	}
 
 	override fun appendHoverText(