1.21.1 is so back

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" 
     }

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")

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 net.minecraft.resources.ResourceLocation
-import dev.architectury.registry.registries.RegistrarManager
-import net.minecraft.resources.Identifier
-import net.minecraft.util.profiling.jfr.event.ServerTickTimeEvent
 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.BLOCKS.register()
-        Blocks.registerBlockItems();
+        Blocks.registerBlockItems()
-        Items.ITEMS.register();
+        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()
@@ -58,25 +53,6 @@ object NeoComputers {
         TickEvent.SERVER_POST.register {
             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()))

src/main/kotlin/org/neoflock/neocomputers/block/BaseBlock.kt

@@ -2,20 +2,16 @@ 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);

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

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
+    var amountStored: Long = 0
-    val capacity = 20000.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 getEnergyCapacity() = capacity
-        override fun setEnergy(energy: Double) {
+        override fun giveEnergy(amount: Long): Long {
-            amountStored = energy
+            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()

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

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 {

src/main/kotlin/org/neoflock/neocomputers/block/SolarGeneratorBlock.kt

@@ -0,0 +1,4 @@
+package org.neoflock.neocomputers.block
+
+class SolarGeneratorBlock : BaseBlock() {
+}

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 SCREEN_ENTITY: RegistrySupplier<BlockEntityType<ScreenEntity>> = BLOCKENTITIES.register("screen_entity") {
-    val CAPACITOR_ENTITY: RegistrySupplier<BlockEntityType<CapacitorEntity>> = BLOCKENTITIES.register("capacitor_entity") { BlockEntityType(::CapacitorEntity, mutableSetOf(Blocks.CAPACITOR_BLOCK.get()))}
+        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())
+    }
 }

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 = Networking.Node()
-
-    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
-    }
 }

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

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 getEnergy(): Long = 0
-        open fun setEnergy(energy: Double) {}
+        // 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 totalEnergyInConnections(): Long = getChargerNodes().fold(0) { acc, node -> acc + node.getEnergy() }
-        fun maxEnergyInConnections(): Double = getChargerNodes().fold(0.0) { acc, node -> acc + node.maxEnergyCapacity() }
+        fun maxEnergyInConnections(): Long = getChargerNodes().fold(0) { acc, node -> acc + node.getEnergyCapacity() }
-
-        fun consumeFromNodeAsMuchAsPossible(energy: Double): Double {
-            val consumed = min(energy, getEnergy())
-            setEnergy(getEnergy() - consumed)
-            return consumed
-        }
 
         // 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)
+            remaining -= withdrawEnergy(remaining)
-            if(remaining <= 0.0) return true
+            if(remaining <= 0) return true
 
             for (charger in getChargerNodes()) {
-                if(remaining <= 0.0) break
+                if(remaining <= 0) break
-                remaining -= charger.consumeFromNodeAsMuchAsPossible(remaining)
+                remaining -= charger.withdrawEnergy(remaining)
             }
 
             return true
         }
 
         fun tryToChargeFully() {
-            var remaining = maxEnergyCapacity() - getEnergy()
+            var remaining = getEnergyCapacity() - getEnergy()
-            if(remaining <= 0.0) return
+            if(remaining <= 0) return
             for (charger in getChargerNodes()) {
-                if(remaining <= 0.0) break
+                if(remaining <= 0) break
-                val amount = charger.consumeFromNodeAsMuchAsPossible(remaining)
+                val amount = charger.withdrawEnergy(remaining)
-                setEnergy(getEnergy() + amount)
+                val given = giveEnergy(amount)
-                remaining -= 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);

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);
+        //?}
+    }
+}

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

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}`