Reworked Energy Providers (Generators)

CHANGELOG.md

@@ -22,6 +22,10 @@
 
 ## Release Candidate 15 (TBD)
 
+#### Changes
+* Refactored and reworked the Generator API
+* Small performance improvements to Energy networks
+
 ## Release Candidate 14 (12 Jul 2020)
 
 #### Additions

src/main/java/io/github/thebusybiscuit/slimefun4/api/ErrorReport.java

@@ -17,6 +17,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.plugin.Plugin;
 
+import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetProvider;
 import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
 import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
@@ -115,7 +116,7 @@ public class ErrorReport {
                 stream.println();
             }
             
-            if (item.getEnergyTicker() != null) {
+            if (item instanceof EnergyNetProvider) {
                 stream.println("Ticker-Info:");
                 stream.println("  Type: Indirect (Energy Network)");
                 stream.println();

src/main/java/io/github/thebusybiscuit/slimefun4/core/attributes/EnergyNetProvider.java

@@ -0,0 +1,62 @@
+package io.github.thebusybiscuit.slimefun4.core.attributes;
+
+import org.bukkit.Location;
+
+import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNet;
+import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
+import io.github.thebusybiscuit.slimefun4.implementation.items.electric.AbstractEnergyProvider;
+import io.github.thebusybiscuit.slimefun4.implementation.items.electric.reactors.Reactor;
+import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
+import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AGenerator;
+
+/**
+ * An {@link EnergyNetProvider} is an extension of {@link EnergyNetComponent} which provides
+ * energy to an {@link EnergyNet}.
+ * It must be implemented on any Generator or {@link Reactor}.
+ * 
+ * @author TheBusyBiscuit
+ * 
+ * @see EnergyNet
+ * @see EnergyNetComponent
+ * @see AbstractEnergyProvider
+ * @see AGenerator
+ * @see Reactor
+ *
+ */
+public interface EnergyNetProvider extends EnergyNetComponent {
+
+    @Override
+    default EnergyNetComponentType getEnergyComponentType() {
+        return EnergyNetComponentType.GENERATOR;
+    }
+
+    /**
+     * This method returns how much energy this {@link EnergyNetProvider} provides to the {@link EnergyNet}.
+     * We call this method on every tick, so make sure to keep it light and fast.
+     * Stored energy does not have to be handled in here.
+     * 
+     * @param l
+     *            The {@link Location} of this {@link EnergyNetProvider}
+     * @param data
+     *            The stored block data
+     * 
+     * @return The generated output energy of this {@link EnergyNetProvider}.
+     */
+    int getGeneratedOutput(Location l, Config data);
+
+    /**
+     * This method returns whether the given {@link Location} is going to explode on the
+     * next tick.
+     * 
+     * @param l
+     *            The {@link Location} of this {@link EnergyNetProvider}
+     * @param data
+     *            The stored block data
+     * 
+     * @return Whether or not this {@link Location} will explode.
+     */
+    default boolean willExplode(Location l, Config data) {
+        return false;
+    }
+
+}

src/main/java/io/github/thebusybiscuit/slimefun4/core/networks/energy/EnergyNet.java

@@ -15,6 +15,7 @@ import io.github.thebusybiscuit.slimefun4.api.ErrorReport;
 import io.github.thebusybiscuit.slimefun4.api.network.Network;
 import io.github.thebusybiscuit.slimefun4.api.network.NetworkComponent;
 import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
+import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetProvider;
 import io.github.thebusybiscuit.slimefun4.implementation.SlimefunItems;
 import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
 import io.github.thebusybiscuit.slimefun4.implementation.items.electric.reactors.Reactor;
@@ -143,10 +144,9 @@ public class EnergyNet extends Network {
             SimpleHologram.update(b, "&4No Energy Network found");
         }
         else {
-            double supply = DoubleHandler.fixDouble(tickAllGenerators(timestamp::getAndAdd) + tickAllCapacitors());
+            int supply = tickAllGenerators(timestamp::getAndAdd) + tickAllCapacitors();
-            double demand = 0;
+            int remainingEnergy = supply;
-
+            int demand = 0;
-            int availableEnergy = (int) supply;
 
             for (Location machine : consumers) {
                 int capacity = ChargableBlock.getMaxCharge(machine);
@@ -156,20 +156,20 @@ public class EnergyNet extends Network {
                     int availableSpace = capacity - charge;
                     demand += availableSpace;
 
-                    if (availableEnergy > 0) {
+                    if (remainingEnergy > 0) {
-                        if (availableEnergy > availableSpace) {
+                        if (remainingEnergy > availableSpace) {
                             ChargableBlock.setUnsafeCharge(machine, capacity, false);
-                            availableEnergy -= availableSpace;
+                            remainingEnergy -= availableSpace;
                         }
                         else {
-                            ChargableBlock.setUnsafeCharge(machine, charge + availableEnergy, false);
+                            ChargableBlock.setUnsafeCharge(machine, charge + remainingEnergy, false);
-                            availableEnergy = 0;
+                            remainingEnergy = 0;
                         }
                     }
                 }
             }
 
-            storeExcessEnergy(availableEnergy);
+            storeExcessEnergy(remainingEnergy);
             updateHologram(b, supply, demand);
         }
 
@@ -217,8 +217,8 @@ public class EnergyNet extends Network {
         }
     }
 
-    private double tickAllGenerators(LongConsumer timeCallback) {
+    private int tickAllGenerators(LongConsumer timeCallback) {
-        double supply = 0;
+        int supply = 0;
         Set<Location> exploded = new HashSet<>();
 
         for (Location source : generators) {
@@ -226,8 +226,46 @@ public class EnergyNet extends Network {
             Config config = BlockStorage.getLocationInfo(source);
             SlimefunItem item = SlimefunItem.getByID(config.getString("id"));
 
-            if (item != null) {
+            if (item instanceof EnergyNetProvider) {
                 try {
+                    EnergyNetProvider generator = (EnergyNetProvider) item;
+                    int energy = generator.getGeneratedOutput(source, config);
+
+                    if (generator.getCapacity() > 0) {
+                        String charge = config.getString("energy-charge");
+
+                        if (charge != null) {
+                            energy += Integer.parseInt(charge);
+                        }
+                    }
+
+                    if (generator.willExplode(source, config)) {
+                        exploded.add(source);
+                        BlockStorage.clearBlockInfo(source);
+                        Reactor.processing.remove(source);
+                        Reactor.progress.remove(source);
+
+                        Slimefun.runSync(() -> {
+                            source.getBlock().setType(Material.LAVA);
+                            source.getWorld().createExplosion(source, 0F, false);
+                        });
+                    }
+                    else {
+                        supply += energy;
+                    }
+                }
+                catch (Exception | LinkageError t) {
+                    exploded.add(source);
+                    new ErrorReport(t, source, item);
+                }
+
+                long time = SlimefunPlugin.getProfiler().closeEntry(source, item, timestamp);
+                timeCallback.accept(time);
+            }
+            else if (item != null) {
+                try {
+                    // This will be removed very very soon
+                    // It is only here for backwards compatibility
                     GeneratorTicker generator = item.getEnergyTicker();
 
                     if (generator != null) {
@@ -267,12 +305,11 @@ public class EnergyNet extends Network {
         }
 
         generators.removeAll(exploded);
-
         return supply;
     }
 
-    private double tickAllCapacitors() {
+    private int tickAllCapacitors() {
-        double supply = 0;
+        int supply = 0;
 
         for (Location capacitor : storage) {
             supply += ChargableBlock.getCharge(capacitor);

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/AbstractEnergyProvider.java

@@ -5,17 +5,19 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
+import org.bukkit.Location;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 
 import io.github.thebusybiscuit.cscorelib2.chat.ChatColors;
 import io.github.thebusybiscuit.cscorelib2.math.DoubleHandler;
-import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
+import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetProvider;
 import io.github.thebusybiscuit.slimefun4.core.attributes.RecipeDisplayItem;
 import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
 import io.github.thebusybiscuit.slimefun4.implementation.items.electric.reactors.Reactor;
 import io.github.thebusybiscuit.slimefun4.utils.NumberUtils;
+import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
 import me.mrCookieSlime.Slimefun.Lists.RecipeType;
 import me.mrCookieSlime.Slimefun.Objects.Category;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
@@ -34,7 +36,7 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
  * @see Reactor
  *
  */
-public abstract class AbstractEnergyProvider extends SlimefunItem implements InventoryBlock, RecipeDisplayItem, EnergyNetComponent {
+public abstract class AbstractEnergyProvider extends SlimefunItem implements InventoryBlock, RecipeDisplayItem, EnergyNetProvider {
 
     protected final Set<MachineFuel> fuelTypes = new HashSet<>();
 
@@ -79,13 +81,48 @@ public abstract class AbstractEnergyProvider extends SlimefunItem implements Inv
         return EnergyNetComponentType.GENERATOR;
     }
 
-    protected abstract GeneratorTicker onTick();
+    /**
+     * @deprecated Please implement the methods
+     *             {@link #getGeneratedOutput(org.bukkit.Location, me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config)}
+     *             and {@link #willExplode(org.bukkit.Location, me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config)}
+     *             instead
+     * 
+     * @return A {@link GeneratorTicker}
+     */
+    @Deprecated
+    protected GeneratorTicker onTick() {
+        return null;
+    }
+
+    @Override
+    public int getGeneratedOutput(Location l, Config data) {
+        if (generatorTicker != null) {
+            return (int) generatorTicker.generateEnergy(l, this, data);
+        }
+        else {
+            return 0;
+        }
+    }
+
+    @Override
+    public boolean willExplode(Location l, Config data) {
+        if (generatorTicker != null) {
+            return generatorTicker.explode(l);
+        }
+        else {
+            return false;
+        }
+    }
 
     @Override
     public void preRegister() {
         super.preRegister();
 
-        addItemHandler(onTick());
+        GeneratorTicker ticker = onTick();
+
+        if (ticker != null) {
+            addItemHandler(ticker);
+        }
     }
 
     public void registerFuel(MachineFuel fuel) {

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/generators/SolarGenerator.java

@@ -6,23 +6,25 @@ import org.bukkit.World.Environment;
 import org.bukkit.inventory.ItemStack;
 
 import io.github.thebusybiscuit.slimefun4.api.events.PlayerRightClickEvent;
-import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
+import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetProvider;
 import io.github.thebusybiscuit.slimefun4.core.handlers.BlockUseHandler;
 import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
-import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
 import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
 import me.mrCookieSlime.Slimefun.Lists.RecipeType;
 import me.mrCookieSlime.Slimefun.Objects.Category;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
-import me.mrCookieSlime.Slimefun.Objects.handlers.GeneratorTicker;
 import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
 
-public abstract class SolarGenerator extends SimpleSlimefunItem<GeneratorTicker> implements EnergyNetComponent {
+public class SolarGenerator extends SlimefunItem implements EnergyNetProvider {
 
-    private static final int DEFAULT_NIGHT_ENERGY = 0;
+    private final int dayEnergy;
+    private final int nightEnergy;
 
-    public SolarGenerator(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
+    public SolarGenerator(Category category, int dayEnergy, int nightEnergy, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
         super(category, item, recipeType, recipe);
+
+        this.dayEnergy = dayEnergy;
+        this.nightEnergy = nightEnergy;
     }
 
     /**
@@ -31,19 +33,18 @@ public abstract class SolarGenerator extends SimpleSlimefunItem<GeneratorTicker>
      * 
      * @return The amount of energy generated at daylight
      */
-    public abstract double getDayEnergy();
+    public int getDayEnergy() {
+        return dayEnergy;
+    }
 
     /**
      * This method returns the amount of energy that this {@link SolarGenerator}
      * produces during the night.
      * 
-     * This is 0 by default.
-     * 
      * @return The amount of energy generated at night time
      */
-    public double getNightEnergy() {
+    public int getNightEnergy() {
-        // Override this as necessary for highly advanced Solar Generators
+        return nightEnergy;
-        return DEFAULT_NIGHT_ENERGY;
     }
 
     @Override
@@ -57,40 +58,29 @@ public abstract class SolarGenerator extends SimpleSlimefunItem<GeneratorTicker>
     }
 
     @Override
-    public GeneratorTicker getItemHandler() {
+    public int getGeneratedOutput(Location l, Config data) {
-        return new GeneratorTicker() {
+        World world = l.getWorld();
 
-            @Override
+        if (world.getEnvironment() != Environment.NORMAL) {
-            public double generateEnergy(Location l, SlimefunItem item, Config data) {
+            return 0;
-                World world = l.getWorld();
+        }
 
-                if (world.getEnvironment() != Environment.NORMAL) {
+        boolean isDaytime = isDaytime(world);
-                    return 0;
-                }
 
-                boolean isDaytime = isDaytime(world);
+        // Performance optimization for daytime-only solar generators
+        if (!isDaytime && getNightEnergy() < 0.1) {
+            return 0;
+        }
 
-                // Performance optimization for daytime-only solar generators
+        if (!world.isChunkLoaded(l.getBlockX() >> 4, l.getBlockZ() >> 4) || l.getBlock().getLightFromSky() != 15) {
-                if (!isDaytime && getNightEnergy() < 0.1) {
+            return 0;
-                    return 0;
+        }
-                }
 
-                if (!world.isChunkLoaded(l.getBlockX() >> 4, l.getBlockZ() >> 4) || l.getBlock().getLightFromSky() != 15) {
+        if (isDaytime) {
-                    return 0;
+            return getDayEnergy();
-                }
+        }
 
-                if (isDaytime) {
+        return getNightEnergy();
-                    return getDayEnergy();
-                }
-
-                return getNightEnergy();
-            }
-
-            @Override
-            public boolean explode(Location l) {
-                return false;
-            }
-        };
     }
 
     /**

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/reactors/Reactor.java

@@ -29,14 +29,11 @@ import io.github.thebusybiscuit.slimefun4.utils.holograms.SimpleHologram;
 import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
 import me.mrCookieSlime.Slimefun.Lists.RecipeType;
 import me.mrCookieSlime.Slimefun.Objects.Category;
-import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AGenerator;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineFuel;
-import me.mrCookieSlime.Slimefun.Objects.handlers.GeneratorTicker;
 import me.mrCookieSlime.Slimefun.api.BlockStorage;
 import me.mrCookieSlime.Slimefun.api.Slimefun;
 import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
-import me.mrCookieSlime.Slimefun.api.energy.ChargableBlock;
 import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu;
 import me.mrCookieSlime.Slimefun.api.inventory.BlockMenuPreset;
 import me.mrCookieSlime.Slimefun.api.item_transport.ItemTransportFlow;
@@ -49,7 +46,7 @@ import me.mrCookieSlime.Slimefun.api.item_transport.ItemTransportFlow;
  * @author AlexLander123
  * @author TheBusyBiscuit
  * 
- * @see AGenerator
+ * @see AGeneratoro
  * @see NuclearReactor
  * @see NetherStarReactor
  *
@@ -72,6 +69,8 @@ public abstract class Reactor extends AbstractEnergyProvider {
     // No coolant border
     private static final int[] border_4 = { 25, 34, 43 };
 
+    private final Set<Location> explosionsQueue = new HashSet<>();
+
     public Reactor(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
         super(category, item, recipeType, recipe);
 
@@ -261,89 +260,85 @@ public abstract class Reactor extends AbstractEnergyProvider {
     }
 
     @Override
-    protected GeneratorTicker onTick() {
+    public int getGeneratedOutput(Location l, Config data) {
-        return new GeneratorTicker() {
+        BlockMenu inv = BlockStorage.getInventory(l);
+        BlockMenu accessPort = getAccessPort(l);
 
-            private final Set<Location> explosionsQueue = new HashSet<>();
+        if (isProcessing(l)) {
+            extraTick(l);
+            int timeleft = progress.get(l);
 
-            @Override
+            if (timeleft > 0) {
-            public double generateEnergy(Location l, SlimefunItem sf, Config data) {
+                int produced = getEnergyProduction();
-                BlockMenu inv = BlockStorage.getInventory(l);
+                int charge = 0;
-                BlockMenu accessPort = getAccessPort(l);
-                int charge = ChargableBlock.getCharge(l);
 
-                if (isProcessing(l)) {
+                if (data.contains("energy-charge")) {
-                    extraTick(l);
+                    charge = Integer.parseInt(data.getString("energy-charge"));
-                    int timeleft = progress.get(l);
+                }
 
-                    if (timeleft > 0) {
+                int space = getCapacity() - charge;
-                        int produced = getEnergyProduction();
-                        int space = getCapacity() - charge;
 
-                        if (space >= produced || !ReactorMode.GENERATOR.toString().equals(BlockStorage.getLocationInfo(l, MODE))) {
+                if (space >= produced || !ReactorMode.GENERATOR.toString().equals(BlockStorage.getLocationInfo(l, MODE))) {
-                            progress.put(l, timeleft - 1);
+                    progress.put(l, timeleft - 1);
-                            checkForWaterBlocks(l);
+                    checkForWaterBlocks(l);
 
-                            ChestMenuUtils.updateProgressbar(inv, 22, timeleft, processing.get(l).getTicks(), getProgressBar());
+                    ChestMenuUtils.updateProgressbar(inv, 22, timeleft, processing.get(l).getTicks(), getProgressBar());
 
-                            if (needsCooling() && !hasEnoughCoolant(l, inv, accessPort, timeleft)) {
+                    if (needsCooling() && !hasEnoughCoolant(l, inv, accessPort, timeleft)) {
-                                explosionsQueue.add(l);
+                        explosionsQueue.add(l);
-                                return 0;
+                        return 0;
-                            }
-                        }
-
-                        if (space >= produced) {
-                            ChargableBlock.addCharge(l, getEnergyProduction());
-                            return (double) (charge + getEnergyProduction());
-                        }
-                        else {
-                            return charge;
-                        }
-                    }
-                    else {
-                        createByproduct(l, inv, accessPort);
-                        return charge;
                     }
                 }
+
+                if (space >= produced) {
+                    return getEnergyProduction();
+                }
                 else {
-                    burnNextFuel(l, inv, accessPort);
+                    return 0;
-                    return charge;
                 }
             }
-
+            else {
-            @Override
+                createByproduct(l, inv, accessPort);
-            public boolean explode(Location l) {
+                return 0;
-                boolean explosion = explosionsQueue.contains(l);
-
-                if (explosion) {
-                    Slimefun.runSync(() -> {
-                        ReactorExplodeEvent event = new ReactorExplodeEvent(l, Reactor.this);
-                        Bukkit.getPluginManager().callEvent(event);
-
-                        BlockStorage.getInventory(l).close();
-                        SimpleHologram.remove(l.getBlock());
-                    });
-
-                    explosionsQueue.remove(l);
-                    processing.remove(l);
-                    progress.remove(l);
-                }
-
-                return explosion;
             }
+        }
+        else {
+            burnNextFuel(l, inv, accessPort);
+            return 0;
+        }
+    }
 
-            private void checkForWaterBlocks(Location l) {
+    @Override
-                Slimefun.runSync(() -> {
+    public boolean willExplode(Location l, Config data) {
-                    // We will pick a surrounding block at random and see if this is water.
+        boolean explosion = explosionsQueue.contains(l);
-                    // If it isn't, then we will make it explode.
-                    BlockFace randomNeighbour = WATER_BLOCKS[ThreadLocalRandom.current().nextInt(WATER_BLOCKS.length)];
 
-                    if (l.getBlock().getRelative(randomNeighbour).getType() != Material.WATER) {
+        if (explosion) {
-                        explosionsQueue.add(l);
+            Slimefun.runSync(() -> {
-                    }
+                ReactorExplodeEvent event = new ReactorExplodeEvent(l, Reactor.this);
-                });
+                Bukkit.getPluginManager().callEvent(event);
+
+                BlockStorage.getInventory(l).close();
+                SimpleHologram.remove(l.getBlock());
+            });
+
+            explosionsQueue.remove(l);
+            processing.remove(l);
+            progress.remove(l);
+        }
+
+        return explosion;
+    }
+
+    private void checkForWaterBlocks(Location l) {
+        Slimefun.runSync(() -> {
+            // We will pick a surrounding block at random and see if this is water.
+            // If it isn't, then we will make it explode.
+            BlockFace randomNeighbour = WATER_BLOCKS[ThreadLocalRandom.current().nextInt(WATER_BLOCKS.length)];
+
+            if (l.getBlock().getRelative(randomNeighbour).getType() != Material.WATER) {
+                explosionsQueue.add(l);
             }
-        };
+        });
     }
 
     private void createByproduct(Location l, BlockMenu inv, BlockMenu accessPort) {

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/setup/SlimefunItemSetup.java

@@ -1495,50 +1495,21 @@ public final class SlimefunItemSetup {
 		new ItemStack[] {SlimefunItems.CARBONADO, SlimefunItems.REDSTONE_ALLOY, SlimefunItems.CARBONADO, new ItemStack(Material.REDSTONE), SlimefunItems.LARGE_CAPACITOR, new ItemStack(Material.REDSTONE), SlimefunItems.CARBONADO, SlimefunItems.REDSTONE_ALLOY, SlimefunItems.CARBONADO})
 		.register(plugin);
 
-		new SolarGenerator(categories.electricity, SlimefunItems.SOLAR_GENERATOR, RecipeType.ENHANCED_CRAFTING_TABLE,
+		new SolarGenerator(categories.electricity, 2, 0, SlimefunItems.SOLAR_GENERATOR, RecipeType.ENHANCED_CRAFTING_TABLE,
-		new ItemStack[] {SlimefunItems.SOLAR_PANEL, SlimefunItems.SOLAR_PANEL, SlimefunItems.SOLAR_PANEL, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.ELECTRIC_MOTOR, SlimefunItems.ALUMINUM_INGOT, null, SlimefunItems.ALUMINUM_INGOT, null}) {
+		new ItemStack[] {SlimefunItems.SOLAR_PANEL, SlimefunItems.SOLAR_PANEL, SlimefunItems.SOLAR_PANEL, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.ELECTRIC_MOTOR, SlimefunItems.ALUMINUM_INGOT, null, SlimefunItems.ALUMINUM_INGOT, null})
+		.register(plugin);
 
-			@Override
+		new SolarGenerator(categories.electricity, 8, 0, SlimefunItems.SOLAR_GENERATOR_2, RecipeType.ENHANCED_CRAFTING_TABLE,
-			public double getDayEnergy() {
+		new ItemStack[] {SlimefunItems.SOLAR_GENERATOR, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR, SlimefunItems.ALUMINUM_INGOT, new ItemStack(Material.REDSTONE), SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR})
-				return 2;
+		.register(plugin);
-			}
-			
-		}.register(plugin);
 
-		new SolarGenerator(categories.electricity, SlimefunItems.SOLAR_GENERATOR_2, RecipeType.ENHANCED_CRAFTING_TABLE,
+		new SolarGenerator(categories.electricity, 32, 0, SlimefunItems.SOLAR_GENERATOR_3, RecipeType.ENHANCED_CRAFTING_TABLE,
-		new ItemStack[] {SlimefunItems.SOLAR_GENERATOR, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR, SlimefunItems.ALUMINUM_INGOT, new ItemStack(Material.REDSTONE), SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR}) {
+		new ItemStack[] {SlimefunItems.SOLAR_GENERATOR_2, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR_2, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.CARBONADO, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR_2, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR_2})
+		.register(plugin);
 
-			@Override
+		new SolarGenerator(categories.electricity, 128, 64, SlimefunItems.SOLAR_GENERATOR_4, RecipeType.ENHANCED_CRAFTING_TABLE,
-			public double getDayEnergy() {
+		new ItemStack[] {SlimefunItems.SOLAR_GENERATOR_3, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.SOLAR_GENERATOR_3, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.ELECTRO_MAGNET, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.SOLAR_GENERATOR_3, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.SOLAR_GENERATOR_3})
-				return 8;
+		.register(plugin);
-			}
-			
-		}.register(plugin);
-
-		new SolarGenerator(categories.electricity, SlimefunItems.SOLAR_GENERATOR_3, RecipeType.ENHANCED_CRAFTING_TABLE,
-		new ItemStack[] {SlimefunItems.SOLAR_GENERATOR_2, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR_2, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.CARBONADO, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR_2, SlimefunItems.ALUMINUM_INGOT, SlimefunItems.SOLAR_GENERATOR_2}) {
-
-			@Override
-			public double getDayEnergy() {
-				return 32;
-			}
-			
-		}.register(plugin);
-
-		new SolarGenerator(categories.electricity, SlimefunItems.SOLAR_GENERATOR_4, RecipeType.ENHANCED_CRAFTING_TABLE,
-		new ItemStack[] {SlimefunItems.SOLAR_GENERATOR_3, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.SOLAR_GENERATOR_3, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.ELECTRO_MAGNET, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.SOLAR_GENERATOR_3, SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.SOLAR_GENERATOR_3}) {
-
-			@Override
-			public double getDayEnergy() {
-				return 128;
-			}
-
-			@Override
-			public double getNightEnergy() {
-				return 64;
-			}
-			
-		}.register(plugin);
 		
 		new ChargingBench(categories.electricity, SlimefunItems.CHARGING_BENCH, RecipeType.ENHANCED_CRAFTING_TABLE,
 		new ItemStack[] {null, SlimefunItems.ELECTRO_MAGNET, null, SlimefunItems.BATTERY, new ItemStack(Material.CRAFTING_TABLE), SlimefunItems.BATTERY, null, SlimefunItems.SMALL_CAPACITOR, null})

src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunItem.java

@@ -28,6 +28,7 @@ import io.github.thebusybiscuit.slimefun4.api.exceptions.WrongItemStackException
 import io.github.thebusybiscuit.slimefun4.api.items.ItemSetting;
 import io.github.thebusybiscuit.slimefun4.api.items.ItemState;
 import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
+import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetProvider;
 import io.github.thebusybiscuit.slimefun4.core.attributes.Placeable;
 import io.github.thebusybiscuit.slimefun4.core.attributes.Radioactive;
 import io.github.thebusybiscuit.slimefun4.core.attributes.Rechargeable;
@@ -74,7 +75,7 @@ public class SlimefunItem implements Placeable {
 
     private boolean ticking = false;
     private BlockTicker blockTicker;
-    private GeneratorTicker generatorTicker;
+    protected GeneratorTicker generatorTicker;
 
     /**
      * This creates a new {@link SlimefunItem} from the given arguments.
@@ -320,7 +321,11 @@ public class SlimefunItem implements Placeable {
         return blockTicker;
     }
 
-    // We should maybe refactor this and move it to a subclass
+    /**
+     * @deprecated The interface {@link EnergyNetProvider} should be implemented instead
+     * @return A {@link GeneratorTicker}
+     */
+    @Deprecated
     public GeneratorTicker getEnergyTicker() {
         return generatorTicker;
     }

src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AGenerator.java

@@ -23,8 +23,6 @@ import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu.AdvancedMenu
 import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ClickAction;
 import me.mrCookieSlime.Slimefun.Lists.RecipeType;
 import me.mrCookieSlime.Slimefun.Objects.Category;
-import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
-import me.mrCookieSlime.Slimefun.Objects.handlers.GeneratorTicker;
 import me.mrCookieSlime.Slimefun.api.BlockStorage;
 import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
 import me.mrCookieSlime.Slimefun.api.energy.ChargableBlock;
@@ -58,8 +56,12 @@ public abstract class AGenerator extends AbstractEnergyProvider {
 
             @Override
             public int[] getSlotsAccessedByItemTransport(ItemTransportFlow flow) {
-                if (flow == ItemTransportFlow.INSERT) return getInputSlots();
+                if (flow == ItemTransportFlow.INSERT) {
-                else return getOutputSlots();
+                    return getInputSlots();
+                }
+                else {
+                    return getOutputSlots();
+                }
             }
         };
 
@@ -138,71 +140,60 @@ public abstract class AGenerator extends AbstractEnergyProvider {
     }
 
     @Override
-    protected GeneratorTicker onTick() {
+    public int getGeneratedOutput(Location l, Config data) {
-        return new GeneratorTicker() {
+        BlockMenu inv = BlockStorage.getInventory(l);
+        boolean chargeable = getCapacity() > 0;
 
-            @Override
+        if (isProcessing(l)) {
-            public double generateEnergy(Location l, SlimefunItem sf, Config data) {
+            int timeleft = progress.get(l);
-                BlockMenu inv = BlockStorage.getInventory(l);
-                boolean chargeable = getCapacity() > 0;
-                int charge = chargeable ? ChargableBlock.getCharge(l) : 0;
 
-                if (isProcessing(l)) {
+            if (timeleft > 0) {
-                    int timeleft = progress.get(l);
+                ChestMenuUtils.updateProgressbar(inv, 22, timeleft, processing.get(l).getTicks(), getProgressBar());
 
-                    if (timeleft > 0) {
+                if (chargeable) {
-                        ChestMenuUtils.updateProgressbar(inv, 22, timeleft, processing.get(l).getTicks(), getProgressBar());
+                    int charge = ChargableBlock.getCharge(l);
 
-                        if (chargeable) {
+                    if (getCapacity() - charge >= getEnergyProduction()) {
-                            if (getCapacity() - charge >= getEnergyProduction()) {
+                        progress.put(l, timeleft - 1);
-                                ChargableBlock.addCharge(l, getEnergyProduction());
+                        return getEnergyProduction();
-                                progress.put(l, timeleft - 1);
-                                return (double) (charge + getEnergyProduction());
-                            }
-
-                            return charge;
-                        }
-                        else {
-                            progress.put(l, timeleft - 1);
-                            return getEnergyProduction();
-                        }
                     }
-                    else {
-                        ItemStack fuel = processing.get(l).getInput();
 
-                        if (isBucket(fuel)) {
+                    return 0;
-                            inv.pushItem(new ItemStack(Material.BUCKET), getOutputSlots());
-                        }
-
-                        inv.replaceExistingItem(22, new CustomItem(Material.BLACK_STAINED_GLASS_PANE, " "));
-
-                        progress.remove(l);
-                        processing.remove(l);
-                        return charge;
-                    }
                 }
                 else {
-                    Map<Integer, Integer> found = new HashMap<>();
+                    progress.put(l, timeleft - 1);
-                    MachineFuel fuel = findRecipe(inv, found);
+                    return getEnergyProduction();
-
-                    if (fuel != null) {
-                        for (Map.Entry<Integer, Integer> entry : found.entrySet()) {
-                            inv.consumeItem(entry.getKey(), entry.getValue());
-                        }
-
-                        processing.put(l, fuel);
-                        progress.put(l, fuel.getTicks());
-                    }
-
-                    return charge;
                 }
             }
+            else {
+                ItemStack fuel = processing.get(l).getInput();
 
-            @Override
+                if (isBucket(fuel)) {
-            public boolean explode(Location l) {
+                    inv.pushItem(new ItemStack(Material.BUCKET), getOutputSlots());
-                return false;
+                }
+
+                inv.replaceExistingItem(22, new CustomItem(Material.BLACK_STAINED_GLASS_PANE, " "));
+
+                progress.remove(l);
+                processing.remove(l);
+                return 0;
             }
-        };
+        }
+        else {
+            Map<Integer, Integer> found = new HashMap<>();
+            MachineFuel fuel = findRecipe(inv, found);
+
+            if (fuel != null) {
+                for (Map.Entry<Integer, Integer> entry : found.entrySet()) {
+                    inv.consumeItem(entry.getKey(), entry.getValue());
+                }
+
+                processing.put(l, fuel);
+                progress.put(l, fuel.getTicks());
+            }
+
+            return 0;
+        }
     }
 
     private boolean isBucket(ItemStack item) {

src/main/java/me/mrCookieSlime/Slimefun/Objects/handlers/GeneratorTicker.java

@@ -6,11 +6,17 @@ import org.bukkit.Location;
 
 import io.github.thebusybiscuit.slimefun4.api.exceptions.IncompatibleItemHandlerException;
 import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
+import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetProvider;
 import io.github.thebusybiscuit.slimefun4.core.attributes.NotPlaceable;
 import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
 import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
 
+/**
+ * @deprecated Please implement the {@link EnergyNetProvider} interface instead.
+ *
+ */
+@Deprecated
 public abstract class GeneratorTicker implements ItemHandler {
 
     public abstract double generateEnergy(Location l, SlimefunItem item, Config data);