power networks

src/main/kotlin/org/neoflock/neocomputers/NeoComputers.kt

@@ -4,8 +4,11 @@ import com.google.common.base.Suppliers
 import dev.architectury.event.events.common.LifecycleEvent
 import dev.architectury.registry.registries.RegistrarManager
 import org.neoflock.neocomputers.block.Blocks
+import org.neoflock.neocomputers.entity.BlockEntities
+import org.neoflock.neocomputers.gui.menu.Menus
 import org.neoflock.neocomputers.item.Items
 import org.neoflock.neocomputers.item.Tabs
+import org.neoflock.neocomputers.network.Networking
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.util.function.Supplier
@@ -23,6 +26,28 @@ object NeoComputers {
         Blocks.BLOCKS.register();
         Blocks.registerBlockItems();
         Items.ITEMS.register();
+
+        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)
+
+        BlockEntities.BLOCKENTITIES.register()
+        Menus.MENUS.register()
         
         Tabs.TABS.register();
         LOGGER.info("Registered!")

src/main/kotlin/org/neoflock/neocomputers/network/Networking.kt

@@ -36,7 +36,46 @@ object Networking {
         val reachability = Visibility.NETWORK
         var reachableCache: Set<Node>? = null
 
-        open fun tick() {}
+        open fun getEnergy(): Double = 0.0
+        open fun setEnergy(energy: Double) {}
+
+        open fun maxEnergyCapacity(): Double = 0.0
+        open fun getChargerNodes(): Set<Node> = getReachable().plus(this)
+        fun totalEnergyInConnections(): Double = getChargerNodes().fold(0.0) { acc, node -> acc + node.getEnergy() }
+        fun maxEnergyInConnections(): Double = getChargerNodes().fold(0.0) { acc, node -> acc + node.maxEnergyCapacity() }
+
+        // the algorithm for balancing energy levels
+        fun balanceEnergyLevels() {
+            // basic algorithm: ensure equal percentages
+            val cap = this.maxEnergyInConnections();
+            val total = this.totalEnergyInConnections();
+
+            val percentage = total / cap;
+
+            getChargerNodes().forEach {
+                it.setEnergy(percentage * it.maxEnergyCapacity());
+            }
+        }
+
+        // attempts to consume
+        fun consumeEnergy(energy: Double): Boolean {
+            // consumes energy, returns false if not enough
+            val total = this.totalEnergyInConnections()
+            if(energy > total) return false
+
+            val percentageConsumed = energy / total
+
+            getChargerNodes().forEach {
+                it.setEnergy(it.getEnergy() * (1.0 - percentageConsumed));
+            }
+
+            return true
+        }
+
+        open fun tick() {
+            // rationale: the other ones can figure it out
+            if(this.maxEnergyCapacity() > 0) this.balanceEnergyLevels()
+        }
         // processes a received message
         open fun received(message: Message) {}
 
@@ -101,13 +140,13 @@ object Networking {
         fun directConnectTo(other: Node) {
             if(other in connections) return;
             connections.add(other);
-            onConnect(other);
+            this.onConnect(other);
         }
 
         fun directDisconnectFrom(other: Node) {
             if(other !in connections) return;
             connections.remove(other);
-            onDisconnect(other);
+            this.onDisconnect(other);
         }
     }
 
@@ -118,6 +157,12 @@ object Networking {
         }
     }
 
+    class DebugBatteryNode(var power: Double, val capacity: Double): Node() {
+        override fun maxEnergyCapacity() = capacity
+        override fun getEnergy() = power
+        override fun setEnergy(energy: Double) { power = energy }
+    }
+
     abstract class WirelessEndpoint : Node {
 
         constructor(position: BlockPos);
@@ -175,6 +220,10 @@ object Networking {
         }
     }
 
+    fun addNodes(vararg nodes: Node) {
+        nodes.forEach { addNode(it) }
+    }
+
     fun removeNode(node: Node) {
         if(node !in allNodes) return;
         allNodes.remove(node);
@@ -184,6 +233,10 @@ object Networking {
         allNodes.forEach { it.onNodeRemoved(node) }
     }
 
+    fun removeNodes(vararg nodes: Node) {
+        nodes.forEach { removeNode(it) }
+    }
+
     val channels = mutableMapOf<String, MutableSet<Node>>();
 
     fun addToChannel(channel: String, node: Node) {