1.21.1 is so back

2026-04-12 19:31:40 +02:00
parent db2cbbbe8d
commit e38184d3a3
16 changed files with 163 additions and 117 deletions
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -51,6 +51,7 @@ dependencies {
    when(minecraft) { // NOTE: add more entries if you want to add more versions
        "1.20.1" -> archversion = "9.2.14"
        "1.20.4" -> archversion = "11.1.17"
+        "1.21.1" -> archversion = "13.0.8"
        "1.21.9" -> archversion = "18.0.5"
        else     -> archversion = "19.0.1" 
    }
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -23,7 +23,7 @@ stonecutter {
        }
        //i would recommend to use neoforge for mc > 1.20.1, i haven't tested neocomputers for forge on versions higher than that
        //mc("fabric","1.20.1","1.20.4", "1.21.1", "1.21.3", "1.21.4", "1.21.5", "1.21.6", "1.21.7", "1.21.8", "1.21.9", "1.21.10", "1.21.11")
-        mc("fabric", "1.20.1", "1.20.4", "1.21.9", "1.21.11")
+        mc("fabric", "1.20.1", "1.20.4", "1.21.1", "1.21.9", "1.21.11")
        mc("forge", "1.20.1")
        //WARNING: neoforge uses mods.toml instead of neoforge.mods.toml for versions 1.20.4 (?) and earlier
        //mc("neoforge", "1.20.4", "1.21.1", "1.21.3", "1.21.4", "1.21.5", "1.21.6", "1.21.7", "1.21.8", "1.21.9", "1.21.10", "1.21.11")
--- a/src/main/kotlin/org/neoflock/neocomputers/NeoComputers.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/NeoComputers.kt
@@ -1,26 +1,20 @@
 package org.neoflock.neocomputers

-import com.google.common.base.Suppliers
 import dev.architectury.event.events.client.ClientLifecycleEvent
-import dev.architectury.event.events.common.LifecycleEvent
 import dev.architectury.event.events.common.TickEvent
-import dev.architectury.registry.client.gui.MenuScreenRegistry
-import dev.architectury.registry.registries.RegistrarManager
-import net.minecraft.resources.Identifier
-import net.minecraft.util.profiling.jfr.event.ServerTickTimeEvent
+import net.minecraft.resources.ResourceLocation
 import org.neoflock.neocomputers.block.Blocks
 import org.neoflock.neocomputers.entity.BlockEntities
 import org.neoflock.neocomputers.gui.buffer.BufferRenderer
 import org.neoflock.neocomputers.gui.menu.Menus
 import org.neoflock.neocomputers.gui.screen.ScreenScreen
+import dev.architectury.registry.menu.MenuRegistry
 import org.neoflock.neocomputers.item.Items
 import org.neoflock.neocomputers.item.Tabs
 import org.neoflock.neocomputers.network.Networking
 import org.neoflock.neocomputers.utils.FontProvider
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import java.util.function.Supplier
-

 object NeoComputers {
    const val MODID: String = "neocomputers"
@@ -31,24 +25,25 @@ object NeoComputers {
    fun entrypoint(platform: ModPlatform?) {
        PLATFORM = platform

-        Blocks.BLOCKS.register();
-        Blocks.registerBlockItems();
-        Items.ITEMS.register();
+        Blocks.BLOCKS.register()
+        Blocks.registerBlockItems()
+        Items.ITEMS.register()
        BlockEntities.BLOCKENTITIES.register()
+        BlockEntities.registerPowerBlocks()
        Menus.MENUS.register()
-        Tabs.TABS.register();
+        Tabs.TABS.register()

        ClientLifecycleEvent.CLIENT_SETUP.register {
-            MenuScreenRegistry.registerScreenFactory(Menus.SCREEN_MENU.get(), ::ScreenScreen)
+            MenuRegistry.registerScreenFactory(Menus.SCREEN_MENU.get(), ::ScreenScreen)
        }
        ClientLifecycleEvent.CLIENT_STARTED.register {
-            FontProvider.load(Identifier.fromNamespaceAndPath("neocomputers", "font/unscii.hex"))
+            FontProvider.load(ResourceLocation.fromNamespaceAndPath(MODID, "font/unscii.hex"))

-            var buffer: ArrayList<BufferRenderer.GPUChar> = arrayListOf(BufferRenderer.GPUChar('h'), BufferRenderer.GPUChar('a'), BufferRenderer.GPUChar('i'))
+            val buffer: ArrayList<BufferRenderer.GPUChar> = arrayListOf(BufferRenderer.GPUChar('h'), BufferRenderer.GPUChar('a'), BufferRenderer.GPUChar('i'))
            for (i in 0..<(400-3)) {
                buffer.add(BufferRenderer.GPUChar(' '))
            }
-            var bufferRenderer = BufferRenderer(20, 20, Identifier.fromNamespaceAndPath(MODID, "screen/test"), buffer)
+            val bufferRenderer = BufferRenderer(20, 20, ResourceLocation.fromNamespaceAndPath(MODID, "screen/test"), buffer)
            bufferRenderer.drawBuffer()
            // bufferRenderer.dump("/home/mewhenthe/code/NeoComputers/dump.png") // NOTE: CHANGE THIS BEFORE RUNNING!!!!
            bufferRenderer.clean()
@@ -59,25 +54,6 @@ object NeoComputers {
            Networking.tickAllNodes()
        }
        
-        val logA = Networking.LoggerNode("LogA")
-        val logB = Networking.LoggerNode("LogB")
-        val batteryA = Networking.DebugBatteryNode(0.0, 10000.0)
-        val batteryB = Networking.DebugBatteryNode(15000.0, 20000.0)
-        logA.connectTo(logB)
-        logA.connectTo(batteryA)
-        logB.connectTo(batteryB)
-
-        Networking.addNodes(logA, logB, batteryA, batteryB)
-
-        Networking.emitMessage(logA, Networking.ClassicPacket(logA, "a", "b", 0, listOf(), 0))
-        LOGGER.info("A: ${batteryA.getEnergy()} / ${batteryA.maxEnergyCapacity()}, B: ${batteryB.getEnergy()} / ${batteryB.maxEnergyCapacity()}")
-        Networking.tickAllNodes();
-        LOGGER.info("A: ${batteryA.getEnergy()} / ${batteryA.maxEnergyCapacity()}, B: ${batteryB.getEnergy()} / ${batteryB.maxEnergyCapacity()}")
-        LOGGER.info("Had enough: ${if(logA.consumeEnergy(600.0)) 'Y' else 'N'}")
-        LOGGER.info("A: ${batteryA.getEnergy()} / ${batteryA.maxEnergyCapacity()}, B: ${batteryB.getEnergy()} / ${batteryB.maxEnergyCapacity()}")
-
-        Networking.removeNodes(logA, logB, batteryA, batteryB)
-        
        LOGGER.info("Registered!")
        //LOGGER.info("Started mod in %s loader".formatted(NeoComputersInit.PLATFORM.getModloader()))
        //LOGGER.info("Kotlin: %s".formatted(NeoComputers.hello()))
--- a/src/main/kotlin/org/neoflock/neocomputers/block/BaseBlock.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/block/BaseBlock.kt
@@ -2,21 +2,17 @@ package org.neoflock.neocomputers.block

 import dev.architectury.registry.registries.RegistrySupplier
 import net.minecraft.core.registries.Registries
-import net.minecraft.resources.Identifier
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.resources.ResourceKey
 import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.block.state.BlockBehaviour
 import org.neoflock.neocomputers.NeoComputers
 import java.util.function.Supplier
+import com.google.common.base.Suppliers

-open class BaseBlock : Block { // TODO: create a TieredBaseBlock class that extends this or something
+open class BaseBlock : Block(BlockBehaviour.Properties.of()) { // TODO: create a TieredBaseBlock class that extends this or something
    // val tier: Int

-    constructor(name: String):super(
-        BlockBehaviour.Properties.of()
-            .setId(ResourceKey
-            .create(Registries.BLOCK, Identifier.fromNamespaceAndPath(NeoComputers.MODID, name))))
-
    companion object Registry {
        fun register(name: String, sup: Supplier<BaseBlock>): RegistrySupplier<Block> = Blocks.BLOCKS.register(name, sup);
    }
--- a/src/main/kotlin/org/neoflock/neocomputers/block/Blocks.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/block/Blocks.kt
@@ -6,7 +6,7 @@ import dev.architectury.registry.registries.Registrar
 import dev.architectury.registry.registries.RegistrarManager
 import dev.architectury.registry.registries.RegistrySupplier
 import net.minecraft.core.registries.Registries
-import net.minecraft.resources.Identifier
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.resources.ResourceKey
 import net.minecraft.world.item.BlockItem
 import net.minecraft.world.item.Item
@@ -25,13 +25,13 @@ object Blocks {


    val BLOCKS: DeferredRegister<Block> = DeferredRegister.create(NeoComputers.MODID, Registries.BLOCK)
-    val TEST_BLOCK: RegistrySupplier<Block> = BaseBlock.register("test") { BaseBlock("test") }
    val SCREEN_BLOCK: RegistrySupplier<Block> = BaseBlock.register("screen") { ScreenBlock() }
    val CAPACITOR_BLOCK: RegistrySupplier<Block> = BaseBlock.register("capacitor") { CapacitorBlock() }

    fun registerBlockItems() {
        BLOCKS.forEach(Consumer { sup: RegistrySupplier<Block> ->
-            Items.ITEMS.register(sup.id.path) { BlockItem(sup.get()!!, Item.Properties().`arch$tab`(Tabs.TAB).setId(ResourceKey.create(Registries.ITEM, sup.id)))}
+            val id = ResourceKey.create(Registries.ITEM, sup.id)
+            Items.ITEMS.register(sup.id.path) { BlockItem(sup.get()!!, Item.Properties().`arch$tab`(Tabs.TAB))}
        })
    }
 }
--- a/src/main/kotlin/org/neoflock/neocomputers/block/Capacitor.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/block/Capacitor.kt
@@ -8,31 +8,37 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.InteractionResult
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.level.Level
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.EntityBlock
 import net.minecraft.world.level.block.entity.BlockEntity
 import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.redstone.Orientation
 import net.minecraft.world.phys.BlockHitResult
 import org.neoflock.neocomputers.entity.BlockEntities
 import org.neoflock.neocomputers.network.Networking
 import org.neoflock.neocomputers.network.PowerRole
+import kotlin.math.min

 class CapacitorEntity(pos: BlockPos, state: BlockState) : NodeBlockEntity(BlockEntities.CAPACITOR_ENTITY.get(), pos, state) {
-    var amountStored: Double = 0.0
-    val capacity = 20000.0
+    var amountStored: Long = 0
+    val capacity: Long = 20000

    override val node = object : Networking.Node() {
        override fun getPowerRole() = PowerRole.PRODUCER
        override fun getEnergy() = amountStored
-        override fun maxEnergyCapacity(): Double = capacity
-        override fun setEnergy(energy: Double) {
-            amountStored = energy
+        override fun getEnergyCapacity() = capacity
+        override fun giveEnergy(amount: Long): Long {
+            val given = min(amount, capacity - amountStored)
+            amountStored += given
+            return given
+        }
+
+        override fun withdrawEnergy(amount: Long): Long {
+            val taken = min(amount, amountStored)
+            amountStored -= taken
+            return taken
        }
    }
 }

-class CapacitorBlock : NodeBlock("capacitor")  {
+class CapacitorBlock : NodeBlock()  {
    override fun newBlockEntity(blockPos: BlockPos, blockState: BlockState): BlockEntity? {
        val cap = CapacitorEntity(blockPos, blockState)
        cap.initNetworking()
--- a/src/main/kotlin/org/neoflock/neocomputers/block/NodeBlock.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/block/NodeBlock.kt
@@ -11,7 +11,6 @@ import net.minecraft.world.level.block.entity.BlockEntity
 import net.minecraft.world.level.block.entity.BlockEntityTicker
 import net.minecraft.world.level.block.entity.BlockEntityType
 import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.redstone.Orientation
 import org.neoflock.neocomputers.network.Networking

 abstract class NodeBlockEntity(blockEntityType: BlockEntityType<*>, blockPos: BlockPos, blockState: BlockState) : BlockEntity(blockEntityType, blockPos, blockState) {
@@ -73,7 +72,7 @@ abstract class NodeBlockEntity(blockEntityType: BlockEntityType<*>, blockPos: Bl
    }
 }

-abstract class NodeBlock(name: String): BaseBlock(name), EntityBlock {
+abstract class NodeBlock: BaseBlock(), EntityBlock {
    override fun <T : BlockEntity> getTicker(
        level: Level,
        blockState: BlockState,
@@ -108,7 +107,7 @@ abstract class NodeBlock(name: String): BaseBlock(name), EntityBlock {
        level: Level,
        blockPos: BlockPos,
        block: Block,
-        orientation: Orientation?,
+        blockPos2: BlockPos,
        bl: Boolean
    ) {
        if(!level.isClientSide) {
@@ -118,6 +117,6 @@ abstract class NodeBlock(name: String): BaseBlock(name), EntityBlock {
            }

        }
-        super.neighborChanged(blockState, level, blockPos, block, orientation, bl)
+        super.neighborChanged(blockState, level, blockPos, block, blockPos2, bl)
    }
 }
--- a/src/main/kotlin/org/neoflock/neocomputers/block/ScreenBlock.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/block/ScreenBlock.kt
@@ -22,7 +22,7 @@ import org.neoflock.neocomputers.entity.ScreenEntity
 import org.neoflock.neocomputers.gui.menu.Menus
 import org.neoflock.neocomputers.network.Networking

-class ScreenBlock() : NodeBlock("screen") {
+class ScreenBlock() : NodeBlock() {

    override fun newBlockEntity(blockPos: BlockPos, blockState: BlockState): BlockEntity? {
        val scr = ScreenEntity(blockPos, blockState)
@@ -39,7 +39,7 @@ class ScreenBlock() : NodeBlock("screen") {
    ): InteractionResult {
        if(!level.isClientSide) {
            val screenState = level.getBlockEntity(blockPos, BlockEntities.SCREEN_ENTITY.get()).get()
-            if(!screenState.node.consumeEnergy(5.0)) return InteractionResult.SUCCESS;
+            if(!screenState.node.consumeEnergy(5)) return InteractionResult.SUCCESS;
            MenuRegistry.openMenu(player as ServerPlayer, object : MenuProvider {
                override fun getDisplayName(): Component = Component.literal("SCREEEEEN!")
                override fun createMenu(i: Int, inventory: Inventory, player: Player): AbstractContainerMenu {
--- a/src/main/kotlin/org/neoflock/neocomputers/block/SolarGeneratorBlock.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/block/SolarGeneratorBlock.kt
@@ -0,0 +1,4 @@
+package org.neoflock.neocomputers.block
+
+class SolarGeneratorBlock : BaseBlock() {
+}
--- a/src/main/kotlin/org/neoflock/neocomputers/entity/BlockEntities.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/entity/BlockEntities.kt
@@ -1,16 +1,54 @@
 package org.neoflock.neocomputers.entity;

+import com.mojang.datafixers.types.templates.TypeTemplate
+import com.mojang.serialization.Codec
+import com.mojang.datafixers.types.Type as DataFixType
 import dev.architectury.registry.registries.DeferredRegister
 import dev.architectury.registry.registries.RegistrySupplier
 import net.minecraft.core.registries.Registries
+import net.minecraft.util.datafix.DataFixTypes
+import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.block.entity.BlockEntityType
 import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.block.Blocks
 import org.neoflock.neocomputers.block.CapacitorEntity
+import org.neoflock.neocomputers.network.PowerManager
+
+// complete fucking bullshit btw
+class BullshitFix: DataFixType<Unit>() {
+    override fun buildTemplate(): TypeTemplate? {
+        return null
+    }
+
+    override fun buildCodec(): Codec<Unit?>? {
+        return null
+    }
+
+    override fun equals(
+        o: Any?,
+        ignoreRecursionPoints: Boolean,
+        checkIndex: Boolean
+    ): Boolean {
+        return o == this
+    }
+
+}

 object BlockEntities {
    val BLOCKENTITIES: DeferredRegister<BlockEntityType<*>> = DeferredRegister.create(NeoComputers.MODID, Registries.BLOCK_ENTITY_TYPE);

-    val SCREEN_ENTITY: RegistrySupplier<BlockEntityType<ScreenEntity>> = BLOCKENTITIES.register("screen_entity") { BlockEntityType(::ScreenEntity, mutableSetOf(Blocks.SCREEN_BLOCK.get()))}
-    val CAPACITOR_ENTITY: RegistrySupplier<BlockEntityType<CapacitorEntity>> = BLOCKENTITIES.register("capacitor_entity") { BlockEntityType(::CapacitorEntity, mutableSetOf(Blocks.CAPACITOR_BLOCK.get()))}
+    val SCREEN_ENTITY: RegistrySupplier<BlockEntityType<ScreenEntity>> = BLOCKENTITIES.register("screen_entity") {
+        BlockEntityType(
+            ::ScreenEntity, mutableSetOf(Blocks.SCREEN_BLOCK.get()), BullshitFix()
+        )
+    }
+    val CAPACITOR_ENTITY: RegistrySupplier<BlockEntityType<CapacitorEntity>> = BLOCKENTITIES.register("capacitor_entity") {
+        BlockEntityType(
+            ::CapacitorEntity, mutableSetOf(Blocks.CAPACITOR_BLOCK.get()), BullshitFix()
+        )
+    }
+
+    fun registerPowerBlocks() {
+        PowerManager.registerPowerBlockEntity(CAPACITOR_ENTITY.get())
+    }
 }
--- a/src/main/kotlin/org/neoflock/neocomputers/entity/ScreenEntity.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/entity/ScreenEntity.kt
@@ -9,14 +9,5 @@ import org.neoflock.neocomputers.network.PowerRole
 class ScreenEntity(blockPos: BlockPos, blockState: BlockState) :
    NodeBlockEntity(BlockEntities.SCREEN_ENTITY.get(), blockPos, blockState) {

-    var energyStored: Double = 0.0
-
-    override val node = object : Networking.Node() {
-        override fun getPowerRole() = PowerRole.CONSUMER
-        override fun getEnergy() = energyStored
-        override fun setEnergy(energy: Double) {
-            energyStored = energy
-        }
-        override fun maxEnergyCapacity(): Double = 10.0
-    }
+    override val node = Networking.Node()
 }
--- a/src/main/kotlin/org/neoflock/neocomputers/gui/buffer/BufferRenderer.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/gui/buffer/BufferRenderer.kt
@@ -4,32 +4,36 @@ import com.mojang.blaze3d.platform.NativeImage
 import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.texture.DynamicTexture
 import net.minecraft.client.renderer.texture.TextureManager
-import net.minecraft.resources.Identifier
+import net.minecraft.resources.ResourceLocation
 import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.utils.FontProvider
 import java.io.File
 import kotlin.experimental.and
 import kotlin.experimental.xor

-class BufferRenderer(width: Int, height: Int, id: Identifier, buffer: MutableList<GPUChar>) { // TODO: NN buffer
+class BufferRenderer(width: Int, height: Int, id: ResourceLocation, buffer: MutableList<GPUChar>) { // TODO: NN buffer
    val CHARW = 8
    val CHARH = 16

    private var width: Int = width;
    private var height: Int = height;
-    private var id: Identifier = id;
+    private var id: ResourceLocation = id;
    private var buffer: MutableList<GPUChar> = buffer;

    private var texwidth: Int = width*CHARW;
    private var texheight: Int = height*CHARH;
    private var image: NativeImage = NativeImage(texwidth, texheight, true); // idk what the boolean is
-    private var tex: DynamicTexture = DynamicTexture({id.path}, image)
+    private var tex: DynamicTexture = DynamicTexture(image)

    fun dump(path: String) {
        image.writeToFile(File(path))
        NeoComputers.LOGGER.info("DUMPED!!!")
    }

+    fun toRGBA(color: Int): Int {
+        return color.shl(8).or(0xFF)
+    }
+
    fun drawGlyph(x: Int, y: Int, c: Char, fg: Int) {
        var glyph: ArrayList<Byte> = FontProvider.map[c]!!

@@ -37,7 +41,7 @@ class BufferRenderer(width: Int, height: Int, id: Identifier, buffer: MutableLis
            for (i in 0..<CHARW) {
                // var pixel = ((glyph[j] and ((1 shl (CHARW - i - 1)).toByte())).toInt()) ushr (CHARW - i - 1) // retardation
                var pixel = (glyph[j] and (0b10000000 ushr i).toByte()).toInt()
-                if (pixel > 0) image.setPixelABGR(x+i, y+j, (0xFF000000+fg).toInt())
+                if (pixel > 0) image.setPixelRGBA(x+i, y+j, toRGBA(fg))
            }
        }
    }
--- a/src/main/kotlin/org/neoflock/neocomputers/network/Networking.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/network/Networking.kt
@@ -47,46 +47,51 @@ object Networking {

        open fun getReachability() = Visibility.NETWORK
        open fun getPowerRole() = PowerRole.CONSUMER
-        open fun getEnergy(): Double = 0.0
-        open fun setEnergy(energy: Double) {}
+        open fun getEnergy(): Long = 0
+        // give energy, returns how much was actually given
+        // cannot exceed amount specified
+        open fun giveEnergy(amount: Long): Long = 0
+        // take energy out, returns how much was actually taken
+        // cannot exceed amount specified
+        open fun withdrawEnergy(amount: Long): Long = 0

-        open fun maxEnergyCapacity(): Double = 0.0
+        open fun getEnergyCapacity(): Long = 0
        fun getChargerNodes(): Set<Node> = getReachable().filter { it.getPowerRole() == PowerRole.PRODUCER }.toSet()
-        fun totalEnergyInConnections(): Double = getChargerNodes().fold(0.0) { acc, node -> acc + node.getEnergy() }
-        fun maxEnergyInConnections(): Double = getChargerNodes().fold(0.0) { acc, node -> acc + node.maxEnergyCapacity() }
-
-        fun consumeFromNodeAsMuchAsPossible(energy: Double): Double {
-            val consumed = min(energy, getEnergy())
-            setEnergy(getEnergy() - consumed)
-            return consumed
-        }
+        fun totalEnergyInConnections(): Long = getChargerNodes().fold(0) { acc, node -> acc + node.getEnergy() }
+        fun maxEnergyInConnections(): Long = getChargerNodes().fold(0) { acc, node -> acc + node.getEnergyCapacity() }

        // attempts to consume
-        fun consumeEnergy(energy: Double): Boolean {
+        fun consumeEnergy(energy: Long): Boolean {
            // consumes energy, returns false if not enough
            val total = totalEnergyInConnections() + getEnergy()
            if(energy > total) return false

            var remaining = energy
-            remaining -= consumeFromNodeAsMuchAsPossible(remaining)
-            if(remaining <= 0.0) return true
+            remaining -= withdrawEnergy(remaining)
+            if(remaining <= 0) return true

            for (charger in getChargerNodes()) {
-                if(remaining <= 0.0) break
-                remaining -= charger.consumeFromNodeAsMuchAsPossible(remaining)
+                if(remaining <= 0) break
+                remaining -= charger.withdrawEnergy(remaining)
            }

            return true
        }

        fun tryToChargeFully() {
-            var remaining = maxEnergyCapacity() - getEnergy()
-            if(remaining <= 0.0) return
+            var remaining = getEnergyCapacity() - getEnergy()
+            if(remaining <= 0) return
            for (charger in getChargerNodes()) {
-                if(remaining <= 0.0) break
-                val amount = charger.consumeFromNodeAsMuchAsPossible(remaining)
-                setEnergy(getEnergy() + amount)
-                remaining -= amount
+                if(remaining <= 0) break
+                val amount = charger.withdrawEnergy(remaining)
+                val given = giveEnergy(amount)
+                remaining -= given
+                if(given < amount) {
+                    val delta = amount - given // amount lost while given back
+                    if(charger.giveEnergy(delta) < delta) {
+                        NeoComputers.LOGGER.warn("LOSING ENERGY! Tried giving $delta back to $charger and we're losing our marbles!")
+                    }
+                }
            }
        }

@@ -173,20 +178,6 @@ object Networking {
        }
    }

-    class LoggerNode(val label: String): Node() {
-        override fun received(message: Message) {
-            NeoComputers.LOGGER.info("$label: ${message.javaClass.name} message");
-            super.received(message)
-        }
-    }
-
-    class DebugBatteryNode(var power: Double, val capacity: Double): Node() {
-        override fun getPowerRole() = PowerRole.PRODUCER
-        override fun maxEnergyCapacity() = capacity
-        override fun getEnergy() = power
-        override fun setEnergy(energy: Double) { power = energy }
-    }
-
    abstract class WirelessEndpoint : Node {

        constructor(position: BlockPos);
--- a/src/main/kotlin/org/neoflock/neocomputers/network/PowerManager.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/network/PowerManager.kt
@@ -0,0 +1,40 @@
+package org.neoflock.neocomputers.network
+
+import net.minecraft.world.level.block.entity.BlockEntityType
+//? if fabric {
+import net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext
+import org.neoflock.neocomputers.block.NodeBlockEntity
+import team.reborn.energy.api.EnergyStorage;
+//?}
+
+// our soul purpose is to fuse bullshit power APIs together
+// the NodeBlockEntity and Node given us a way to get power from a block, we just
+// need to tell mods how to do it as well
+object PowerManager {
+    fun<T: NodeBlockEntity> registerPowerBlockEntity(blockEntityType: BlockEntityType<T>) {
+        //? if fabric {
+        EnergyStorage.SIDED.registerForBlockEntity({
+            entity, dir -> object : EnergyStorage {
+                override fun getAmount() = entity.node.getEnergy()
+                override fun getCapacity() = entity.node.getEnergyCapacity()
+                override fun supportsExtraction() = entity.node.getPowerRole() == PowerRole.PRODUCER
+                override fun supportsInsertion(): Boolean = entity.node.getEnergyCapacity() > 0
+                override fun extract(maxAmount: Long, transaction: TransactionContext?): Long {
+                    val taken = entity.node.withdrawEnergy(maxAmount)
+                    transaction?.addCloseCallback {
+                        ctx, res -> if(res.wasAborted() || !res.wasCommitted()) entity.node.giveEnergy(taken)
+                    }
+                    return taken
+                }
+                override fun insert(maxAmount: Long, transaction: TransactionContext?): Long {
+                    val given = entity.node.giveEnergy(maxAmount)
+                    transaction?.addCloseCallback {
+                            ctx, res -> if(res.wasAborted() || !res.wasCommitted()) entity.node.withdrawEnergy(given)
+                    }
+                    return given
+                }
+            }
+        }, blockEntityType);
+        //?}
+    }
+}
--- a/src/main/kotlin/org/neoflock/neocomputers/utils/FontProvider.kt
+++ b/src/main/kotlin/org/neoflock/neocomputers/utils/FontProvider.kt
@@ -1,7 +1,7 @@
 package org.neoflock.neocomputers.utils;

 import net.minecraft.client.Minecraft
-import net.minecraft.resources.Identifier
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.packs.resources.Resource
 import net.minecraft.server.packs.resources.ResourceManager
 import org.neoflock.neocomputers.NeoComputers
@@ -10,7 +10,7 @@ import java.nio.charset.StandardCharsets
 object FontProvider {
    val map: MutableMap<Char, ArrayList<Byte>> = mutableMapOf();

-    fun load(loc: Identifier) { // TODO: optimize, this can totally be optimized
+    fun load(loc: ResourceLocation) { // TODO: optimize, this can totally be optimized
        var man: ResourceManager = Minecraft.getInstance().resourceManager
        var resource: Resource = man.getResourceOrThrow(loc)
        var stream = resource.open()
--- a/stonecutter.gradle.kts
+++ b/stonecutter.gradle.kts
@@ -5,7 +5,7 @@ plugins {
    id("com.gradleup.shadow") version "9.3.0" apply false
    id("me.modmuss50.mod-publish-plugin") version "0.8.4" apply false
 }
-stonecutter active "1.21.11-fabric" /* [SC] DO NOT EDIT */
+stonecutter active "1.21.1-fabric" /* [SC] DO NOT EDIT */
 stonecutter.automaticPlatformConstants = true

 // Builds every version into `build/libs/{mod.version}/{loader}`