Working Energy Transmission

src/main/java/org/KaiFlo/SolarCell/Components/EnergyStorage/Implementations/EnergyStorageComponent.java

@@ -102,12 +102,12 @@ public class EnergyStorageComponent implements Component<ChunkStore>, IEnergySto
     public long extractEnergy(long requiredEnergy) {
         var extractedEnergy = Math.min(currentEnergyAmount, Math.min(requiredEnergy, extractEnergyPerTick));
         currentEnergyAmount -= extractedEnergy;
-        if (extractedEnergy >=1000){
+//        if (extractedEnergy >=1000){
-            HyLogger.atInfo().log("Extracted Energy: " + extractedEnergy + " now at " + currentEnergyAmount);
+//            HyLogger.atInfo().log("Extracted Energy: " + extractedEnergy + " now at " + currentEnergyAmount);
-            for (StackTraceElement element : Arrays.stream(Thread.currentThread().getStackTrace()).limit(7).toList()) {
+//            for (StackTraceElement element : Arrays.stream(Thread.currentThread().getStackTrace()).limit(7).toList()) {
-                HyLogger.atInfo().log(String.valueOf(element));
+//                HyLogger.atInfo().log(String.valueOf(element));
-            }
+//            }
-        }
+//        }
         return extractedEnergy;
     }
 

src/main/java/org/KaiFlo/SolarCell/Systems/EnergySource/TickingImplementations/SolarCellSourceTicking.java

@@ -3,6 +3,7 @@ package org.KaiFlo.SolarCell.Systems.EnergySource.TickingImplementations;
 import com.hypixel.hytale.component.Archetype;
 import com.hypixel.hytale.component.CommandBuffer;
 import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.component.Ref;
 import com.hypixel.hytale.protocol.Vector3i;
 import com.hypixel.hytale.server.core.universe.world.World;
 import com.hypixel.hytale.server.core.universe.world.chunk.BlockComponentChunk;
@@ -12,6 +13,7 @@ import org.KaiFlo.SolarCell.Components.EnergyStorage.Implementations.EnergyStora
 import org.KaiFlo.SolarCell.Systems.ITickingSystem;
 
 import java.util.List;
+import java.util.Set;
 
 import static org.KaiFlo.SolarCell.Helpers.BlockHelper.HyLogger;
 import static org.KaiFlo.SolarCell.Helpers.ComponentHelper.getComponentOfType;
