Reimplement variable length int field synchronizers, mark Supplier interface as deprecated

src/main/kotlin/ru/dbotthepony/mc/otm/network/FieldSynchronizer.kt

@@ -23,7 +23,9 @@ import ru.dbotthepony.mc.otm.core.util.ItemStackValueCodec
 import ru.dbotthepony.mc.otm.core.util.ShortValueCodec
 import ru.dbotthepony.mc.otm.core.util.UUIDValueCodec
 import ru.dbotthepony.mc.otm.core.util.readVarIntLE
+import ru.dbotthepony.mc.otm.core.util.readVarLongLE
 import ru.dbotthepony.mc.otm.core.util.writeVarIntLE
+import ru.dbotthepony.mc.otm.core.util.writeVarLongLE
 import ru.dbotthepony.mc.otm.secondTime
 import java.io.DataInputStream
 import java.io.DataOutputStream
@@ -218,6 +220,11 @@ sealed interface IFloatField : IField<Float>, FloatSupplier {
 	override val value: Float
 		get() = float
 
+	@Deprecated("Use type specific Supplier interface")
+	override fun get(): Float {
+		return float
+	}
+
 	override fun getAsFloat(): Float {
 		return float
 	}
@@ -236,6 +243,11 @@ sealed interface IDoubleField : IField<Double>, DoubleSupplier {
 	val double: Double
 	val property: IDoubleProperty
 
+	@Deprecated("Use type specific Supplier interface")
+	override fun get(): Double {
+		return double
+	}
+
 	override val value: Double
 		get() = double
 
@@ -257,6 +269,11 @@ sealed interface IIntField : IField<Int>, IntSupplier {
 	val int: Int
 	val property: IIntProperty
 
+	@Deprecated("Use type specific Supplier interface")
+	override fun get(): Int {
+		return int
+	}
+
 	override val value: Int
 		get() = int
 
@@ -278,6 +295,11 @@ sealed interface ILongField : IField<Long>, LongSupplier {
 	val long: Long
 	val property: ILongProperty
 
+	@Deprecated("Use type specific Supplier interface")
+	override fun get(): Long {
+		return long
+	}
+
 	override val value: Long
 		get() = long
 
@@ -299,6 +321,11 @@ sealed interface IBooleanField : IField<Boolean>, BooleanSupplier {
 	val boolean: Boolean
 	val property: IBooleanProperty
 
+	@Deprecated("Use type specific Supplier interface")
+	override fun get(): Boolean {
+		return boolean
+	}
+
 	override val value: Boolean
 		get() = boolean
 
@@ -332,9 +359,9 @@ interface IMutableFloatProperty : IFloatProperty {
 	operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Float)
 }
 
-sealed interface IMutableFloatField : IMutableField<Float>, FloatConsumer {
+sealed interface IMutableFloatField : IMutableField<Float>, IFloatField, FloatConsumer {
-	var float: Float
+	override var float: Float
-	val property: IMutableFloatProperty
+	override val property: IMutableFloatProperty
 
 	@Deprecated("Use type specific property", replaceWith = ReplaceWith("this.float"))
 	override var value: Float
@@ -360,9 +387,9 @@ interface IMutableDoubleProperty : IDoubleProperty {
 	operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Double)
 }
 
-sealed interface IMutableDoubleField : IMutableField<Double>, DoubleConsumer {
+sealed interface IMutableDoubleField : IMutableField<Double>, IDoubleField, DoubleConsumer {
-	var double: Double
+	override var double: Double
-	val property: IMutableDoubleProperty
+	override val property: IMutableDoubleProperty
 
 	@Deprecated("Use type specific property", replaceWith = ReplaceWith("this.double"))
 	override var value: Double
@@ -388,9 +415,9 @@ interface IMutableIntProperty : IIntProperty {
 	operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Int)
 }
 
-sealed interface IMutableIntField : IMutableField<Int>, IntConsumer {
+sealed interface IMutableIntField : IMutableField<Int>, IIntField, IntConsumer {
-	var int: Int
+	override var int: Int
-	val property: IMutableIntProperty
+	override val property: IMutableIntProperty
 
 	@Deprecated("Use type specific property", replaceWith = ReplaceWith("this.int"))
 	override var value: Int
@@ -416,9 +443,9 @@ interface IMutableLongProperty : ILongProperty {
 	operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Long)
 }
 
-sealed interface IMutableLongField : IMutableField<Long>, LongConsumer {
+sealed interface IMutableLongField : IMutableField<Long>, ILongField, LongConsumer {
-	var long: Long
+	override var long: Long
-	val property: IMutableLongProperty
+	override val property: IMutableLongProperty
 
 	@Deprecated("Use type specific property", replaceWith = ReplaceWith("this.long"))
 	override var value: Long
@@ -444,9 +471,9 @@ interface IMutableBooleanProperty : IBooleanProperty {
 	operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Boolean)
 }
 
-sealed interface IMutableBooleanField : IMutableField<Boolean>, BooleanConsumer {
+sealed interface IMutableBooleanField : IMutableField<Boolean>, IBooleanField, BooleanConsumer {
-	var boolean: Boolean
+	override var boolean: Boolean
-	val property: IMutableBooleanProperty
+	override val property: IMutableBooleanProperty
 
 	@Deprecated("Use type specific property", replaceWith = ReplaceWith("this.boolean"))
 	override var value: Boolean
@@ -541,12 +568,12 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	fun bool(getter: BooleanSupplier) = ComputedBooleanField(getter)
 	fun short(getter: () -> Short) = ComputedField(getter, ShortValueCodec)
 	fun long(getter: LongSupplier) = ComputedLongField(getter)
-	fun fixedLong(getter: LongSupplier) = ComputedLongField(getter)
+	fun fixedLong(getter: LongSupplier) = ComputedFixedLongField(getter)
 	fun float(getter: FloatSupplier) = ComputedFloatField(getter)
 	fun double(getter: DoubleSupplier) = ComputedDoubleField(getter)
 	fun uuid(getter: () -> UUID) = ComputedField(getter, UUIDValueCodec)
 	fun int(getter: IntSupplier) = ComputedIntField(getter)
-	fun fixedInt(getter: IntSupplier) = ComputedIntField(getter)
+	fun fixedInt(getter: IntSupplier) = ComputedFixedIntField(getter)
 	fun fraction(getter: () -> Decimal) = ComputedField(getter, DecimalValueCodec)
 	fun bigDecimal(getter: () -> BigDecimal) = ComputedField(getter, BigDecimalValueCodec)
 	fun item(getter: () -> ItemStack) = ComputedField(getter, ItemStackValueCodec)
@@ -556,12 +583,12 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	fun bool(getter: KProperty0<Boolean>) = ComputedBooleanField(getter::get)
 	fun short(getter: KProperty0<Short>) = ComputedField(getter, ShortValueCodec)
 	fun long(getter: KProperty0<Long>) = ComputedLongField(getter::get)
-	fun fixedLong(getter: KProperty0<Long>) = ComputedLongField(getter::get)
+	fun fixedLong(getter: KProperty0<Long>) = ComputedFixedLongField(getter::get)
 	fun float(getter: KProperty0<Float>) = ComputedFloatField(getter::get)
 	fun double(getter: KProperty0<Double>) = ComputedDoubleField(getter::get)
 	fun uuid(getter: KProperty0<UUID>) = ComputedField(getter, UUIDValueCodec)
 	fun int(getter: KProperty0<Int>) = ComputedIntField(getter::get)
-	fun fixedInt(getter: KProperty0<Int>) = ComputedIntField(getter::get)
+	fun fixedInt(getter: KProperty0<Int>) = ComputedFixedIntField(getter::get)
 	fun fraction(getter: KProperty0<Decimal>) = ComputedField(getter, DecimalValueCodec)
 	fun bigDecimal(getter: KProperty0<BigDecimal>) = ComputedField(getter, BigDecimalValueCodec)
 	fun item(getter: KProperty0<ItemStack>) = ComputedField(getter, ItemStackValueCodec)
@@ -571,12 +598,12 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	fun bool(getter: Supplier<Boolean>) = ComputedBooleanField(getter::get)
 	fun short(getter: Supplier<Short>) = ComputedField(getter::get, ShortValueCodec)
 	fun long(getter: Supplier<Long>) = ComputedLongField(getter::get)
-	fun fixedLong(getter: Supplier<Long>) = ComputedLongField(getter::get)
+	fun fixedLong(getter: Supplier<Long>) = ComputedFixedLongField(getter::get)
 	fun float(getter: Supplier<Float>) = ComputedFloatField(getter::get)
 	fun double(getter: Supplier<Double>) = ComputedDoubleField(getter::get)
 	fun uuid(getter: Supplier<UUID>) = ComputedField(getter::get, UUIDValueCodec)
 	fun int(getter: Supplier<Int>) = ComputedIntField(getter::get)
-	fun fixedInt(getter: Supplier<Int>) = ComputedIntField(getter::get)
+	fun fixedInt(getter: Supplier<Int>) = ComputedFixedIntField(getter::get)
 	fun fraction(getter: Supplier<Decimal>) = ComputedField(getter::get, DecimalValueCodec)
 	fun bigDecimal(getter: Supplier<BigDecimal>) = ComputedField(getter::get, BigDecimalValueCodec)
 	fun item(getter: Supplier<ItemStack>) = ComputedField(getter::get, ItemStackValueCodec)
@@ -632,8 +659,8 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 		value: Long = 0L,
 		getter: LongFieldGetter? = null,
 		setter: LongFieldSetter? = null,
-	): LongField {
+	): FixedLongField {
-		return LongField(value, getter, setter)
+		return FixedLongField(value, getter, setter)
 	}
 
 	@JvmOverloads
@@ -686,8 +713,8 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 		value: Int = 0,
 		getter: IntFieldGetter? = null,
 		setter: IntFieldSetter? = null,
-	): IntField {
+	): FixedIntField {
-		return IntField(value, getter, setter)
+		return FixedIntField(value, getter, setter)
 	}
 
 	@JvmOverloads
@@ -1046,12 +1073,25 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 		}
 	}
 
+	abstract inner class PrimitiveField<V : Any>() : AbstractField<V>() {
+		protected var isDirty = false
+
+		override fun observe(): Boolean {
+			check(!isRemoved) { "Field was removed" }
+			return isDirty
+		}
+
+		override fun markDirty() {
+			check(!isRemoved) { "Field was removed" }
+			notifyEndpoints(this)
+			isDirty = true
+		}
+	}
+
 	/**
 	 * Type specific field, storing primitive [Float] directly
 	 */
-	inner class FloatField(private var field: Float, private val getter: FloatFieldGetter? = null, private val setter: FloatFieldSetter? = null) : AbstractField<Float>(), IMutableFloatField {
+	inner class FloatField(private var field: Float, private val getter: FloatFieldGetter? = null, private val setter: FloatFieldSetter? = null) : PrimitiveField<Float>(), IMutableFloatField {
-		private var isDirty = false
-
 		override val property = object : IMutableFloatProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Float {
 				return this@FloatField.float
@@ -1077,11 +1117,6 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			}
 		}
 
-		override fun observe(): Boolean {
-			check(!isRemoved) { "Field was removed" }
-			return isDirty
-		}
-
 		override var float: Float
 			get() {
 				return getter?.invoke(access) ?: this.field
@@ -1091,10 +1126,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 
 				if (setter != null) {
 					setter.invoke(value, access, false)
-					return
+				} else if (value != this.field) {
-				}
-
-				if (value != this.field) {
 					if (!isDirty) {
 						notifyEndpoints(this)
 						isDirty = true
@@ -1104,12 +1136,6 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 				}
 			}
 
-		override fun markDirty() {
-			check(!isRemoved) { "Field was removed" }
-			notifyEndpoints(this)
-			isDirty = true
-		}
-
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeFloat(this.field)
@@ -1132,9 +1158,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	/**
 	 * Type specific field, storing primitive [Double] directly
 	 */
-	inner class DoubleField(private var field: Double, private val getter: DoubleFieldGetter? = null, private val setter: DoubleFieldSetter? = null) : AbstractField<Double>(), IMutableDoubleField {
+	inner class DoubleField(private var field: Double, private val getter: DoubleFieldGetter? = null, private val setter: DoubleFieldSetter? = null) : PrimitiveField<Double>(), IMutableDoubleField {
-		private var isDirty = false
-
 		override val property = object : IMutableDoubleProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Double {
 				return this@DoubleField.double
@@ -1160,11 +1184,6 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			}
 		}
 
-		override fun observe(): Boolean {
-			check(!isRemoved) { "Field was removed" }
-			return isDirty
-		}
-
 		override var double: Double
 			get() {
 				return getter?.invoke(access) ?: this.field
@@ -1174,10 +1193,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 
 				if (setter != null) {
 					setter.invoke(value, access, false)
-					return
+				} else if (value != this.field) {
-				}
-
-				if (value != this.field) {
 					if (!isDirty) {
 						notifyEndpoints(this)
 						isDirty = true
@@ -1187,12 +1203,6 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 				}
 			}
 
-		override fun markDirty() {
-			check(!isRemoved) { "Field was removed" }
-			notifyEndpoints(this)
-			isDirty = true
-		}
-
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeDouble(this.field)
@@ -1212,43 +1222,33 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 		}
 	}
 
-	/**
+	abstract inner class AbstractIntField(protected var field: Int, private val getter: IntFieldGetter? = null, protected val setter: IntFieldSetter? = null) : PrimitiveField<Int>(), IMutableIntField {
-	 * Type specific field, storing primitive [Int] directly
+		final override val property = object : IMutableIntProperty {
-	 */
-	inner class IntField(private var field: Int, private val getter: IntFieldGetter? = null, private val setter: IntFieldSetter? = null) : AbstractField<Int>(), IMutableIntField {
-		private var isDirty = false
-
-		override val property = object : IMutableIntProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Int {
-				return this@IntField.int
+				return this@AbstractIntField.int
 			}
 
 			override fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
-				this@IntField.int = value
+				this@AbstractIntField.int = value
 			}
 		}
 
-		private val access = object : IntFieldAccess {
+		protected val access = object : IntFieldAccess {
 			override fun readInt(): Int {
-				return this@IntField.field
+				return this@AbstractIntField.field
 			}
 
 			override fun write(value: Int) {
-				if (!isDirty && value != this@IntField.field) {
+				if (!isDirty && value != this@AbstractIntField.field) {
-					notifyEndpoints(this@IntField)
+					notifyEndpoints(this@AbstractIntField)
 					isDirty = true
 				}
 
-				this@IntField.field = value
+				this@AbstractIntField.field = value
 			}
 		}
 
-		override fun observe(): Boolean {
+		final override var int: Int
-			check(!isRemoved) { "Field was removed" }
-			return isDirty
-		}
-
-		override var int: Int
 			get() {
 				return getter?.invoke(access) ?: this.field
 			}
@@ -1257,10 +1257,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 
 				if (setter != null) {
 					setter.invoke(value, access, false)
-					return
+				} else if (value != this.field) {
-				}
-
-				if (value != this.field) {
 					if (!isDirty) {
 						notifyEndpoints(this)
 						isDirty = true
@@ -1269,13 +1266,35 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 					this.field = value
 				}
 			}
+	}
 
-		override fun markDirty() {
+	/**
+	 * Type specific field, storing primitive [Int] directly, and networking it as variable length integer
+	 */
+	inner class IntField(field: Int, getter: IntFieldGetter? = null, setter: IntFieldSetter? = null) : AbstractIntField(field, getter, setter) {
+		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
-			notifyEndpoints(this)
+			stream.writeVarIntLE(this.field)
-			isDirty = true
+			isDirty = false
 		}
 
+		override fun read(stream: DataInputStream) {
+			check(!isRemoved) { "Field was removed" }
+			val value = stream.readVarIntLE()
+			val setter = this.setter
+
+			if (setter != null) {
+				setter.invoke(value, access, true)
+			} else {
+				this.field = value
+			}
+		}
+	}
+
+	/**
+	 * Type specific field, storing primitive [Int] directly, and networking it as 4 octets
+	 */
+	inner class FixedIntField(field: Int, getter: IntFieldGetter? = null, setter: IntFieldSetter? = null) : AbstractIntField(field, getter, setter) {
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeInt(this.field)
@@ -1298,40 +1317,33 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	/**
 	 * Type specific field, storing primitive [Long] directly
 	 */
-	inner class LongField(private var field: Long, private val getter: LongFieldGetter? = null, private val setter: LongFieldSetter? = null) : AbstractField<Long>(), IMutableLongField {
+	abstract inner class AbstractLongField(protected var field: Long, private val getter: LongFieldGetter? = null, protected val setter: LongFieldSetter? = null) : PrimitiveField<Long>(), IMutableLongField {
-		private var isDirty = false
+		final override val property = object : IMutableLongProperty {
-
-		override val property = object : IMutableLongProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Long {
-				return this@LongField.long
+				return this@AbstractLongField.long
 			}
 
 			override fun setValue(thisRef: Any?, property: KProperty<*>, value: Long) {
-				this@LongField.long = value
+				this@AbstractLongField.long = value
 			}
 		}
 
-		private val access = object : LongFieldAccess {
+		protected val access = object : LongFieldAccess {
 			override fun readLong(): Long {
-				return this@LongField.field
+				return this@AbstractLongField.field
 			}
 
 			override fun write(value: Long) {
-				if (!isDirty && value != this@LongField.field) {
+				if (!isDirty && value != this@AbstractLongField.field) {
-					notifyEndpoints(this@LongField)
+					notifyEndpoints(this@AbstractLongField)
 					isDirty = true
 				}
 
-				this@LongField.field = value
+				this@AbstractLongField.field = value
 			}
 		}
 
-		override fun observe(): Boolean {
+		final override var long: Long
-			check(!isRemoved) { "Field was removed" }
-			return isDirty
-		}
-
-		override var long: Long
 			get() {
 				return getter?.invoke(access) ?: this.field
 			}
@@ -1340,10 +1352,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 
 				if (setter != null) {
 					setter.invoke(value, access, false)
-					return
+				} else if (value != this.field) {
-				}
-
-				if (value != this.field) {
 					if (!isDirty) {
 						notifyEndpoints(this)
 						isDirty = true
@@ -1352,13 +1361,35 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 					this.field = value
 				}
 			}
+	}
 
-		override fun markDirty() {
+	/**
+	 * Type specific field, storing primitive [Long] directly, and networking it as variable length integer
+	 */
+	inner class LongField(field: Long, getter: LongFieldGetter? = null, setter: LongFieldSetter? = null) : AbstractLongField(field, getter, setter) {
+		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
-			notifyEndpoints(this)
+			stream.writeVarLongLE(this.field)
-			isDirty = true
+			isDirty = false
 		}
 
+		override fun read(stream: DataInputStream) {
+			check(!isRemoved) { "Field was removed" }
+			val value = stream.readVarLongLE()
+			val setter = this.setter
+
+			if (setter != null) {
+				setter.invoke(value, access, true)
+			} else {
+				this.field = value
+			}
+		}
+	}
+
+	/**
+	 * Type specific field, storing primitive [Long] directly, and networking it as 8 octets
+	 */
+	inner class FixedLongField(field: Long, getter: LongFieldGetter? = null, setter: LongFieldSetter? = null) : AbstractLongField(field, getter, setter) {
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeLong(this.field)
@@ -1381,9 +1412,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	/**
 	 * Type specific field, storing primitive [Boolean] directly
 	 */
-	inner class BooleanField(private var field: Boolean, private val getter: BooleanFieldGetter? = null, private val setter: BooleanFieldSetter? = null) : AbstractField<Boolean>(), IMutableBooleanField {
+	inner class BooleanField(private var field: Boolean, private val getter: BooleanFieldGetter? = null, private val setter: BooleanFieldSetter? = null) : PrimitiveField<Boolean>(), IMutableBooleanField {
-		private var isDirty = false
-
 		override val property = object : IMutableBooleanProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Boolean {
 				return this@BooleanField.boolean
@@ -1409,11 +1438,6 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			}
 		}
 
-		override fun observe(): Boolean {
-			check(!isRemoved) { "Field was removed" }
-			return isDirty
-		}
-
 		override var boolean: Boolean
 			get() {
 				return getter?.invoke(access) ?: this.field
@@ -1423,10 +1447,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 
 				if (setter != null) {
 					setter.invoke(value, access, false)
-					return
+				} else if (value != this.field) {
-				}
-
-				if (value != this.field) {
 					if (!isDirty) {
 						notifyEndpoints(this)
 						isDirty = true
@@ -1436,12 +1457,6 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 				}
 			}
 
-		override fun markDirty() {
-			check(!isRemoved) { "Field was removed" }
-			notifyEndpoints(this)
-			isDirty = true
-		}
-
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeBoolean(this.field)
@@ -1653,14 +1668,14 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	 *
 	 * This class has concrete implementation for [Int] primitive
 	 */
-	inner class ComputedIntField(private val getter: IntSupplier, private val observer: IntConsumer = IntConsumer {}) : AbstractField<Int>(), IIntField {
+	abstract inner class AbstractComputedIntField(protected val getter: IntSupplier, protected val observer: IntConsumer = IntConsumer {}) : AbstractField<Int>(), IIntField {
 		private var remote: Int = 0
 		private var isRemoteSet = false
-		private var clientValue: Int = 0
+		protected var clientValue: Int = 0
-		private var isClientValue = false
+		protected var isClientValue = false
-		private var isDirty = false
+		protected var isDirty = false
 
-		override val property = object : IIntProperty {
+		final override val property = object : IIntProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Int {
 				return int
 			}
@@ -1670,7 +1685,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			observers.add(this)
 		}
 
-		override fun observe(): Boolean {
+		final override fun observe(): Boolean {
 			check(!isRemoved) { "Field was removed" }
 
 			val value = getter.asInt
@@ -1685,13 +1700,13 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			return isDirty
 		}
 
-		override fun markDirty() {
+		final override fun markDirty() {
 			check(!isRemoved) { "Field was removed" }
 			notifyEndpoints(this)
 			isDirty = true
 		}
 
-		override val int: Int
+		final override val int: Int
 			get() {
 				if (isClientValue) {
 					return clientValue
@@ -1699,7 +1714,35 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 					return getter.asInt
 				}
 			}
+	}
 
+	/**
+	 * Networked value with backing getter which is constantly polled
+	 *
+	 * This class has concrete implementation for [Int] primitive, networking it as variable length integer
+	 */
+	inner class ComputedIntField(getter: IntSupplier, observer: IntConsumer = IntConsumer {}) : AbstractComputedIntField(getter, observer) {
+		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
+			check(!isRemoved) { "Field was removed" }
+			stream.writeVarIntLE(getter.asInt)
+			isDirty = false
+		}
+
+		override fun read(stream: DataInputStream) {
+			check(!isRemoved) { "Field was removed" }
+			val newValue = stream.readVarIntLE()
+			clientValue = newValue
+			isClientValue = true
+			observer.accept(newValue)
+		}
+	}
+
+	/**
+	 * Networked value with backing getter which is constantly polled
+	 *
+	 * This class has concrete implementation for [Int] primitive, networking it as 4 octets
+	 */
+	inner class ComputedFixedIntField(getter: IntSupplier, observer: IntConsumer = IntConsumer {}) : AbstractComputedIntField(getter, observer) {
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeInt(getter.asInt)
@@ -1720,14 +1763,14 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 	 *
 	 * This class has concrete implementation for [Long] primitive
 	 */
-	inner class ComputedLongField(private val getter: LongSupplier, private val observer: LongConsumer = LongConsumer {}) : AbstractField<Long>(), ILongField {
+	abstract inner class AbstractComputedLongField(protected val getter: LongSupplier, protected val observer: LongConsumer = LongConsumer {}) : AbstractField<Long>(), ILongField {
 		private var remote: Long = 0L
 		private var isRemoteSet = false
-		private var clientValue: Long = 0L
+		protected var clientValue: Long = 0L
-		private var isClientValue = false
+		protected var isClientValue = false
-		private var isDirty = false
+		protected var isDirty = false
 
-		override val property = object : ILongProperty {
+		final override val property = object : ILongProperty {
 			override fun getValue(thisRef: Any?, property: KProperty<*>): Long {
 				return long
 			}
@@ -1737,7 +1780,7 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			observers.add(this)
 		}
 
-		override fun observe(): Boolean {
+		final override fun observe(): Boolean {
 			check(!isRemoved) { "Field was removed" }
 
 			val value = getter.asLong
@@ -1752,13 +1795,13 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 			return isDirty
 		}
 
-		override fun markDirty() {
+		final override fun markDirty() {
 			check(!isRemoved) { "Field was removed" }
 			notifyEndpoints(this)
 			isDirty = true
 		}
 
-		override val long: Long
+		final override val long: Long
 			get() {
 				if (isClientValue) {
 					return clientValue
@@ -1766,7 +1809,35 @@ class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCa
 					return getter.asLong
 				}
 			}
+	}
 
+	/**
+	 * Networked value with backing getter which is constantly polled
+	 *
+	 * This class has concrete implementation for [Long] primitive, networking it as variable length integer
+	 */
+	inner class ComputedLongField(getter: LongSupplier, observer: LongConsumer = LongConsumer {}) : AbstractComputedLongField(getter, observer) {
+		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
+			check(!isRemoved) { "Field was removed" }
+			stream.writeVarLongLE(getter.asLong)
+			isDirty = false
+		}
+
+		override fun read(stream: DataInputStream) {
+			check(!isRemoved) { "Field was removed" }
+			val newValue = stream.readVarLongLE()
+			clientValue = newValue
+			isClientValue = true
+			observer.accept(newValue)
+		}
+	}
+
+	/**
+	 * Networked value with backing getter which is constantly polled
+	 *
+	 * This class has concrete implementation for [Long] primitive, networking it as 8 octets
+	 */
+	inner class ComputedFixedLongField(getter: LongSupplier, observer: LongConsumer = LongConsumer {}) : AbstractComputedLongField(getter, observer) {
 		override fun write(stream: DataOutputStream, endpoint: Endpoint) {
 			check(!isRemoved) { "Field was removed" }
 			stream.writeLong(getter.asLong)