Implemented all required Components

2026-02-07 17:58:13 +01:00
parent 9aea3a3e83
commit 837d7ceb02
10 changed files with 323 additions and 35 deletions
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergyConsumer/IEnergyConsumer.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergyConsumer/IEnergyConsumer.java
@@ -0,0 +1,11 @@
+package org.KaiFlo.SolarCell.Components.EnergyConsumer;
+
+public interface IEnergyConsumer {
+    float getWorkingCapabilityRatio();
+
+    void setWorkingCapabilityRatio(float workingCapabilityRatio);
+
+    long getConsumptionPerTick();
+
+    void setConsumptionPerTick(long consumptionPerTick);
+}
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergyConsumer/Implementations/EnergyConsumerComponent.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergyConsumer/Implementations/EnergyConsumerComponent.java
@@ -0,0 +1,71 @@
+package org.KaiFlo.SolarCell.Components.EnergyConsumer.Implementations;
+
+import com.hypixel.hytale.codec.Codec;
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+import com.hypixel.hytale.codec.validation.Validators;
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.logger.HytaleLogger;
+import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
+import org.KaiFlo.SolarCell.Components.EnergyConsumer.IEnergyConsumer;
+import org.KaiFlo.SolarCell.SolarCellPlugin;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+public class EnergyConsumerComponent implements Component<ChunkStore>, IEnergyConsumer {
+    public static final BuilderCodec<EnergyConsumerComponent> CODEC = BuilderCodec.builder(EnergyConsumerComponent.class, EnergyConsumerComponent::new)
+            .append(new KeyedCodec<>("ConsumptionPerTick", Codec.LONG),
+                    (component, value) -> component.consumptionPerTick = value,
+                    (component) -> component.consumptionPerTick
+            )
+            .addValidator(Validators.greaterThanOrEqual(0L))
+            .documentation("ConsumptionPerTick defines the Consumers ConsumptionPerTick")
+            .add()
+            .build();
+
+    private long consumptionPerTick;
+    private float workingCapabilityRatio;
+
+    private final HytaleLogger Logger = HytaleLogger.getLogger();
+
+    @Override
+    public float getWorkingCapabilityRatio() {
+        return workingCapabilityRatio;
+    }
+
+    @Override
+    public void setWorkingCapabilityRatio(float workingCapabilityRatio) {
+        this.workingCapabilityRatio = workingCapabilityRatio;
+    }
+
+    @Override
+    public long getConsumptionPerTick() {
+        return consumptionPerTick;
+    }
+
+    @Override
+    public void setConsumptionPerTick(long consumptionPerTick) {
+        this.consumptionPerTick = consumptionPerTick;
+    }
+
+    private EnergyConsumerComponent copyFrom(EnergyConsumerComponent other) {
+        this.consumptionPerTick = other.consumptionPerTick;
+        this.workingCapabilityRatio = other.workingCapabilityRatio;
+        return this;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<ChunkStore> clone() {
+        try {
+            super.clone();
+        } catch (CloneNotSupportedException e) {
+            Logger.atWarning().log("Cloning of " + this.getClass().getName() + " failed.");
+        }
+        return new EnergyConsumerComponent().copyFrom(this);
+    }
+
+    public static ComponentType<ChunkStore, EnergyConsumerComponent> getComponentType() {
+        return SolarCellPlugin.get().getEnergyConsumerComponentType();
+    }
+}
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergySource/AbstractEnergySource.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergySource/AbstractEnergySource.java
@@ -1,18 +0,0 @@
-package org.KaiFlo.SolarCell.Components.EnergySource;
-
-public class AbstractEnergySource implements  IEnergySource{
-    @Override
-    public boolean isEndless() {
-        return true;
-    }
-
-    @Override
-    public long getEnergyCapacity() {
-        return -1;
-    }
-
-    @Override
-    public long getEnergyRatePerTick() {
-        return 1;
-    }
-}
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergySource/IEnergySource.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergySource/IEnergySource.java
@@ -15,5 +15,11 @@ public interface IEnergySource {
    /**
     * @return The amount of energy the source produces per Tick
     */
-    long getEnergyRatePerTick();
+    long getGeneratesPerTick();
+
+    void setGeneratesPerTick(long generatesPerTick);
+
+    void setEndless(boolean endless);
+
+    void setEnergyCapacity(long energyCapacity);
 }
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergySource/Implementations/EnergySourceComponent.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergySource/Implementations/EnergySourceComponent.java
@@ -1,26 +1,47 @@
 package org.KaiFlo.SolarCell.Components.EnergySource.Implementations;

+import com.hypixel.hytale.codec.Codec;
+import com.hypixel.hytale.codec.KeyedCodec;
 import com.hypixel.hytale.codec.builder.BuilderCodec;
+import com.hypixel.hytale.codec.validation.Validators;
 import com.hypixel.hytale.component.Component;
 import com.hypixel.hytale.component.ComponentType;
 import com.hypixel.hytale.logger.HytaleLogger;
 import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
-import org.KaiFlo.SolarCell.Components.EnergySource.AbstractEnergySource;
+import org.KaiFlo.SolarCell.Components.EnergySource.IEnergySource;
 import org.KaiFlo.SolarCell.SolarCellPlugin;
 import org.checkerframework.checker.nullness.compatqual.NullableDecl;

-public class EnergySourceComponent extends AbstractEnergySource implements Component<ChunkStore> {
-    public static final BuilderCodec<EnergySourceComponent> CODEC = BuilderCodec.builder(EnergySourceComponent.class, EnergySourceComponent::new).build();
+public class EnergySourceComponent implements Component<ChunkStore>, IEnergySource {
+    @SuppressWarnings("unchecked")
+    public static final BuilderCodec<EnergySourceComponent> CODEC = BuilderCodec.builder(EnergySourceComponent.class, EnergySourceComponent::new)
+            .append(new KeyedCodec<>("GeneratesPerTick", Codec.LONG),
+                    (component, value) -> component.generatesPerTick = value,
+                    (component) -> component.generatesPerTick
+            )
+            .addValidator(Validators.greaterThanOrEqual(0L))
+            .documentation("GeneratesPerTick defines the Sources GeneratesPerTick")
+            .add()
+            .append(new KeyedCodec<>("EnergyCapacity", Codec.LONG),
+                    (component, value) -> component.energyCapacity = value,
+                    (component) -> component.energyCapacity
+            )
+            .addValidator(Validators.or(Validators.equal(-1L), Validators.greaterThanOrEqual(0L)))
+            .documentation("EnergyCapacity defines how long energy can be produced (Set to -1 if endless energy production)")
+            .add()
+            .build();

    private final HytaleLogger Logger = HytaleLogger.getLogger();
-    private long energyRatePerTick = 5;
+    private long generatesPerTick = 5;
+    private boolean isEndless = true;
+    private long energyCapacity = -1;

    public static ComponentType<ChunkStore, EnergySourceComponent> getComponentType() {
-        return SolarCellPlugin.get().getSolarCellComponentType();
+        return SolarCellPlugin.get().getEnergySourceComponentType();
    }

    private EnergySourceComponent copyFrom(EnergySourceComponent other) {
-        this.energyRatePerTick = other.energyRatePerTick;
+        this.generatesPerTick = other.generatesPerTick;
        return this;
    }

@@ -36,11 +57,32 @@ public class EnergySourceComponent extends AbstractEnergySource implements Compo
    }

    @Override
-    public long getEnergyRatePerTick() {
-        return energyRatePerTick;
+    public boolean isEndless() {
+        return isEndless;
    }

-    public void setEnergyRatePerTick(long energyRatePerTick) {
-        this.energyRatePerTick = energyRatePerTick;
+    @Override
+    public void setEndless(boolean endless) {
+        isEndless = endless;
+    }
+
+    @Override
+    public long getEnergyCapacity() {
+        return energyCapacity;
+    }
+
+    @Override
+    public void setEnergyCapacity(long energyCapacity) {
+        this.energyCapacity = energyCapacity;
+    }
+
+    @Override
+    public long getGeneratesPerTick() {
+        return generatesPerTick;
+    }
+
+    @Override
+    public void setGeneratesPerTick(long generatesPerTick) {
+        this.generatesPerTick = generatesPerTick;
    }
 }
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergyStorage/IEnergyStorage.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergyStorage/IEnergyStorage.java
@@ -0,0 +1,26 @@
+package org.KaiFlo.SolarCell.Components.EnergyStorage;
+
+public interface IEnergyStorage {
+
+    long getMaxCapacity();
+
+    void setMaxCapacity(long maxCapacity);
+
+    long getExtractEnergyPerTick();
+
+    void setExtractEnergyPerTick(long extractEnergyPerTick);
+
+    long getCurrentEnergyAmount();
+
+    void setCurrentEnergyAmount(long currentEnergyAmount);
+
+    long getReceiveEnergyPerTick();
+
+    void setReceiveEnergyPerTick(long receiveEnergyPerTick);
+
+    long extractEnergy(long requiredEnergy);
+
+    long receiveEnergy(long inputEnergy);
+
+    double getCurrentEnergyToCapacityRatio();
+}
--- a/src/main/java/org/KaiFlo/SolarCell/Components/EnergyStorage/Implementations/EnergyStorageComponent.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Components/EnergyStorage/Implementations/EnergyStorageComponent.java
@@ -0,0 +1,136 @@
+package org.KaiFlo.SolarCell.Components.EnergyStorage.Implementations;
+
+import com.hypixel.hytale.codec.Codec;
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+import com.hypixel.hytale.codec.validation.Validators;
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.logger.HytaleLogger;
+import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
+import org.KaiFlo.SolarCell.Components.EnergyStorage.IEnergyStorage;
+import org.KaiFlo.SolarCell.SolarCellPlugin;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+public class EnergyStorageComponent implements Component<ChunkStore>, IEnergyStorage {
+    public static final BuilderCodec<EnergyStorageComponent> CODEC = BuilderCodec.builder(EnergyStorageComponent.class, EnergyStorageComponent::new)
+            .append(new KeyedCodec<>("MaxCapacity", Codec.LONG),
+                    (component, value) -> component.maxCapacity = value,
+                    (component) -> component.maxCapacity
+            )
+            .addValidator(Validators.greaterThanOrEqual(0L))
+            .documentation("MaxCapacity defines the Storage MaxCapacity")
+            .add()
+            .append(new KeyedCodec<>("ExtractEnergyPerTick", Codec.LONG),
+                    (component, value) -> component.extractEnergyPerTick = value,
+                    (component) -> component.extractEnergyPerTick
+            )
+            .addValidator(Validators.greaterThanOrEqual(0L))
+            .documentation("ExtractEnergyPerTick defines the Storage ExtractEnergyPerTick")
+            .add()
+            .append(new KeyedCodec<>("ReceiveEnergyPerTick", Codec.LONG),
+                    (component, value) -> component.receiveEnergyPerTick = value,
+                    (component) -> component.receiveEnergyPerTick
+            )
+            .addValidator(Validators.greaterThanOrEqual(0L))
+            .documentation("ReceiveEnergyPerTick defines the Storage ReceiveEnergyPerTick")
+            .add()
+            .append(new KeyedCodec<>("CurrentEnergyAmount", Codec.LONG),
+                    (component, value) -> component.currentEnergyAmount = value,
+                    (component) -> component.currentEnergyAmount
+            )
+            .addValidator(Validators.greaterThanOrEqual(0L))
+            .documentation("CurrentEnergyAmount defines the Storage CurrentEnergyAmount")
+            .add()
+            .build();
+
+    private final HytaleLogger Logger = HytaleLogger.getLogger();
+
+    private long maxCapacity;
+    private long extractEnergyPerTick;
+    private long currentEnergyAmount;
+    private long receiveEnergyPerTick;
+
+    @Override
+    public long getMaxCapacity() {
+        return maxCapacity;
+    }
+
+    @Override
+    public void setMaxCapacity(long maxCapacity) {
+        this.maxCapacity = maxCapacity;
+    }
+
+    @Override
+    public long getExtractEnergyPerTick() {
+        return extractEnergyPerTick;
+    }
+
+    @Override
+    public void setExtractEnergyPerTick(long extractEnergyPerTick) {
+        this.extractEnergyPerTick = extractEnergyPerTick;
+    }
+
+    @Override
+    public long getCurrentEnergyAmount() {
+        return currentEnergyAmount;
+    }
+
+    @Override
+    public void setCurrentEnergyAmount(long currentEnergyAmount) {
+        this.currentEnergyAmount = currentEnergyAmount;
+    }
+
+    @Override
+    public long getReceiveEnergyPerTick() {
+        return receiveEnergyPerTick;
+    }
+
+    @Override
+    public void setReceiveEnergyPerTick(long receiveEnergyPerTick) {
+        this.receiveEnergyPerTick = receiveEnergyPerTick;
+    }
+
+    @Override
+    public double getCurrentEnergyToCapacityRatio(){
+        return (double) currentEnergyAmount / maxCapacity;
+    }
+
+    @Override
+    public long extractEnergy(long requiredEnergy) {
+        var extractedEnergy = Math.min(currentEnergyAmount, Math.min(requiredEnergy, extractEnergyPerTick));
+        currentEnergyAmount -= extractedEnergy;
+        return extractedEnergy;
+    }
+
+    @Override
+    public long receiveEnergy(long inputEnergy) {
+        var receivedEnergy = Math.min(maxCapacity - currentEnergyAmount, Math.min(inputEnergy, receiveEnergyPerTick));
+        currentEnergyAmount += receivedEnergy;
+        return receivedEnergy;
+    }
+
+    private EnergyStorageComponent copyFrom(EnergyStorageComponent other) {
+        this.maxCapacity = other.maxCapacity;
+        this.currentEnergyAmount = other.currentEnergyAmount;
+        this.receiveEnergyPerTick = other.receiveEnergyPerTick;
+        this.extractEnergyPerTick = other.extractEnergyPerTick;
+        return this;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<ChunkStore> clone() {
+        try {
+            super.clone();
+        } catch (CloneNotSupportedException e) {
+            Logger.atWarning().log("Cloning of " + this.getClass().getName() + " failed.");
+        }
+        return new EnergyStorageComponent().copyFrom(this);
+    }
+
+    public static ComponentType<ChunkStore, EnergyStorageComponent> getComponentType() {
+        return SolarCellPlugin.get().getEnergyStorageComponentType();
+    }
+
+}
--- a/src/main/java/org/KaiFlo/SolarCell/SolarCellPlugin.java
+++ b/src/main/java/org/KaiFlo/SolarCell/SolarCellPlugin.java
@@ -6,7 +6,9 @@ import com.hypixel.hytale.server.core.plugin.JavaPlugin;
 import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
 import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
 import org.KaiFlo.SolarCell.Commands.ExampleCommand;
+import org.KaiFlo.SolarCell.Components.EnergyConsumer.Implementations.EnergyConsumerComponent;
 import org.KaiFlo.SolarCell.Components.EnergySource.Implementations.EnergySourceComponent;
+import org.KaiFlo.SolarCell.Components.EnergyStorage.Implementations.EnergyStorageComponent;
 import org.KaiFlo.SolarCell.Systems.EnergySource.EnergySourceInitializerSystem;
 import org.KaiFlo.SolarCell.Systems.EnergySource.EnergyProducerTickingSystem;

@@ -22,7 +24,9 @@ public class SolarCellPlugin extends JavaPlugin {

    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();

-    private ComponentType<ChunkStore, EnergySourceComponent> solarCellComponentType;
+    private ComponentType<ChunkStore, EnergySourceComponent> energySourceComponentType;
+    private ComponentType<ChunkStore, EnergyConsumerComponent> energyConsumerComponentType;
+    private ComponentType<ChunkStore, EnergyStorageComponent> energyStorageComponentType;

    public SolarCellPlugin(@Nonnull JavaPluginInit init) {
        super(init);
@@ -34,7 +38,9 @@ public class SolarCellPlugin extends JavaPlugin {
        instance = this;
        LOGGER.atInfo().log("Setting up plugin " + this.getName());

-        solarCellComponentType = this.getChunkStoreRegistry().registerComponent(EnergySourceComponent.class, "SolarCell", EnergySourceComponent.CODEC);
+        energySourceComponentType = this.getChunkStoreRegistry().registerComponent(EnergySourceComponent.class, "EnergySource", EnergySourceComponent.CODEC);
+        energyConsumerComponentType = this.getChunkStoreRegistry().registerComponent(EnergyConsumerComponent.class, "EnergyConsumer", EnergyConsumerComponent.CODEC);
+        energyStorageComponentType = this.getChunkStoreRegistry().registerComponent(EnergyStorageComponent.class, "EnergyStorage", EnergyStorageComponent.CODEC);

        this.getCommandRegistry().registerCommand(new ExampleCommand(this.getName(), this.getManifest().getVersion().toString()));

@@ -43,7 +49,15 @@ public class SolarCellPlugin extends JavaPlugin {

    }

-    public ComponentType<ChunkStore, EnergySourceComponent> getSolarCellComponentType() {
-        return solarCellComponentType;
+    public ComponentType<ChunkStore, EnergySourceComponent> getEnergySourceComponentType() {
+        return energySourceComponentType;
+    }
+
+    public ComponentType<ChunkStore, EnergyConsumerComponent> getEnergyConsumerComponentType() {
+        return energyConsumerComponentType;
+    }
+
+    public ComponentType<ChunkStore, EnergyStorageComponent> getEnergyStorageComponentType() {
+        return energyStorageComponentType;
    }
 } 
--- a/src/main/java/org/KaiFlo/SolarCell/Systems/EnergySource/EnergyProducerTickingSystem.java
+++ b/src/main/java/org/KaiFlo/SolarCell/Systems/EnergySource/EnergyProducerTickingSystem.java
@@ -54,7 +54,7 @@ public class EnergyProducerTickingSystem extends EntityTickingSystem<ChunkStore>
                        var targetEnergyStorage = commandBuffer.getComponent(targetRef, EnergyStorageBlockComponent.getComponentType());
                        if (targetEnergySource == null || targetEnergyStorage == null) return;

-                        var energy = targetEnergyStorage.extractEnergy(targetEnergySource.getEnergyRatePerTick(), false);
+                        var energy = targetEnergyStorage.extractEnergy(targetEnergySource.getGeneratesPerTick(), false);
                        var inserted = thisEnergyStorageComponent.receiveEnergy(energy, false);
                        LOGGER.atInfo().log("Inserted " + inserted + "/" + energy + " |" + targetEnergyStorage.getEnergyStored() + "| into storage" +
                                " at Block " + globalX + ", " + localY + ", " + globalZ + ", " +
--- a/src/main/resources/Common/Items/SolarPanels/SolarCell1.bbmodel
+++ b/src/main/resources/Common/Items/SolarPanels/SolarCell1.bbmodel