Move helpers out from interface

src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsArmor.kt

@@ -5,6 +5,7 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraftforge.event.entity.living.LivingHurtEvent
 import ru.dbotthepony.mc.otm.android.AndroidFeature
 import ru.dbotthepony.mc.otm.capability.android.AndroidCapability
+import ru.dbotthepony.mc.otm.capability.extractEnergyInnerExact
 import ru.dbotthepony.mc.otm.core.ImpreciseFraction
 import ru.dbotthepony.mc.otm.registry.AndroidFeatures
 import ru.dbotthepony.mc.otm.registry.StatNames

src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/StoragePowerSupplierBlockEntity.kt

@@ -16,6 +16,7 @@ import net.minecraftforge.common.util.LazyOptional
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
 import ru.dbotthepony.mc.otm.capability.MatteryCapability
 import ru.dbotthepony.mc.otm.capability.WorkerEnergyStorage
+import ru.dbotthepony.mc.otm.capability.transferInner
 import ru.dbotthepony.mc.otm.core.ImpreciseFraction
 import ru.dbotthepony.mc.otm.graph.storage.BasicStorageGraphNode
 import ru.dbotthepony.mc.otm.graph.storage.StorageNetworkGraph

src/main/kotlin/ru/dbotthepony/mc/otm/capability/IMatteryEnergyStorage.kt

@@ -1,7 +1,6 @@
 package ru.dbotthepony.mc.otm.capability
 
 import net.minecraftforge.energy.IEnergyStorage
-import ru.dbotthepony.mc.otm.core.Fraction
 import ru.dbotthepony.mc.otm.core.ImpreciseFraction
 
 // IEnergyStorage for direct compat with Forge Energy
