DBot/overdrive_that_matters
DBot/overdrive_that_matters
3
1
Fork 0
Code Issues 63 Pull Requests Packages Releases Wiki Activity

Move helpers out from interface

Browse Source
This commit is contained in:
DBotThePony 2022-05-14 18:18:42 +07:00
parent 14c60033c3
commit cd622b0708
Signed by: DBot
GPG Key ID: DCC23B5715498507
3 changed files with 138 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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

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

@ -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

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

@ -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()
}