From cd622b0708fe13342ce8a25c860d9abd4aa45d2a Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Sat, 14 May 2022 18:18:42 +0700 Subject: [PATCH] Move helpers out from interface --- .../mc/otm/android/feature/NanobotsArmor.kt | 1 + .../entity/StoragePowerSupplierBlockEntity.kt | 1 + .../otm/capability/IMatteryEnergyStorage.kt | 266 +++++++++--------- 3 files changed, 138 insertions(+), 130 deletions(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsArmor.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsArmor.kt index 6b25cb923..3e969b80b 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsArmor.kt +++ b/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 diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/StoragePowerSupplierBlockEntity.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/StoragePowerSupplierBlockEntity.kt index 0ae5d5c38..6e32fbd56 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/StoragePowerSupplierBlockEntity.kt +++ b/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 diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/capability/IMatteryEnergyStorage.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/capability/IMatteryEnergyStorage.kt index c9c192a55..102ba2d0f 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/capability/IMatteryEnergyStorage.kt +++ b/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,30 +75,140 @@ interface IMatteryEnergyStorage : IEnergyStorage { override fun canReceive(): Boolean { return receiveEnergyOuter(ImpreciseFraction.ONE, true) > ImpreciseFraction.ZERO } - - fun transferInner(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction { - if (!amount.isPositive) - return ImpreciseFraction.ZERO - - val extracted = extractEnergyInner(amount, true) - val received = other.receiveEnergyOuter(extracted, simulate) - - if (!simulate) - extractEnergyInner(received, false) - - return received - } - - fun transferOuter(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction { - if (!amount.isPositive) - return ImpreciseFraction.ZERO - - val extracted = extractEnergyOuter(amount, true) - val received = other.receiveEnergyOuter(extracted, simulate) - - if (!simulate) - extractEnergyInner(received, false) - - return received - } +} + +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 + + val extracted = extractEnergyInner(amount, true) + val received = other.receiveEnergyOuter(extracted, simulate) + + if (!simulate) + extractEnergyInner(received, false) + + return received +} + +fun IMatteryEnergyStorage.transferOuter(other: IMatteryEnergyStorage, amount: ImpreciseFraction, simulate: Boolean): ImpreciseFraction { + if (!amount.isPositive) + return ImpreciseFraction.ZERO + + val extracted = extractEnergyOuter(amount, true) + val received = other.receiveEnergyOuter(extracted, simulate) + + if (!simulate) + 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() }