@@ -13,25 +12,6 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 	 */
 	fun extractEnergyOuter(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction
 
-	/**
-	 * All or nothing
-	 *
-	 * @return energy extracted
-	 */
-	fun extractEnergyOuterExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
-		val extracted = extractEnergyOuter(howMuch, true)
-
-		if (extracted != howMuch) {
-			return ImpreciseFraction.ZERO
-		}
-
-		if (!simulate) {
-			extractEnergyOuter(howMuch, false)
-		}
-
-		return extracted
-	}
-
 	/**
 	 * for internal needs, e.g. for work
 	 * CAN also be used by something that does evil
@@ -41,25 +21,6 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 	 */
 	fun extractEnergyInner(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction
 
-	/**
-	 * All or nothing
-	 *
-	 * @return energy extracted
-	 */
-	fun extractEnergyInnerExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
-		val extracted = extractEnergyInner(howMuch, true)
-
-		if (extracted != howMuch) {
-			return ImpreciseFraction.ZERO
-		}
-
-		if (!simulate) {
-			extractEnergyInner(howMuch, false)
-		}
-
-		return extracted
-	}
-
 	/**
 	 * For energy receiving from outside, e.g. cables
 	 *
@@ -67,20 +28,6 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 	 */
 	fun receiveEnergyOuter(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction
 
-	fun receiveEnergyOuterExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
-		val extracted = receiveEnergyOuter(howMuch, true)
-
-		if (extracted != howMuch) {
-			return ImpreciseFraction.ZERO
-		}
-
-		if (!simulate) {
-			receiveEnergyOuter(howMuch, false)
-		}
-
-		return extracted
-	}
-
 	/**
 	 * For energy receiving from inside, e.g. generator generates power
 	 *
@@ -88,57 +35,6 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 	 */
 	fun receiveEnergyInner(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction
 
-	/**
-	 * All or nothing
-	 *
-	 * @return energy accepted
-	 */
-	fun receiveEnergyInnerExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
-		val extracted = receiveEnergyInner(howMuch, true)
-
-		if (extracted != howMuch) {
-			return ImpreciseFraction.ZERO
-		}
-
-		if (!simulate) {
-			receiveEnergyInner(howMuch, false)
-		}
-
-		return extracted
-	}
-
-	fun extractEnergyOuter(howMuch: Long, simulate: Boolean): ImpreciseFraction {
-		return extractEnergyOuter(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun extractEnergyOuter(howMuch: Int, simulate: Boolean): ImpreciseFraction {
-		return extractEnergyOuter(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun receiveEnergyOuter(howMuch: Long, simulate: Boolean): ImpreciseFraction {
-		return receiveEnergyOuter(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun receiveEnergyOuter(howMuch: Int, simulate: Boolean): ImpreciseFraction {
-		return receiveEnergyOuter(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun extractEnergyInner(howMuch: Long, simulate: Boolean): ImpreciseFraction {
-		return extractEnergyInner(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun extractEnergyInner(howMuch: Int, simulate: Boolean): ImpreciseFraction {
-		return extractEnergyInner(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun receiveEnergyInner(howMuch: Long, simulate: Boolean): ImpreciseFraction {
-		return receiveEnergyInner(ImpreciseFraction(howMuch), simulate)
-	}
-
-	fun receiveEnergyInner(howMuch: Int, simulate: Boolean): ImpreciseFraction {
-		return receiveEnergyInner(ImpreciseFraction(howMuch), simulate)
-	}
-
 	val batteryLevel: ImpreciseFraction
 	val maxBatteryLevel: ImpreciseFraction
 	val missingPower: ImpreciseFraction
@@ -179,8 +75,111 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 	override fun canReceive(): Boolean {
 		return receiveEnergyOuter(ImpreciseFraction.ONE, true) > ImpreciseFraction.ZERO
 	}
+}
 
-	fun transferInner(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
+fun IMatteryEnergyStorage.receiveEnergyOuterExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
+	val extracted = receiveEnergyOuter(howMuch, true)
+
+	if (extracted != howMuch) {
+		return ImpreciseFraction.ZERO
+	}
+
+	if (!simulate) {
+		receiveEnergyOuter(howMuch, false)
+	}
+
+	return extracted
+}
+/**
+ * All or nothing
+ *
+ * @return energy extracted
+ */
+fun IMatteryEnergyStorage.extractEnergyOuterExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
+	val extracted = extractEnergyOuter(howMuch, true)
+
+	if (extracted != howMuch) {
+		return ImpreciseFraction.ZERO
+	}
+
+	if (!simulate) {
+		extractEnergyOuter(howMuch, false)
+	}
+
+	return extracted
+}
+
+/**
+ * All or nothing
+ *
+ * @return energy accepted
+ */
+fun IMatteryEnergyStorage.receiveEnergyInnerExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
+	val extracted = receiveEnergyInner(howMuch, true)
+
+	if (extracted != howMuch) {
+		return ImpreciseFraction.ZERO
+	}
+
+	if (!simulate) {
+		receiveEnergyInner(howMuch, false)
+	}
+
+	return extracted
+}
+
+/**
+ * All or nothing
+ *
+ * @return energy extracted
+ */
+fun IMatteryEnergyStorage.extractEnergyInnerExact(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
+	val extracted = extractEnergyInner(howMuch, true)
+
+	if (extracted != howMuch) {
+		return ImpreciseFraction.ZERO
+	}
+
+	if (!simulate) {
+		extractEnergyInner(howMuch, false)
+	}
+
+	return extracted
+}
+
+fun IMatteryEnergyStorage.extractEnergyOuter(howMuch: Long, simulate: Boolean): ImpreciseFraction {
+	return extractEnergyOuter(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.extractEnergyOuter(howMuch: Int, simulate: Boolean): ImpreciseFraction {
+	return extractEnergyOuter(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.receiveEnergyOuter(howMuch: Long, simulate: Boolean): ImpreciseFraction {
+	return receiveEnergyOuter(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.receiveEnergyOuter(howMuch: Int, simulate: Boolean): ImpreciseFraction {
+	return receiveEnergyOuter(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.extractEnergyInner(howMuch: Long, simulate: Boolean): ImpreciseFraction {
+	return extractEnergyInner(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.extractEnergyInner(howMuch: Int, simulate: Boolean): ImpreciseFraction {
+	return extractEnergyInner(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.receiveEnergyInner(howMuch: Long, simulate: Boolean): ImpreciseFraction {
+	return receiveEnergyInner(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.receiveEnergyInner(howMuch: Int, simulate: Boolean): ImpreciseFraction {
+	return receiveEnergyInner(ImpreciseFraction(howMuch), simulate)
+}
+
+fun IMatteryEnergyStorage.transferInner(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
 	if (!amount.isPositive)
 		return ImpreciseFraction.ZERO
 
@@ -191,9 +190,9 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 		extractEnergyInner(received, false)
 
 	return received
-	}
+}
 
-	fun transferOuter(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
+fun IMatteryEnergyStorage.transferOuter(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction {
 	if (!amount.isPositive)
 		return ImpreciseFraction.ZERO
 
@@ -204,5 +203,12 @@ interface IMatteryEnergyStorage : IEnergyStorage {
 		extractEnergyInner(received, false)
 
 	return received
-	}
+}
+
+fun IMatteryEnergyStorage.extractStepInner(base: ImpreciseFraction, multiplier: Int, simulate: Boolean): Int {
+	return (extractEnergyInner(base * multiplier, simulate) / base).toInt()
+}
+
+fun IMatteryEnergyStorage.extractStepOuter(base: ImpreciseFraction, multiplier: Int, simulate: Boolean): Int {
+	return (extractEnergyOuter(base * multiplier, simulate) / base).toInt()
 }