@@ -19,7 +21,7 @@ import static org.KaiFlo.SolarCell.Helpers.ComponentHelper.getComponentOfType;
 public class SolarCellSourceTicking implements ITickingSystem {
 
     @Override
-    public void accept(List<Component<ChunkStore>> foundComponents, Archetype<ChunkStore> archetype, Vector3i globalPosition, BlockComponentChunk blockComponentChunk, CommandBuffer<ChunkStore> commandBuffer, World world) {
+    public void accept(Ref<ChunkStore> blockRef, List<Component<ChunkStore>> foundComponents, Archetype<ChunkStore> archetype, Vector3i globalPosition, BlockComponentChunk blockComponentChunk, CommandBuffer<ChunkStore> commandBuffer, World world, Set<Ref<ChunkStore>> blockRefs) {
         var energyStorage = getComponentOfType(foundComponents, EnergyStorageComponent.class).orElse(null);
         if (energyStorage == null) return;
         var energySource = getComponentOfType(foundComponents, EnergySourceComponent.class).orElse(null);

src/main/java/org/KaiFlo/SolarCell/Systems/EnergyStorage/EnergyStorageInitializerSystem.java

@@ -9,11 +9,13 @@ import org.KaiFlo.SolarCell.Components.EnergyStorage.Implementations.EnergyStora
 import org.checkerframework.checker.nullness.compatqual.NonNullDecl;
 import org.checkerframework.checker.nullness.compatqual.NullableDecl;
 
+import static org.KaiFlo.SolarCell.Helpers.BlockHelper.HyLogger;
 import static org.KaiFlo.SolarCell.Helpers.BlockHelper.setBlockRefTicking;
 
 public class EnergyStorageInitializerSystem extends RefSystem<ChunkStore> {
     @Override
     public void onEntityAdded(@NonNullDecl Ref<ChunkStore> ref, @NonNullDecl AddReason addReason, @NonNullDecl Store<ChunkStore> store, @NonNullDecl CommandBuffer<ChunkStore> commandBuffer) {
+        HyLogger.atInfo().log("onEntityAdded");
         setBlockRefTicking(ref, commandBuffer);
     }
 

src/main/java/org/KaiFlo/SolarCell/Systems/EnergyStorage/TickingImplementations/BatteryStorageTicking.java

@@ -3,6 +3,7 @@ package org.KaiFlo.SolarCell.Systems.EnergyStorage.TickingImplementations;
 import com.hypixel.hytale.component.Archetype;
 import com.hypixel.hytale.component.CommandBuffer;
 import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.component.Ref;
 import com.hypixel.hytale.protocol.Vector3i;
 import com.hypixel.hytale.server.core.universe.world.World;
 import com.hypixel.hytale.server.core.universe.world.chunk.BlockComponentChunk;
@@ -12,6 +13,7 @@ import org.KaiFlo.SolarCell.Components.EnergyStorage.Implementations.EnergyStora
 import org.KaiFlo.SolarCell.Systems.ITickingSystem;
 
 import java.util.List;
+import java.util.Set;
 
 import static org.KaiFlo.SolarCell.Helpers.BlockHelper.HyLogger;
 import static org.KaiFlo.SolarCell.Helpers.BlockHelper.executeForCubeAroundChunkSafe;
@@ -20,35 +22,75 @@ import static org.KaiFlo.SolarCell.Helpers.ComponentHelper.getComponentOfType;
 public class BatteryStorageTicking implements ITickingSystem {
 
     @Override
-    public void accept(List<Component<ChunkStore>> foundComponents, Archetype<ChunkStore> archetype, Vector3i globalPosition, BlockComponentChunk blockComponentChunk, CommandBuffer<ChunkStore> commandBuffer, World world) {
+    public void accept(Ref<ChunkStore> blockRef, List<Component<ChunkStore>> foundComponents, Archetype<ChunkStore> archetype, Vector3i globalPosition, BlockComponentChunk blockComponentChunk, CommandBuffer<ChunkStore> commandBuffer, World world, Set<Ref<ChunkStore>> blockRefs) {
         var energyStorage = getComponentOfType(foundComponents, EnergyStorageComponent.class).orElse(null);
         if (energyStorage == null) return;
         var energySourceComponent = getComponentOfType(foundComponents, EnergySourceComponent.class).orElse(null);
         if (energySourceComponent != null) return;
-        if (energyStorage.getCurrentEnergyAmount() >= energyStorage.getMaxCapacity()) {
-            return;
-        }
         executeForCubeAroundChunkSafe(globalPosition.x, globalPosition.y, globalPosition.z, 5, false, world, commandBuffer,
             (x, y, z, targetRef, blockCompChunk, targetChunk) -> {
+//                if (blockRefs.contains(targetRef)) {
+//                    return;
+//                }
+                if (energyStorage.getCurrentEnergyAmount() >= energyStorage.getMaxCapacity()) {
+                    return;
+                }
 
                 var targetEnergyStorage = commandBuffer.getComponent(targetRef, EnergyStorageComponent.getComponentType());
                 if (targetEnergyStorage == null) return;
                 if (targetEnergyStorage.getCurrentEnergyAmount() < energyStorage.getCurrentEnergyAmount()) return;
 
-                long energy = targetEnergyStorage.extractEnergy(Math.min(energyStorage.getMaxCapacity()-energyStorage.getCurrentEnergyAmount(),
+                long diff = targetEnergyStorage.getCurrentEnergyAmount()
-                    Math.min(
+                    - energyStorage.getCurrentEnergyAmount();
-                    targetEnergyStorage.getExtractEnergyPerTick(),
+                var diffWasNegative = diff < 0;
-                    energyStorage.getReceiveEnergyPerTick()
+                diff = Math.abs(diff);
-                )));
-                long inserted = energyStorage.receiveEnergy(energy);
 
-                if (inserted != 0 && energyStorage.getCurrentEnergyAmount() != energyStorage.getMaxCapacity()) {
+                long extractTarget = Math.min(
-                    HyLogger.atInfo().log("Inserted " + inserted + "/" + energy +
+                    Math.ceilDiv(diff,2),
-                        " |" + targetEnergyStorage.getCurrentEnergyAmount() + "| into storage" +
+                    Math.min(
-                        " at Block " + globalPosition.x + ", " + globalPosition.y + ", " + globalPosition.z + ", " +
+                        targetEnergyStorage.getExtractEnergyPerTick(),
-                        energyStorage.getCurrentEnergyAmount() + "/" + energyStorage.getMaxCapacity());
+                        energyStorage.getReceiveEnergyPerTick()
+                    )
+                );
+                if (extractTarget<=0){
+                    return;
                 }
+                if (diffWasNegative) {
+                    transmitEnergy(targetEnergyStorage,energyStorage,extractTarget,new Vector3i(x,y,z), globalPosition.x, globalPosition.y, globalPosition.z);
+                }else {
+                    transmitEnergy(energyStorage,targetEnergyStorage,extractTarget,globalPosition, x, y, z);
+                }
+
             }
         );
+
+//        blockRefs.add(blockRef);
+    }
+
+    private static void transmitEnergy( EnergyStorageComponent energyStorage, EnergyStorageComponent targetEnergyStorage,long extractTarget, Vector3i globalPosition, int x, int y, int z) {
+        long energy = 1;
+        if (extractTarget > 1 && !(energyStorage.getCurrentEnergyAmount()+1>=energyStorage.getMaxCapacity())) {
+            energy = targetEnergyStorage.extractEnergy(extractTarget);
+            HyLogger.atInfo().log("Extracted " + energy + "/" + extractTarget +
+                " |" + targetEnergyStorage.getCurrentEnergyAmount() + "| from storage" +
+                " at Block " + x + ", " + y + ", " + z + ", now at " +
+                targetEnergyStorage.getCurrentEnergyAmount() + "/" + targetEnergyStorage.getMaxCapacity());
+        }
+
+        long inserted = energyStorage.receiveEnergy(energy);
+        if (inserted < energy) {
+            var received = targetEnergyStorage.receiveEnergy(energy - inserted);
+            HyLogger.atInfo().log("TO MUCH:Inserted " + received + "/" + (energy - inserted) +
+                " |" + targetEnergyStorage.getCurrentEnergyAmount() + "| into storage" +
+                " at Block " + x + ", " + y + ", " + z + ", now at " +
+                targetEnergyStorage.getCurrentEnergyAmount() + "/" + targetEnergyStorage.getMaxCapacity());
+        }
+
+        if (inserted != 0) {
+            HyLogger.atInfo().log("Inserted " + inserted + "/" + energy +
+                " |" + energyStorage.getCurrentEnergyAmount() + "| into storage" +
+                " at Block " + globalPosition.x + ", " + globalPosition.y + ", " + globalPosition.z + ", now at " +
+                energyStorage.getCurrentEnergyAmount() + "/" + energyStorage.getMaxCapacity());
+        }
     }
 }

src/main/java/org/KaiFlo/SolarCell/Systems/EnergyTickingSystem.java

@@ -6,27 +6,38 @@ import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
 import com.hypixel.hytale.math.util.ChunkUtil;
 import com.hypixel.hytale.protocol.Vector3i;
 import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
+import com.hypixel.hytale.server.core.universe.Universe;
 import com.hypixel.hytale.server.core.universe.world.chunk.BlockComponentChunk;
 import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
 import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
 import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
 import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
+import org.KaiFlo.SolarCell.Helpers.BlockHelper;
 import org.checkerframework.checker.nullness.compatqual.NonNullDecl;
 import org.checkerframework.checker.nullness.compatqual.NullableDecl;
 
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static org.KaiFlo.SolarCell.Helpers.BlockHelper.HyLogger;
+
 public class EnergyTickingSystem extends EntityTickingSystem<ChunkStore> {
 
-    private final Map<List<ComponentType<ChunkStore, ?>>, ITickingSystem> componentsToTickingSystem = new HashMap<>();
+    private final Map<List<ComponentType<ChunkStore, ?>>, Map.Entry<ITickingSystem,Set<Ref<ChunkStore>>>> componentsToTickingSystem = new HashMap<>();
+    private long lastTime = 0L;
 
 
     @Override
     public void tick(float v, int archetypeIndex, @NonNullDecl ArchetypeChunk<ChunkStore> archetypeChunk, @NonNullDecl Store<ChunkStore> store, @NonNullDecl CommandBuffer<ChunkStore> commandBuffer) {
-
+        var currentTime = System.nanoTime();
+//        HyLogger.atInfo().log("V:"+v);
+        if ((currentTime/1_000_000_000.0)-0.1> lastTime/1_000_000_000.0){
+//            HyLogger.atInfo().log("Reset, currentTime: "+currentTime/1_000_000_000.0+", lastTime: "+lastTime/1_000_000_000.0);
+            lastTime = currentTime;
+            componentsToTickingSystem.forEach((_, iTickingSystemSetEntry) -> iTickingSystemSetEntry.getValue().clear());
+        }
         var blockSection = archetypeChunk.getComponent(archetypeIndex, BlockSection.getComponentType());
-        if (blockSection == null || blockSection.getTickingBlocksCount() != 0) return;
+        if (blockSection == null) return;
 
         var chunkSection = archetypeChunk.getComponent(archetypeIndex, ChunkSection.getComponentType());
         if (chunkSection == null) return;
@@ -38,9 +49,13 @@ public class EnergyTickingSystem extends EntityTickingSystem<ChunkStore> {
         var entrySet = componentsToTickingSystem.entrySet();
         var foundComponentTypes = new ArrayList<ComponentType<ChunkStore, ?>>();
 
-        blockSection.forEachTicking(blockComponentChunk, commandBuffer, chunkSection.getY(), (blockCompChunk, _, localX, localY, localZ, _) -> {
+        blockSection.forEachTicking(null, null, chunkSection.getY(), (_, _, localX, localY, localZ, _) -> {
-            var blockRef = blockCompChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+            var blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
-            if (blockRef == null) return BlockTickStrategy.IGNORED;
+            if (blockRef == null) {
+
+//                HyLogger.atInfo().log("Ignored block at "+localX+", "+localY+", "+localZ);
+                return BlockTickStrategy.CONTINUE;
+            }
 
             int globalX = localX + (worldChunk.getX() * 32);
             int globalZ = localZ + (worldChunk.getZ() * 32);
@@ -61,11 +76,13 @@ public class EnergyTickingSystem extends EntityTickingSystem<ChunkStore> {
             AtomicBoolean hasAny = new AtomicBoolean(false);
             entrySet.stream()
                 .filter(entry -> foundComponentTypes.containsAll(entry.getKey())).map(Map.Entry::getValue)
-                .forEach(tickingSystem -> {
+                .forEach(entry -> {
                     hasAny.set(true);
-                    tickingSystem.accept(foundComponents, archetype, globalPosition, blockCompChunk, commandBuffer, worldChunk.getWorld());
+                    entry.getKey().accept(blockRef,foundComponents, archetype, globalPosition, blockComponentChunk, commandBuffer, worldChunk.getWorld(),entry.getValue());
                 });
-            return hasAny.get() ? BlockTickStrategy.CONTINUE : BlockTickStrategy.IGNORED;
+
+//            HyLogger.atInfo().log("Continued block at "+localX+", "+localY+", "+localZ);
+            return BlockTickStrategy.CONTINUE;
         });
 
     }
@@ -77,7 +94,7 @@ public class EnergyTickingSystem extends EntityTickingSystem<ChunkStore> {
     }
 
     public EnergyTickingSystem withTickingSystemForComponentTypes(List<ComponentType<ChunkStore, ?>> componentTypes, ITickingSystem tickingSystem) {
-        componentsToTickingSystem.put(componentTypes, tickingSystem);
+        componentsToTickingSystem.put(componentTypes, Map.entry(tickingSystem, new HashSet<>()));
         return this;
     }
 }

src/main/java/org/KaiFlo/SolarCell/Systems/ITickingSystem.java

@@ -3,14 +3,16 @@ package org.KaiFlo.SolarCell.Systems;
 import com.hypixel.hytale.component.Archetype;
 import com.hypixel.hytale.component.CommandBuffer;
 import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.component.Ref;
 import com.hypixel.hytale.protocol.Vector3i;
 import com.hypixel.hytale.server.core.universe.world.World;
 import com.hypixel.hytale.server.core.universe.world.chunk.BlockComponentChunk;
 import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
 
 import java.util.List;
+import java.util.Set;
 
 public interface ITickingSystem {
 
-    void accept(List<Component<ChunkStore>> foundComponents, Archetype<ChunkStore> archetype, Vector3i globalPosition, BlockComponentChunk blockComponentChunk, CommandBuffer<ChunkStore> commandBuffer, World world);
+    void accept(Ref<ChunkStore> blockRef, List<Component<ChunkStore>> foundComponents, Archetype<ChunkStore> archetype, Vector3i globalPosition, BlockComponentChunk blockComponentChunk, CommandBuffer<ChunkStore> commandBuffer, World world, Set<Ref<ChunkStore>> blockRefs);
 }

src/main/resources/Server/Item/Items/SolarCell.json

@@ -26,7 +26,7 @@
         },
         "EnergySource": {
           "EnergyCapacity": -1,
-          "GeneratesPerTick": 1000
+          "GeneratesPerTick": 100
         }
       }
     },