From 86b656d6c4dd16ca2b653aa5c48e691a125dc5a4 Mon Sep 17 00:00:00 2001 From: bdew Date: Mon, 25 Aug 2014 15:34:24 +0300 Subject: [PATCH 01/37] Added IC2 and RF input to machines --- build.gradle | 19 ++-- .../java/forestry/core/config/Config.java | 7 ++ .../forestry/core/gadgets/TilePowered.java | 101 +++++++++++++++--- 3 files changed, 105 insertions(+), 22 deletions(-) diff --git a/build.gradle b/build.gradle index b90a1b73e..030578842 100755 --- a/build.gradle +++ b/build.gradle @@ -24,7 +24,7 @@ loadProperties() version = version_major + '.' + version_minor + '.' + version_patch + '.' + getBuildNumber() group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html -archivesBaseName = "forestry_" + mcversion +archivesBaseName = "forestry-allpower_" + mcversion ext.dirDest = './build/dist' ext.dirLang = "./lang" @@ -64,16 +64,21 @@ repositories { name = "ic2" url = "http://maven.ic2.player.to/" } + maven { + name = "bdew" + url = "http://jenkins.bdew.net/maven" + } } configurations { - buildcraft - compile.extendsFrom buildcraft + apis + compile.extendsFrom apis } dependencies { - compile 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api' - buildcraft 'com.mod-buildcraft:buildcraft:6.0.17:dev' + apis 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api' + apis 'com.mod-buildcraft:buildcraft:6.0.17:dev' + apis "net.bdew.thirdparty:CoFHLib:R1.0.1:api" } processResources { @@ -174,7 +179,7 @@ jar { archiveName = "main.jar" from { - configurations.buildcraft.collect { + configurations.apis.collect { it.isDirectory() ? it : zipTree(it).matching { include '**/api/**' } @@ -252,7 +257,7 @@ task devJar ( type: Zip, dependsOn: devJarSigned ) { } from { - configurations.buildcraft.collect { + configurations.apis.collect { it.isDirectory() ? it : zipTree(it).matching { include '**/api/**' } diff --git a/src/main/java/forestry/core/config/Config.java b/src/main/java/forestry/core/config/Config.java index a063fe370..8f1348cde 100755 --- a/src/main/java/forestry/core/config/Config.java +++ b/src/main/java/forestry/core/config/Config.java @@ -112,6 +112,10 @@ public class Config { public static HashMap hints = new HashMap(); public static boolean disableEnergyStat = false; + // Power rations + public static double MJ_RF_Ratio = 10; + public static double MJ_EU_Ratio = 2.5; + @SuppressWarnings({ "all" }) public static void load() { @@ -262,6 +266,9 @@ public class Config { property.Comment = "set to false to prevent Forestry's user from autooping."; Config.fakeUserAutoop = Boolean.parseBoolean(property.Value); + Config.MJ_RF_Ratio = Double.parseDouble(config.get("MJ_RF_Ratio", CATEGORY_COMMON, 10F).Value); + Config.MJ_EU_Ratio = Double.parseDouble(config.get("MJ_EU_Ratio", CATEGORY_COMMON, 2.5F).Value); + registerClimates(); ForestryTrigger.initialize(); diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index 999e3bfbe..31ec48f05 100755 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -10,9 +10,16 @@ ******************************************************************************/ package forestry.core.gadgets; +import cofh.api.energy.IEnergyHandler; +import forestry.core.config.Config; +import ic2.api.energy.event.EnergyTileLoadEvent; +import ic2.api.energy.event.EnergyTileUnloadEvent; +import ic2.api.energy.tile.IEnergySink; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; @@ -31,7 +38,7 @@ import forestry.core.proxy.Proxies; import forestry.core.utils.EnumTankLevel; import forestry.core.utils.ForestryTank; -public abstract class TilePowered extends TileBase implements IPowerHandler, IRenderableMachine { +public abstract class TilePowered extends TileBase implements IPowerHandler, IRenderableMachine, IEnergySink, IEnergyHandler { public static int WORK_CYCLES = 4; @@ -118,6 +125,11 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe if (worldObj.isRemote) return; + if (!ic2registered) { + MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this)); + ic2registered = true; + } + if (workCounter >= WORK_CYCLES && worldObj.getTotalWorldTime() % 5 == 0) { if (workCycle()) workCounter = 0; @@ -136,20 +148,6 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe workCounter++; } - /* - // Hard limit to 4 cycles / second. - if (worldObj.getTotalWorldTime() % 5 * 10 != 0) - return; - - PluginBuildCraft.instance.invokeUseEnergyMethod(powerHandler, powerHandler.getActivationEnergy(), powerHandler.getActivationEnergy(), false); - - // Do not consume energy if the boiler didn't do any work. - if (!workCycle()) - return; - - // Use up energy since we did some work. - PluginBuildCraft.instance.invokeUseEnergyMethod(powerHandler, powerHandler.getActivationEnergy(), powerHandler.getActivationEnergy(), true); - */ } public abstract boolean workCycle(); @@ -210,4 +208,77 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe public EnumTankLevel getSecondaryLevel() { return EnumTankLevel.EMPTY; } + + // ======= RF SUPPORT =========== + + @Override + public int receiveEnergy(ForgeDirection forgeDirection, int i, boolean b) { + if (b) + return (int) Math.round(Math.min(powerHandler.getPowerReceiver().powerRequest() * Config.MJ_RF_Ratio, i)); + else + return (int) Math.round(powerHandler.getPowerReceiver().receiveEnergy( + Type.PIPE, i / Config.MJ_RF_Ratio, forgeDirection) * Config.MJ_RF_Ratio); + } + + @Override + public int extractEnergy(ForgeDirection forgeDirection, int i, boolean b) { + return 0; + } + + @Override + public int getEnergyStored(ForgeDirection forgeDirection) { + return (int) Math.round(powerHandler.getEnergyStored() * Config.MJ_RF_Ratio); + } + + @Override + public int getMaxEnergyStored(ForgeDirection forgeDirection) { + return (int) Math.round(powerHandler.getMaxEnergyStored() * Config.MJ_RF_Ratio); + } + + @Override + public boolean canConnectEnergy(ForgeDirection forgeDirection) { + return true; + } + + // ======== EU SUPPORT ============ + + private boolean ic2registered = false; + + @Override + public void invalidate() { + if (ic2registered) { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); + ic2registered = false; + } + super.invalidate(); + } + + @Override + public void onChunkUnload() { + if (ic2registered) { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); + ic2registered = false; + } + super.onChunkUnload(); + } + + @Override + public double getDemandedEnergy() { + return powerHandler.getPowerReceiver().powerRequest() * Config.MJ_EU_Ratio; + } + + @Override + public int getSinkTier() { + return 2; + } + + @Override + public double injectEnergy(ForgeDirection forgeDirection, double v, double v2) { + return (v - powerHandler.getPowerReceiver().receiveEnergy(Type.PIPE, v / Config.MJ_EU_Ratio, forgeDirection)) * Config.MJ_EU_Ratio; + } + + @Override + public boolean acceptsEnergyFrom(TileEntity tileEntity, ForgeDirection forgeDirection) { + return true; + } } From 3aadd95c2d3f3cc39bed343de9da9d1ef68653e0 Mon Sep 17 00:00:00 2001 From: bdew Date: Mon, 25 Aug 2014 16:04:20 +0300 Subject: [PATCH 02/37] Fixed backwards math in IC2 receiver --- src/main/java/forestry/core/gadgets/TilePowered.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index 31ec48f05..c1c7aef71 100755 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -274,7 +274,7 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe @Override public double injectEnergy(ForgeDirection forgeDirection, double v, double v2) { - return (v - powerHandler.getPowerReceiver().receiveEnergy(Type.PIPE, v / Config.MJ_EU_Ratio, forgeDirection)) * Config.MJ_EU_Ratio; + return (v - powerHandler.getPowerReceiver().receiveEnergy(Type.PIPE, v / Config.MJ_EU_Ratio, forgeDirection) * Config.MJ_EU_Ratio) ; } @Override From 71e57ba35644c97176751fc016fd5dcf01a58ea5 Mon Sep 17 00:00:00 2001 From: Parker Date: Mon, 25 Aug 2014 19:38:14 -0400 Subject: [PATCH 03/37] Changed buildscript --- build.gradle | 10 +- src/main/java/cofh/api/CoFHAPIProps.java | 11 ++ .../java/cofh/api/energy/EnergyStorage.java | 158 ++++++++++++++++++ .../cofh/api/energy/IEnergyConnection.java | 21 +++ .../cofh/api/energy/IEnergyContainerItem.java | 52 ++++++ .../java/cofh/api/energy/IEnergyHandler.java | 51 ++++++ .../java/cofh/api/energy/IEnergyStorage.java | 45 +++++ .../cofh/api/energy/ItemEnergyContainer.java | 110 ++++++++++++ .../cofh/api/energy/TileEnergyHandler.java | 62 +++++++ .../java/cofh/api/energy/package-info.java | 10 ++ src/main/java/cofh/api/package-info.java | 9 + 11 files changed, 532 insertions(+), 7 deletions(-) create mode 100644 src/main/java/cofh/api/CoFHAPIProps.java create mode 100644 src/main/java/cofh/api/energy/EnergyStorage.java create mode 100644 src/main/java/cofh/api/energy/IEnergyConnection.java create mode 100644 src/main/java/cofh/api/energy/IEnergyContainerItem.java create mode 100644 src/main/java/cofh/api/energy/IEnergyHandler.java create mode 100644 src/main/java/cofh/api/energy/IEnergyStorage.java create mode 100644 src/main/java/cofh/api/energy/ItemEnergyContainer.java create mode 100644 src/main/java/cofh/api/energy/TileEnergyHandler.java create mode 100644 src/main/java/cofh/api/energy/package-info.java create mode 100644 src/main/java/cofh/api/package-info.java diff --git a/build.gradle b/build.gradle index 030578842..55b36708c 100755 --- a/build.gradle +++ b/build.gradle @@ -22,9 +22,9 @@ apply plugin: 'maven' loadProperties() -version = version_major + '.' + version_minor + '.' + version_patch + '.' + getBuildNumber() +version = "3.0.0.91-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html -archivesBaseName = "forestry-allpower_" + mcversion +archivesBaseName = "forestry_" + mcversion ext.dirDest = './build/dist' ext.dirLang = "./lang" @@ -46,6 +46,7 @@ sourceSets { java { srcDir CraftGuideTmp + "/src" include '**/CraftGuide/api/**' + include 'cofh/**' } } @@ -64,10 +65,6 @@ repositories { name = "ic2" url = "http://maven.ic2.player.to/" } - maven { - name = "bdew" - url = "http://jenkins.bdew.net/maven" - } } configurations { @@ -78,7 +75,6 @@ configurations { dependencies { apis 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api' apis 'com.mod-buildcraft:buildcraft:6.0.17:dev' - apis "net.bdew.thirdparty:CoFHLib:R1.0.1:api" } processResources { diff --git a/src/main/java/cofh/api/CoFHAPIProps.java b/src/main/java/cofh/api/CoFHAPIProps.java new file mode 100644 index 000000000..22096377f --- /dev/null +++ b/src/main/java/cofh/api/CoFHAPIProps.java @@ -0,0 +1,11 @@ +package cofh.api; + +public class CoFHAPIProps { + + private CoFHAPIProps() { + + } + + public static final String VERSION = "1.7.10R1.0.1"; + +} diff --git a/src/main/java/cofh/api/energy/EnergyStorage.java b/src/main/java/cofh/api/energy/EnergyStorage.java new file mode 100644 index 000000000..2dfd2b1b6 --- /dev/null +++ b/src/main/java/cofh/api/energy/EnergyStorage.java @@ -0,0 +1,158 @@ +package cofh.api.energy; + +import net.minecraft.nbt.NBTTagCompound; + +/** + * Reference implementation of {@link IEnergyStorage}. Use/extend this or implement your own. + * + * @author King Lemming + * + */ +public class EnergyStorage implements IEnergyStorage { + + protected int energy; + protected int capacity; + protected int maxReceive; + protected int maxExtract; + + public EnergyStorage(int capacity) { + + this(capacity, capacity, capacity); + } + + public EnergyStorage(int capacity, int maxTransfer) { + + this(capacity, maxTransfer, maxTransfer); + } + + public EnergyStorage(int capacity, int maxReceive, int maxExtract) { + + this.capacity = capacity; + this.maxReceive = maxReceive; + this.maxExtract = maxExtract; + } + + public EnergyStorage readFromNBT(NBTTagCompound nbt) { + + this.energy = nbt.getInteger("Energy"); + + if (energy > capacity) { + energy = capacity; + } + return this; + } + + public NBTTagCompound writeToNBT(NBTTagCompound nbt) { + + if (energy < 0) { + energy = 0; + } + nbt.setInteger("Energy", energy); + return nbt; + } + + public void setCapacity(int capacity) { + + this.capacity = capacity; + + if (energy > capacity) { + energy = capacity; + } + } + + public void setMaxTransfer(int maxTransfer) { + + setMaxReceive(maxTransfer); + setMaxExtract(maxTransfer); + } + + public void setMaxReceive(int maxReceive) { + + this.maxReceive = maxReceive; + } + + public void setMaxExtract(int maxExtract) { + + this.maxExtract = maxExtract; + } + + public int getMaxReceive() { + + return maxReceive; + } + + public int getMaxExtract() { + + return maxExtract; + } + + /** + * This function is included to allow for server -> client sync. Do not call this externally to the containing Tile Entity, as not all IEnergyHandlers are + * guaranteed to have it. + * + * @param energy + */ + public void setEnergyStored(int energy) { + + this.energy = energy; + + if (this.energy > capacity) { + this.energy = capacity; + } else if (this.energy < 0) { + this.energy = 0; + } + } + + /** + * This function is included to allow the containing tile to directly and efficiently modify the energy contained in the EnergyStorage. Do not rely on this + * externally, as not all IEnergyHandlers are guaranteed to have it. + * + * @param energy + */ + public void modifyEnergyStored(int energy) { + + this.energy += energy; + + if (this.energy > capacity) { + this.energy = capacity; + } else if (this.energy < 0) { + this.energy = 0; + } + } + + /* IEnergyStorage */ + @Override + public int receiveEnergy(int maxReceive, boolean simulate) { + + int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive)); + + if (!simulate) { + energy += energyReceived; + } + return energyReceived; + } + + @Override + public int extractEnergy(int maxExtract, boolean simulate) { + + int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract)); + + if (!simulate) { + energy -= energyExtracted; + } + return energyExtracted; + } + + @Override + public int getEnergyStored() { + + return energy; + } + + @Override + public int getMaxEnergyStored() { + + return capacity; + } + +} diff --git a/src/main/java/cofh/api/energy/IEnergyConnection.java b/src/main/java/cofh/api/energy/IEnergyConnection.java new file mode 100644 index 000000000..63faffb9f --- /dev/null +++ b/src/main/java/cofh/api/energy/IEnergyConnection.java @@ -0,0 +1,21 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this interface on TileEntities which should connect to energy transportation blocks. This is intended for blocks which generate energy but do not + * accept it; otherwise just use IEnergyHandler. + * + * Note that {@link IEnergyHandler} is an extension of this. + * + * @author King Lemming + * + */ +public interface IEnergyConnection { + + /** + * Returns TRUE if the TileEntity can connect on a given side. + */ + boolean canConnectEnergy(ForgeDirection from); + +} diff --git a/src/main/java/cofh/api/energy/IEnergyContainerItem.java b/src/main/java/cofh/api/energy/IEnergyContainerItem.java new file mode 100644 index 000000000..0bcfda600 --- /dev/null +++ b/src/main/java/cofh/api/energy/IEnergyContainerItem.java @@ -0,0 +1,52 @@ +package cofh.api.energy; + +import net.minecraft.item.ItemStack; + +/** + * Implement this interface on Item classes that support external manipulation of their internal energy storages. + * + * A reference implementation is provided {@link ItemEnergyContainer}. + * + * @author King Lemming + * + */ +public interface IEnergyContainerItem { + + /** + * Adds energy to a container item. Returns the quantity of energy that was accepted. This should always return 0 if the item cannot be externally charged. + * + * @param container + * ItemStack to be charged. + * @param maxReceive + * Maximum amount of energy to be sent into the item. + * @param simulate + * If TRUE, the charge will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) received by the item. + */ + int receiveEnergy(ItemStack container, int maxReceive, boolean simulate); + + /** + * Removes energy from a container item. Returns the quantity of energy that was removed. This should always return 0 if the item cannot be externally + * discharged. + * + * @param container + * ItemStack to be discharged. + * @param maxExtract + * Maximum amount of energy to be extracted from the item. + * @param simulate + * If TRUE, the discharge will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) extracted from the item. + */ + int extractEnergy(ItemStack container, int maxExtract, boolean simulate); + + /** + * Get the amount of energy currently stored in the container item. + */ + int getEnergyStored(ItemStack container); + + /** + * Get the max amount of energy that can be stored in the container item. + */ + int getMaxEnergyStored(ItemStack container); + +} diff --git a/src/main/java/cofh/api/energy/IEnergyHandler.java b/src/main/java/cofh/api/energy/IEnergyHandler.java new file mode 100644 index 000000000..3df312346 --- /dev/null +++ b/src/main/java/cofh/api/energy/IEnergyHandler.java @@ -0,0 +1,51 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this interface on Tile Entities which should handle energy, generally storing it in one or more internal {@link IEnergyStorage} objects. + * + * A reference implementation is provided {@link TileEnergyHandler}. + * + * @author King Lemming + * + */ +public interface IEnergyHandler extends IEnergyConnection { + + /** + * Add energy to an IEnergyHandler, internal distribution is left entirely to the IEnergyHandler. + * + * @param from + * Orientation the energy is received from. + * @param maxReceive + * Maximum amount of energy to receive. + * @param simulate + * If TRUE, the charge will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) received. + */ + int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate); + + /** + * Remove energy from an IEnergyHandler, internal distribution is left entirely to the IEnergyHandler. + * + * @param from + * Orientation the energy is extracted from. + * @param maxExtract + * Maximum amount of energy to extract. + * @param simulate + * If TRUE, the extraction will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) extracted. + */ + int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate); + + /** + * Returns the amount of energy currently stored. + */ + int getEnergyStored(ForgeDirection from); + + /** + * Returns the maximum amount of energy that can be stored. + */ + int getMaxEnergyStored(ForgeDirection from); + +} diff --git a/src/main/java/cofh/api/energy/IEnergyStorage.java b/src/main/java/cofh/api/energy/IEnergyStorage.java new file mode 100644 index 000000000..1e84bc221 --- /dev/null +++ b/src/main/java/cofh/api/energy/IEnergyStorage.java @@ -0,0 +1,45 @@ +package cofh.api.energy; + +/** + * An energy storage is the unit of interaction with Energy inventories. + * + * A reference implementation can be found at {@link EnergyStorage}. + * + * @author King Lemming + * + */ +public interface IEnergyStorage { + + /** + * Adds energy to the storage. Returns quantity of energy that was accepted. + * + * @param maxReceive + * Maximum amount of energy to be inserted. + * @param simulate + * If TRUE, the insertion will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) accepted by the storage. + */ + int receiveEnergy(int maxReceive, boolean simulate); + + /** + * Removes energy from the storage. Returns quantity of energy that was removed. + * + * @param maxExtract + * Maximum amount of energy to be extracted. + * @param simulate + * If TRUE, the extraction will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) extracted from the storage. + */ + int extractEnergy(int maxExtract, boolean simulate); + + /** + * Returns the amount of energy currently stored. + */ + int getEnergyStored(); + + /** + * Returns the maximum amount of energy that can be stored. + */ + int getMaxEnergyStored(); + +} diff --git a/src/main/java/cofh/api/energy/ItemEnergyContainer.java b/src/main/java/cofh/api/energy/ItemEnergyContainer.java new file mode 100644 index 000000000..055ae45bc --- /dev/null +++ b/src/main/java/cofh/api/energy/ItemEnergyContainer.java @@ -0,0 +1,110 @@ +package cofh.api.energy; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +/** + * Reference implementation of {@link IEnergyContainerItem}. Use/extend this or implement your own. + * + * @author King Lemming + * + */ +public class ItemEnergyContainer extends Item implements IEnergyContainerItem { + + protected int capacity; + protected int maxReceive; + protected int maxExtract; + + public ItemEnergyContainer() { + + } + + public ItemEnergyContainer(int capacity) { + + this(capacity, capacity, capacity); + } + + public ItemEnergyContainer(int capacity, int maxTransfer) { + + this(capacity, maxTransfer, maxTransfer); + } + + public ItemEnergyContainer(int capacity, int maxReceive, int maxExtract) { + + this.capacity = capacity; + this.maxReceive = maxReceive; + this.maxExtract = maxExtract; + } + + public ItemEnergyContainer setCapacity(int capacity) { + + this.capacity = capacity; + return this; + } + + public void setMaxTransfer(int maxTransfer) { + + setMaxReceive(maxTransfer); + setMaxExtract(maxTransfer); + } + + public void setMaxReceive(int maxReceive) { + + this.maxReceive = maxReceive; + } + + public void setMaxExtract(int maxExtract) { + + this.maxExtract = maxExtract; + } + + /* IEnergyContainerItem */ + @Override + public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { + + if (container.stackTagCompound == null) { + container.stackTagCompound = new NBTTagCompound(); + } + int energy = container.stackTagCompound.getInteger("Energy"); + int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive)); + + if (!simulate) { + energy += energyReceived; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyReceived; + } + + @Override + public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { + + if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { + return 0; + } + int energy = container.stackTagCompound.getInteger("Energy"); + int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract)); + + if (!simulate) { + energy -= energyExtracted; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyExtracted; + } + + @Override + public int getEnergyStored(ItemStack container) { + + if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { + return 0; + } + return container.stackTagCompound.getInteger("Energy"); + } + + @Override + public int getMaxEnergyStored(ItemStack container) { + + return capacity; + } + +} diff --git a/src/main/java/cofh/api/energy/TileEnergyHandler.java b/src/main/java/cofh/api/energy/TileEnergyHandler.java new file mode 100644 index 000000000..a7fabeb77 --- /dev/null +++ b/src/main/java/cofh/api/energy/TileEnergyHandler.java @@ -0,0 +1,62 @@ +package cofh.api.energy; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Reference implementation of {@link IEnergyHandler}. Use/extend this or implement your own. + * + * @author King Lemming + * + */ +public class TileEnergyHandler extends TileEntity implements IEnergyHandler { + + protected EnergyStorage storage = new EnergyStorage(32000); + + @Override + public void readFromNBT(NBTTagCompound nbt) { + + super.readFromNBT(nbt); + storage.readFromNBT(nbt); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + + super.writeToNBT(nbt); + storage.writeToNBT(nbt); + } + + /* IEnergyHandler */ + @Override + public boolean canConnectEnergy(ForgeDirection from) { + + return true; + } + + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + + return storage.receiveEnergy(maxReceive, simulate); + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + + return storage.extractEnergy(maxExtract, simulate); + } + + @Override + public int getEnergyStored(ForgeDirection from) { + + return storage.getEnergyStored(); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + + return storage.getMaxEnergyStored(); + } + +} diff --git a/src/main/java/cofh/api/energy/package-info.java b/src/main/java/cofh/api/energy/package-info.java new file mode 100644 index 000000000..7379702b8 --- /dev/null +++ b/src/main/java/cofh/api/energy/package-info.java @@ -0,0 +1,10 @@ +/** + * (C) 2014 Team CoFH / CoFH / Cult of the Full Hub + * http://www.teamcofh.com + */ +@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHAPI", provides = "CoFHAPI|energy") +package cofh.api.energy; + +import cofh.api.CoFHAPIProps; +import cpw.mods.fml.common.API; + diff --git a/src/main/java/cofh/api/package-info.java b/src/main/java/cofh/api/package-info.java new file mode 100644 index 000000000..08ff5fcb6 --- /dev/null +++ b/src/main/java/cofh/api/package-info.java @@ -0,0 +1,9 @@ +/** + * (C) 2014 Team CoFH / CoFH / Cult of the Full Hub + * http://www.teamcofh.com + */ +@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHLib", provides = "CoFHAPI") +package cofh.api; + +import cpw.mods.fml.common.API; + From 582e93278e149a1bda9adbcbee505e235eed89a5 Mon Sep 17 00:00:00 2001 From: Parker Date: Mon, 25 Aug 2014 21:29:02 -0400 Subject: [PATCH 04/37] Updated to build 92 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 55b36708c..bb1d58b44 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.91-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.92-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From f3894b088e5675437b80c9b96357c1dc67853eb6 Mon Sep 17 00:00:00 2001 From: Parker Date: Fri, 29 Aug 2014 15:25:48 -0400 Subject: [PATCH 05/37] Initial drop of MJ. This is for machines only at this point. Untested. 3Fixed compiler errors --- build.gradle | 1 - .../forestry/core/gadgets/TilePowered.java | 85 +++++++------------ .../factory/gadgets/MachineBottler.java | 6 +- .../factory/gadgets/MachineCarpenter.java | 6 +- .../factory/gadgets/MachineCentrifuge.java | 4 +- .../factory/gadgets/MachineFabricator.java | 6 +- .../factory/gadgets/MachineFermenter.java | 6 +- .../factory/gadgets/MachineSqueezer.java | 6 +- .../factory/gadgets/MachineStill.java | 6 +- 9 files changed, 56 insertions(+), 70 deletions(-) diff --git a/build.gradle b/build.gradle index bb1d58b44..5755bf3c2 100755 --- a/build.gradle +++ b/build.gradle @@ -46,7 +46,6 @@ sourceSets { java { srcDir CraftGuideTmp + "/src" include '**/CraftGuide/api/**' - include 'cofh/**' } } diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index c1c7aef71..38fa9fe65 100755 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -10,8 +10,8 @@ ******************************************************************************/ package forestry.core.gadgets; +import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyHandler; -import forestry.core.config.Config; import ic2.api.energy.event.EnergyTileLoadEvent; import ic2.api.energy.event.EnergyTileUnloadEvent; import ic2.api.energy.tile.IEnergySink; @@ -23,13 +23,7 @@ import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; -import buildcraft.api.power.PowerHandler; -import buildcraft.api.power.PowerHandler.PowerReceiver; -import buildcraft.api.power.PowerHandler.Type; - import forestry.core.GameMode; -import forestry.core.config.Defaults; -import forestry.core.interfaces.IPowerHandler; import forestry.core.interfaces.IRenderableMachine; import forestry.core.network.ClassMap; import forestry.core.network.IndexInPayload; @@ -38,9 +32,10 @@ import forestry.core.proxy.Proxies; import forestry.core.utils.EnumTankLevel; import forestry.core.utils.ForestryTank; -public abstract class TilePowered extends TileBase implements IPowerHandler, IRenderableMachine, IEnergySink, IEnergyHandler { +public abstract class TilePowered extends TileBase implements IRenderableMachine, IEnergySink, IEnergyHandler { public static int WORK_CYCLES = 4; + public static int ENERGY_PER_USE = 150; //Temporary @Override public PacketPayload getPacketPayload() { @@ -76,7 +71,14 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe ex.printStackTrace(); } } - private final PowerHandler powerHandler; + protected EnergyStorage energyStorage; + + public TilePowered() { + energyStorage = new EnergyStorage(5000); + energyStorage.setCapacity(Math.round(energyStorage.getMaxEnergyStored() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier") * 10)); //TODO The *10 is temporary until the RF conversion is complete + } + + /*private final PowerHandler powerHandler; public TilePowered() { powerHandler = new PowerHandler(this, Type.MACHINE); @@ -95,7 +97,7 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe Math.round(provider.getMaxEnergyReceived() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")), Math.round(provider.getActivationEnergy() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")), Math.round(provider.getMaxEnergyStored() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier"))); - } + }*/ /* STATE INFORMATION */ public abstract boolean isWorking(); @@ -113,16 +115,16 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe } /* IPOWERRECEPTOR */ - @Override + /*@Override public PowerHandler getPowerHandler() { return powerHandler; - } + }*/ private int workCounter; @Override public void updateEntity() { super.updateEntity(); - if (worldObj.isRemote) + if (worldObj.isRemote || !Proxies.common.isSimulating(worldObj)) return; if (!ic2registered) { @@ -130,52 +132,31 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe ic2registered = true; } + if (workCounter < WORK_CYCLES) { + energyStorage.modifyEnergyStored(-ENERGY_PER_USE); //TODO Make it continuous usage while doing work + workCounter++; + } + if (workCounter >= WORK_CYCLES && worldObj.getTotalWorldTime() % 5 == 0) { if (workCycle()) workCounter = 0; } } - @Override - public void doWork(PowerHandler workProvider) { - - if (!Proxies.common.isSimulating(worldObj)) - return; - - // Hard limit to 4 cycles / second. - if (workCounter < WORK_CYCLES) { - powerHandler.useEnergy(powerHandler.getActivationEnergy(), powerHandler.getActivationEnergy(), true); - workCounter++; - } - - } - public abstract boolean workCycle(); - @Override - public PowerReceiver getPowerReceiver(ForgeDirection side) { - return powerHandler.getPowerReceiver(); - } - @Override public void writeToNBT(NBTTagCompound nbt) { super.writeToNBT(nbt); - powerHandler.writeToNBT(nbt); + energyStorage.writeToNBT(nbt); } @Override public void readFromNBT(NBTTagCompound nbt) { super.readFromNBT(nbt); - powerHandler.readFromNBT(nbt); + energyStorage.readFromNBT(nbt); } - /* - @Override - public int powerRequest(ForgeDirection direction) { - float needed = powerProvider.getMaxEnergyStored() - powerProvider.getEnergyStored(); - return (int) Math.ceil(Math.min(powerProvider.getMaxEnergyReceived(), needed)); - } */ - /* LIQUID CONTAINER HANDLING */ protected ItemStack bottleIntoContainer(ItemStack canStack, ItemStack outputStack, FluidContainerData container, ForestryTank tank) { if (tank.getFluidAmount() < container.fluid.amount) @@ -209,15 +190,9 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe return EnumTankLevel.EMPTY; } - // ======= RF SUPPORT =========== - @Override - public int receiveEnergy(ForgeDirection forgeDirection, int i, boolean b) { - if (b) - return (int) Math.round(Math.min(powerHandler.getPowerReceiver().powerRequest() * Config.MJ_RF_Ratio, i)); - else - return (int) Math.round(powerHandler.getPowerReceiver().receiveEnergy( - Type.PIPE, i / Config.MJ_RF_Ratio, forgeDirection) * Config.MJ_RF_Ratio); + public int receiveEnergy(ForgeDirection forgeDirection, int maxReceive, boolean simulate) { + return energyStorage.receiveEnergy(maxReceive, simulate); } @Override @@ -227,12 +202,12 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe @Override public int getEnergyStored(ForgeDirection forgeDirection) { - return (int) Math.round(powerHandler.getEnergyStored() * Config.MJ_RF_Ratio); + return energyStorage.getEnergyStored(); } @Override public int getMaxEnergyStored(ForgeDirection forgeDirection) { - return (int) Math.round(powerHandler.getMaxEnergyStored() * Config.MJ_RF_Ratio); + return energyStorage.getMaxEnergyStored(); } @Override @@ -264,7 +239,7 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe @Override public double getDemandedEnergy() { - return powerHandler.getPowerReceiver().powerRequest() * Config.MJ_EU_Ratio; + return (energyStorage.getMaxEnergyStored() - energyStorage.getEnergyStored()) / 4; } @Override @@ -273,12 +248,12 @@ public abstract class TilePowered extends TileBase implements IPowerHandler, IRe } @Override - public double injectEnergy(ForgeDirection forgeDirection, double v, double v2) { - return (v - powerHandler.getPowerReceiver().receiveEnergy(Type.PIPE, v / Config.MJ_EU_Ratio, forgeDirection) * Config.MJ_EU_Ratio) ; + public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage) { + return energyStorage.receiveEnergy((int)(amount * 4), false); //TODO May want to do something other than casting } @Override - public boolean acceptsEnergyFrom(TileEntity tileEntity, ForgeDirection forgeDirection) { + public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) { return true; } } diff --git a/src/main/java/forestry/factory/gadgets/MachineBottler.java b/src/main/java/forestry/factory/gadgets/MachineBottler.java index 2b9c0a6e3..d8308a2ad 100755 --- a/src/main/java/forestry/factory/gadgets/MachineBottler.java +++ b/src/main/java/forestry/factory/gadgets/MachineBottler.java @@ -33,6 +33,7 @@ import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; import buildcraft.api.power.PowerHandler; +import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.recipes.IBottlerManager; import forestry.api.recipes.RecipeManagers; @@ -161,6 +162,7 @@ public class MachineBottler extends TilePowered implements ISidedInventory, ILiq private int fillingTotalTime; public MachineBottler() { + energyStorage = new EnergyStorage(4000); setHints(Config.hints.get("bottler")); } @@ -175,10 +177,10 @@ public class MachineBottler extends TilePowered implements ISidedInventory, ILiq } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(50, 110, 5, 400); - } + }*/ /* SAVING & LOADING */ @Override diff --git a/src/main/java/forestry/factory/gadgets/MachineCarpenter.java b/src/main/java/forestry/factory/gadgets/MachineCarpenter.java index 5e30b7f43..dc93a50aa 100755 --- a/src/main/java/forestry/factory/gadgets/MachineCarpenter.java +++ b/src/main/java/forestry/factory/gadgets/MachineCarpenter.java @@ -34,6 +34,7 @@ import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; import buildcraft.api.power.PowerHandler; +import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.recipes.ICarpenterManager; import forestry.core.EnumErrorCode; @@ -230,6 +231,7 @@ public class MachineCarpenter extends TilePowered implements ISidedInventory, IL } public MachineCarpenter() { + energyStorage = new EnergyStorage(4000); setHints(Config.hints.get("carpenter")); craftingInventory = new TileInventoryAdapter(this, 10, "CraftItems"); accessibleInventory = (TileInventoryAdapter) new TileInventoryAdapter(this, 30, "Items").configureSided(Defaults.FACINGS, SLOT_BOX, 20); @@ -245,10 +247,10 @@ public class MachineCarpenter extends TilePowered implements ISidedInventory, IL player.openGui(ForestryAPI.instance, GuiId.CarpenterGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(50, 110, 5, 400); - } + }*/ /* LOADING & SAVING */ @Override diff --git a/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java b/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java index 294d09bf3..b96f17c20 100755 --- a/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java +++ b/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java @@ -156,10 +156,10 @@ public class MachineCentrifuge extends TilePowered implements ISidedInventory, I player.openGui(ForestryAPI.instance, GuiId.CentrifugeGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(40, 80, 4, Defaults.MACHINE_MAX_ENERGY); - } + }*/ /* LOADING & SAVING */ @Override diff --git a/src/main/java/forestry/factory/gadgets/MachineFabricator.java b/src/main/java/forestry/factory/gadgets/MachineFabricator.java index 989e27820..0e3e2da85 100755 --- a/src/main/java/forestry/factory/gadgets/MachineFabricator.java +++ b/src/main/java/forestry/factory/gadgets/MachineFabricator.java @@ -27,6 +27,7 @@ import net.minecraftforge.fluids.FluidStack; import buildcraft.api.power.PowerHandler; +import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; import forestry.api.recipes.IFabricatorManager; @@ -237,12 +238,13 @@ public class MachineFabricator extends TilePowered implements ICrafter, ISpecial private FluidStack pendingSmelt; public MachineFabricator() { + energyStorage = new EnergyStorage(3300); } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(50, 110, 5, 330); - } + }*/ @Override public String getInventoryName() { diff --git a/src/main/java/forestry/factory/gadgets/MachineFermenter.java b/src/main/java/forestry/factory/gadgets/MachineFermenter.java index fc0ec9bbd..e2e3ff7aa 100755 --- a/src/main/java/forestry/factory/gadgets/MachineFermenter.java +++ b/src/main/java/forestry/factory/gadgets/MachineFermenter.java @@ -29,6 +29,7 @@ import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; import buildcraft.api.power.PowerHandler; +import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.fuels.FuelManager; import forestry.api.recipes.IFermenterManager; @@ -193,6 +194,7 @@ public class MachineFermenter extends TilePowered implements ISidedInventory, IL public int fuelCurrentFerment = 0; public MachineFermenter() { + energyStorage = new EnergyStorage(8000); setHints(Config.hints.get("fermenter")); } @@ -206,10 +208,10 @@ public class MachineFermenter extends TilePowered implements ISidedInventory, IL player.openGui(ForestryAPI.instance, GuiId.FermenterGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(5, 200, 15, 800); - } + }*/ @Override public void writeToNBT(NBTTagCompound nbttagcompound) { diff --git a/src/main/java/forestry/factory/gadgets/MachineSqueezer.java b/src/main/java/forestry/factory/gadgets/MachineSqueezer.java index da55534c1..4641e35cc 100755 --- a/src/main/java/forestry/factory/gadgets/MachineSqueezer.java +++ b/src/main/java/forestry/factory/gadgets/MachineSqueezer.java @@ -31,6 +31,7 @@ import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; import buildcraft.api.power.PowerHandler; +import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; import forestry.api.recipes.ISqueezerManager; @@ -149,6 +150,7 @@ public class MachineSqueezer extends TilePowered implements ISpecialInventory, I private int timePerItem; public MachineSqueezer() { + energyStorage = new EnergyStorage(4000); setHints(Config.hints.get("squeezer")); } @@ -162,10 +164,10 @@ public class MachineSqueezer extends TilePowered implements ISpecialInventory, I player.openGui(ForestryAPI.instance, GuiId.SqueezerGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(50, 110, 5, 400); - } + }*/ /* LOADING & SAVING */ @Override diff --git a/src/main/java/forestry/factory/gadgets/MachineStill.java b/src/main/java/forestry/factory/gadgets/MachineStill.java index f972240f5..6de02b5c6 100755 --- a/src/main/java/forestry/factory/gadgets/MachineStill.java +++ b/src/main/java/forestry/factory/gadgets/MachineStill.java @@ -29,6 +29,7 @@ import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; import buildcraft.api.power.PowerHandler; +import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; import forestry.api.recipes.IStillManager; @@ -128,6 +129,7 @@ public class MachineStill extends TilePowered implements ISpecialInventory, ISid public int distillationTotalTime = 0; public MachineStill() { + energyStorage = new EnergyStorage(8000); setHints(Config.hints.get("still")); } @@ -141,10 +143,10 @@ public class MachineStill extends TilePowered implements ISpecialInventory, ISid player.openGui(ForestryAPI.instance, GuiId.StillGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - @Override + /*@Override //TODO protected void configurePowerProvider(PowerHandler provider) { provider.configure(50, 110, 5, 800); - } + }*/ @Override public void writeToNBT(NBTTagCompound nbttagcompound) { From 1f290f9cf5358ef436afc968a792e7978679ac71 Mon Sep 17 00:00:00 2001 From: Parker Date: Sat, 30 Aug 2014 20:39:49 -0400 Subject: [PATCH 06/37] Fixed Energy Demand Modifier. Commented it out for now. I'll have to go through later and re-implement it in a different way. --- .../java/forestry/core/gadgets/TilePowered.java | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index 38fa9fe65..87fa3776b 100755 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -75,7 +75,7 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine public TilePowered() { energyStorage = new EnergyStorage(5000); - energyStorage.setCapacity(Math.round(energyStorage.getMaxEnergyStored() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier") * 10)); //TODO The *10 is temporary until the RF conversion is complete + //energyStorage.setCapacity(Math.round(energyStorage.getMaxEnergyStored() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier"))); } /*private final PowerHandler powerHandler; @@ -114,11 +114,6 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine return false; } - /* IPOWERRECEPTOR */ - /*@Override - public PowerHandler getPowerHandler() { - return powerHandler; - }*/ private int workCounter; @Override @@ -191,27 +186,27 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine } @Override - public int receiveEnergy(ForgeDirection forgeDirection, int maxReceive, boolean simulate) { + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { return energyStorage.receiveEnergy(maxReceive, simulate); } @Override - public int extractEnergy(ForgeDirection forgeDirection, int i, boolean b) { + public int extractEnergy(ForgeDirection from, int maxReceive, boolean simulate) { return 0; } @Override - public int getEnergyStored(ForgeDirection forgeDirection) { + public int getEnergyStored(ForgeDirection from) { return energyStorage.getEnergyStored(); } @Override - public int getMaxEnergyStored(ForgeDirection forgeDirection) { + public int getMaxEnergyStored(ForgeDirection from) { return energyStorage.getMaxEnergyStored(); } @Override - public boolean canConnectEnergy(ForgeDirection forgeDirection) { + public boolean canConnectEnergy(ForgeDirection from) { return true; } From 0da3d6f792bc32b9dcf98e8a41ce3efacc0d466a Mon Sep 17 00:00:00 2001 From: Parker Date: Fri, 12 Sep 2014 16:16:07 -0400 Subject: [PATCH 07/37] Stupid submodule and forks not working together :( --- api | 2 +- lang | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/api b/api index 6720bd4ae..210e7d410 160000 --- a/api +++ b/api @@ -1 +1 @@ -Subproject commit 6720bd4aee8e7951ec3b0a6c4c5aaca4af136d82 +Subproject commit 210e7d410222fe74d20e3c3b994fda0419615d3a diff --git a/lang b/lang index 37b482690..6a0217f4a 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit 37b482690038b2d1c56a97bf99bc3dfcd50bd0a4 +Subproject commit 6a0217f4ae1594a1e82ca61303242b1161cdd724 From 2cefa9f99df4ba9db519e30b97cb78d172e8287f Mon Sep 17 00:00:00 2001 From: Parker Date: Tue, 16 Sep 2014 13:16:31 -0400 Subject: [PATCH 08/37] Updated to Forestry 140 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 824fe2480..69a975ac0 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.131-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.140-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From b786a227ed07e9d28dee42fd032e6afd4b26b451 Mon Sep 17 00:00:00 2001 From: Parker Date: Fri, 19 Sep 2014 19:05:54 -0400 Subject: [PATCH 09/37] Updated to Forestry 158 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 69a975ac0..1d6d1d2b9 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.140-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.158-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From 1080799a8d80973a046647d16cacfa08e88f5f8a Mon Sep 17 00:00:00 2001 From: Parker Young Date: Sat, 20 Sep 2014 16:22:22 -0400 Subject: [PATCH 10/37] First draft of Engines producing RF. Compiles. Untested. --- .../java/forestry/core/config/Config.java | 6 - .../java/forestry/core/config/Defaults.java | 4 +- .../java/forestry/core/gadgets/Engine.java | 172 ++++++++---------- .../java/forestry/core/utils/BlockUtil.java | 16 ++ .../forestry/energy/gadgets/EngineBronze.java | 6 +- .../energy/gadgets/EngineClockwork.java | 6 +- .../forestry/energy/gadgets/EngineCopper.java | 8 +- .../forestry/energy/gadgets/EngineTin.java | 18 +- 8 files changed, 110 insertions(+), 126 deletions(-) diff --git a/src/main/java/forestry/core/config/Config.java b/src/main/java/forestry/core/config/Config.java index 451822311..fa37af2aa 100755 --- a/src/main/java/forestry/core/config/Config.java +++ b/src/main/java/forestry/core/config/Config.java @@ -109,10 +109,6 @@ public class Config { public static HashMap hints = new HashMap(); public static boolean disableEnergyStat = false; - // Power rations - public static double MJ_RF_Ratio = 10; - public static double MJ_EU_Ratio = 2.5; - @SuppressWarnings({ "all" }) public static void load() { @@ -255,8 +251,6 @@ public class Config { for (String str : disabledStructures) Proxies.log.finer("Disabled structure '%s'.", str); - Config.MJ_RF_Ratio = Double.parseDouble(config.get("MJ_RF_Ratio", CATEGORY_COMMON, 10F).Value); - Config.MJ_EU_Ratio = Double.parseDouble(config.get("MJ_EU_Ratio", CATEGORY_COMMON, 2.5F).Value); registerClimates(); ForestryTrigger.initialize(); diff --git a/src/main/java/forestry/core/config/Defaults.java b/src/main/java/forestry/core/config/Defaults.java index d4c77cf3e..bf7c5b843 100755 --- a/src/main/java/forestry/core/config/Defaults.java +++ b/src/main/java/forestry/core/config/Defaults.java @@ -201,8 +201,8 @@ public class Defaults { public static final int ENGINE_COPPER_ASH_FOR_ITEM = 7500; public static final int ENGINE_TIN_HEAT_MAX = 3000; - public static final int ENGINE_TIN_EU_FOR_CYCLE = 6; - public static final int ENGINE_TIN_ENERGY_PER_CYCLE = 2; + public static final int ENGINE_TIN_EU_FOR_CYCLE = 5; //Reduced from 6 to 5, as per the 4 RF to 1 EU ratio + public static final int ENGINE_TIN_ENERGY_PER_CYCLE = 20; public static final int ENGINE_TIN_MAX_EU_STORED = 2 * ENGINE_TIN_EU_FOR_CYCLE; public static final int ENGINE_TIN_MAX_EU_BATTERY = 100; diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index d754cded7..9f76de487 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -20,14 +20,8 @@ import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; -import buildcraft.api.core.Position; -import buildcraft.api.power.IPowerEmitter; -import buildcraft.api.power.IPowerReceptor; -import buildcraft.api.power.PowerHandler; -import buildcraft.api.power.PowerHandler.PowerReceiver; -import buildcraft.api.transport.IPipeConnection; -import buildcraft.api.transport.IPipeTile.PipeType; - +import cofh.api.energy.EnergyStorage; +import cofh.api.energy.IEnergyHandler; import forestry.core.TemperatureState; import forestry.core.config.Defaults; import forestry.core.interfaces.IPowerHandler; @@ -36,7 +30,7 @@ import forestry.core.proxy.Proxies; import forestry.core.utils.BlockUtil; import forestry.plugins.PluginBuildCraft; -public abstract class Engine extends TileBase implements IPowerHandler, IPipeConnection, IPowerEmitter { +public abstract class Engine extends TileBase implements IEnergyHandler { @Override public PacketPayload getPacketPayload() { @@ -46,7 +40,7 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon payload.intPayload[0] = 1; else payload.intPayload[0] = 0; - payload.intPayload[1] = (int) storedEnergy; + payload.intPayload[1] = energyStorage.getEnergyStored(); payload.intPayload[2] = heat; payload.floatPayload[0] = pistonSpeedServer; @@ -56,11 +50,8 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon @Override public void fromPacketPayload(PacketPayload payload) { - if (payload.intPayload[0] > 0) - isActive = true; - else - isActive = false; - storedEnergy = payload.intPayload[1]; + isActive = payload.intPayload[0] > 0; + energyStorage.setEnergyStored(payload.intPayload[1]); heat = payload.intPayload[2]; pistonSpeedServer = payload.floatPayload[0]; @@ -78,19 +69,19 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon protected int currentOutput = 0; public final int maxEnergy; public final int maxEnergyExtracted; - public float storedEnergy; public int heat; protected final int maxHeat; protected boolean forceCooldown = false; public float progress; - private final PowerHandler powerProvider; + protected EnergyStorage energyStorage; public Engine(int maxHeat, int maxEnergy, int maxEnergyExtracted) { this.maxHeat = maxHeat; - this.maxEnergy = maxEnergy; - this.maxEnergyExtracted = maxEnergyExtracted; - powerProvider = new PowerHandler(this, PowerHandler.Type.ENGINE); - powerProvider.configure(10, 200, 10, 100000); + this.maxEnergy = maxEnergy * 10; //TODO Temporary until all are converted + this.maxEnergyExtracted = maxEnergyExtracted * 10; + energyStorage = new EnergyStorage(maxEnergy, maxEnergyExtracted); + //powerProvider = new PowerHandler(this, PowerHandler.Type.ENGINE); + //powerProvider.configure(10, 200, 10, 100000); } @@ -101,47 +92,20 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon } /** - * Adds energy - * - * @param addition + * @deprecated Use {@link cofh.api.energy.EnergyStorage#modifyEnergyStored(int)} instead */ + @Deprecated public void addEnergy(float addition) { - storedEnergy += addition; - - if (storedEnergy > maxEnergy) - storedEnergy = maxEnergy; + energyStorage.modifyEnergyStored((int)addition); } /** - * - * @param min Minimum energy to extract. Will return 0 if storedEnergy less - * than min. - * @param max Maximum energy to extract. - * @param doExtract Determines whether energy will actually be removed from - * the engine. - * - * @return + * @deprecated Use {@link #extractEnergy(net.minecraftforge.common.util.ForgeDirection, int, boolean)} instead */ + @Deprecated public double extractEnergy(double min, double max, boolean doExtract) { - if (storedEnergy < min) - return 0; - - double ceiling = max > maxEnergyExtracted ? maxEnergyExtracted : max; - - double extracted; - - if (storedEnergy >= ceiling) { - extracted = ceiling; - if (doExtract) - storedEnergy -= ceiling; - } else { - extracted = storedEnergy; - if (doExtract) - storedEnergy = 0; - } - - return extracted; - } + return energyStorage.extractEnergy((int)max, !doExtract); + } /** * Adds heat @@ -185,6 +149,9 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon @Override public void updateServerSide() { + //doWork appears to be called before updateServerSide, so it's contents have been moved to here. + energyStorage.modifyEnergyStored(energyStorage.getMaxReceive()); + TemperatureState energyState = getTemperatureState(); if (energyState == TemperatureState.MELTING && heat > 0) forceCooldown = true; @@ -192,9 +159,10 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon forceCooldown = false; // Determine targeted tile - Position posTarget = new Position(xCoord, yCoord, zCoord, this.getOrientation()); + /*Position posTarget = new Position(xCoord, yCoord, zCoord, this.getOrientation()); posTarget.moveForwards(1.0); - TileEntity tile = worldObj.getTileEntity((int) posTarget.x, (int) posTarget.y, (int) posTarget.z); + TileEntity tile = worldObj.getTileEntity((int) posTarget.x, (int) posTarget.y, (int) posTarget.z);*/ + TileEntity tile = worldObj.getTileEntity(xCoord + getOrientation().offsetX, yCoord + getOrientation().offsetY, zCoord + getOrientation().offsetZ); float newPistonSpeed = getPistonSpeed(); if (newPistonSpeed != pistonSpeedServer) { @@ -209,12 +177,12 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon if (progress > 0.5 && stagePiston == 1) { stagePiston = 2; - if (BlockUtil.isPoweredTile(getOrientation().getOpposite(), tile)) { - IPowerReceptor receptor = (IPowerReceptor) tile; - double extractedEnergy = extractEnergy(receptor.getPowerReceiver(getOrientation().getOpposite()).getMinEnergyReceived(), receptor.getPowerReceiver(getOrientation().getOpposite()).getMaxEnergyReceived(), - true); + if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { + IEnergyHandler receptor = (IEnergyHandler) tile; + int extractedEnergy = extractEnergy(getOrientation(), energyStorage.getMaxExtract(), false); //TODO What should I pass in here? if (extractedEnergy > 0) - PluginBuildCraft.instance.invokeReceiveEnergyMethod(PowerHandler.Type.ENGINE, receptor.getPowerReceiver(getOrientation().getOpposite()), extractedEnergy, getOrientation().getOpposite()); + //PluginBuildCraft.instance.invokeReceiveEnergyMethod(PowerHandler.Type.ENGINE, receptor.getPowerReceiver(getOrientation().getOpposite()), extractedEnergy, getOrientation().getOpposite()); + receptor.receiveEnergy(getOrientation().getOpposite(), extractedEnergy, false); // receptor.getPowerProvider().receiveEnergy(extractedEnergy); } @@ -224,8 +192,8 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon } } else if (canPowerTo(tile)) { // If we are not already running, check if - IPowerReceptor receptor = (IPowerReceptor) tile; - if (extractEnergy(receptor.getPowerReceiver(getOrientation().getOpposite()).getMinEnergyReceived(), receptor.getPowerReceiver(getOrientation().getOpposite()).getMaxEnergyReceived(), false) > 0) { + IEnergyHandler receptor = (IEnergyHandler) tile; + if (extractEnergy(getOrientation(), energyStorage.getMaxExtract(), true) > 0) { stagePiston = 1; // If we can transfer energy, start running setActive(true); } else @@ -244,7 +212,7 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon } private boolean canPowerTo(TileEntity tile) { - return isActivated() && BlockUtil.isPoweredTile(getOrientation().getOpposite(), tile); + return isActivated() && BlockUtil.isRFTile(getOrientation().getOpposite(), tile); } private void setActive(boolean isActive) { @@ -261,12 +229,13 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon for (int i = getOrientation().ordinal() + 1; i <= getOrientation().ordinal() + 6; ++i) { ForgeDirection orient = ForgeDirection.values()[i % 6]; - Position pos = new Position(xCoord, yCoord, zCoord, orient); + /*Position pos = new Position(xCoord, yCoord, zCoord, orient); pos.moveForwards(1.0F); - TileEntity tile = worldObj.getTileEntity((int) pos.x, (int) pos.y, (int) pos.z); + TileEntity tile = worldObj.getTileEntity((int) pos.x, (int) pos.y, (int) pos.z);*/ + TileEntity tile = worldObj.getTileEntity(xCoord + orient.offsetX, yCoord + orient.offsetY, zCoord + orient.offsetZ); - if (BlockUtil.isPoweredTile(getOrientation().getOpposite(), tile)) { + if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { setOrientation(orient); worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, worldObj.getBlock(xCoord, yCoord, zCoord)); worldObj.func_147479_m(xCoord, yCoord, zCoord); @@ -297,8 +266,12 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon return 0; } + /** + * @deprecated Use {@link #getEnergyStored(net.minecraftforge.common.util.ForgeDirection)} instead + */ + @Deprecated public float getEnergyStored() { - return storedEnergy; + return energyStorage.getEnergyStored(); } public int getHeat() { @@ -356,12 +329,13 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon @Override public void readFromNBT(NBTTagCompound nbt) { super.readFromNBT(nbt); + energyStorage.readFromNBT(nbt); heat = nbt.getInteger("EngineHeat"); - if (nbt.hasKey("EngineStoredEnergy")) + /*if (nbt.hasKey("EngineStoredEnergy")) storedEnergy = nbt.getInteger("EngineStoredEnergy"); else - storedEnergy = nbt.getFloat("EngineStored"); + storedEnergy = nbt.getFloat("EngineStored");*/ progress = nbt.getFloat("EngineProgress"); forceCooldown = nbt.getBoolean("ForceCooldown"); @@ -370,9 +344,10 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon @Override public void writeToNBT(NBTTagCompound nbt) { super.writeToNBT(nbt); + energyStorage.writeToNBT(nbt); nbt.setInteger("EngineHeat", heat); - nbt.setFloat("EngineStored", storedEnergy); + //nbt.setFloat("EngineStored", storedEnergy); nbt.setFloat("EngineProgress", progress); nbt.setBoolean("ForceCooldown", forceCooldown); } @@ -382,38 +357,37 @@ public abstract class Engine extends TileBase implements IPowerHandler, IPipeCon public abstract void sendGUINetworkData(Container containerEngine, ICrafting iCrafting); - /* IPOWERRECEPTOR */ - @Override - public PowerReceiver getPowerReceiver(ForgeDirection side) { - return powerProvider.getPowerReceiver(); - } - - @Override - public PowerHandler getPowerHandler() { - return powerProvider; - } - - @Override + /*@Override public void doWork(PowerHandler workProvider) { if (!Proxies.common.isSimulating(worldObj)) return; addEnergy((int) (PluginBuildCraft.instance.invokeUseEnergyMethod(workProvider, 1, maxEnergyReceived(), true) * 0.95F)); - } - /* IPIPECONNECTION */ - @Override - public ConnectOverride overridePipeConnection(PipeType type, ForgeDirection with) { - if (type == PipeType.POWER) - return ConnectOverride.DEFAULT; - if (with == getOrientation()) - return ConnectOverride.DISCONNECT; - return ConnectOverride.DEFAULT; - } + }*/ - /* IPOWEREMITTER */ - @Override - public boolean canEmitPowerFrom(ForgeDirection side) { - return side == getOrientation(); - } + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + return 0; + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + return energyStorage.extractEnergy(maxExtract, simulate); //TODO + } + + @Override + public int getEnergyStored(ForgeDirection from) { + return energyStorage.getEnergyStored(); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + return energyStorage.getMaxEnergyStored(); + } + + @Override + public boolean canConnectEnergy(ForgeDirection from) { + return from == getOrientation(); + } } diff --git a/src/main/java/forestry/core/utils/BlockUtil.java b/src/main/java/forestry/core/utils/BlockUtil.java index 51e652a8f..de34903a8 100755 --- a/src/main/java/forestry/core/utils/BlockUtil.java +++ b/src/main/java/forestry/core/utils/BlockUtil.java @@ -34,6 +34,7 @@ import buildcraft.api.transport.IPipeConnection.ConnectOverride; import buildcraft.api.transport.IPipeTile; import buildcraft.api.transport.IPipeTile.PipeType; +import cofh.api.energy.IEnergyHandler; import forestry.core.config.Defaults; public class BlockUtil { @@ -146,6 +147,10 @@ public class BlockUtil { return false; } + /** + * @deprecated To be removed when MJ is gone. Use {@link #isRFTile} for now. + */ + @Deprecated public static boolean isPoweredTile(ForgeDirection side, TileEntity tile) { if (tile == null) return false; @@ -157,6 +162,17 @@ public class BlockUtil { return receptor.getPowerReceiver(side) != null; } + public static boolean isRFTile(ForgeDirection side, TileEntity tile) { + if (tile == null) + return false; + + if (!(tile instanceof IEnergyHandler)) + return false; + + IEnergyHandler receptor = (IEnergyHandler) tile; + return receptor.canConnectEnergy(side); + } + public static boolean tryPlantPot(World world, int x, int y, int z, Block block) { int direction = getDirectionalMetadata(world, x, y, z); diff --git a/src/main/java/forestry/energy/gadgets/EngineBronze.java b/src/main/java/forestry/energy/gadgets/EngineBronze.java index ebc286a13..5028c3dc3 100755 --- a/src/main/java/forestry/energy/gadgets/EngineBronze.java +++ b/src/main/java/forestry/energy/gadgets/EngineBronze.java @@ -167,7 +167,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa if (burnTime > 0) { burnTime--; currentOutput = determineFuelValue(FluidRegistry.getFluid(currentFluidId)); - addEnergy(currentOutput); + energyStorage.modifyEnergyStored(currentOutput); } else { burnTime = totalTime = this.determineBurnTime(fuelTank.getFluid().getFluid()); currentFluidId = fuelTank.getFluid().getFluid().getID(); @@ -353,7 +353,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa currentOutput = data; break; case 3: - storedEnergy = data; + energyStorage.setEnergyStored(data); break; case 4: heat = data; @@ -370,7 +370,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa iCrafting.sendProgressBarUpdate(containerEngine, i, burnTime); iCrafting.sendProgressBarUpdate(containerEngine, i + 1, totalTime); iCrafting.sendProgressBarUpdate(containerEngine, i + 2, currentOutput); - iCrafting.sendProgressBarUpdate(containerEngine, i + 3, (int) storedEnergy); + iCrafting.sendProgressBarUpdate(containerEngine, i + 3, energyStorage.getEnergyStored()); iCrafting.sendProgressBarUpdate(containerEngine, i + 4, heat); iCrafting.sendProgressBarUpdate(containerEngine, i + 5, currentFluidId); } diff --git a/src/main/java/forestry/energy/gadgets/EngineClockwork.java b/src/main/java/forestry/energy/gadgets/EngineClockwork.java index 2f380e99a..9a39d0153 100755 --- a/src/main/java/forestry/energy/gadgets/EngineClockwork.java +++ b/src/main/java/forestry/energy/gadgets/EngineClockwork.java @@ -29,7 +29,7 @@ public class EngineClockwork extends Engine { private final static int WIND_DELAY = 10; private static final int ENGINE_CLOCKWORK_HEAT_MAX = 300000; - private static final float ENGINE_CLOCKWORK_ENERGY_PER_CYCLE = 0.25f; + private static final int ENGINE_CLOCKWORK_ENERGY_PER_CYCLE = 2; private static final float ENGINE_CLOCKWORK_WIND_MAX = 8f; private static final DamageSourceForestry damageSourceEngineClockwork = new DamageSourceForestry("engine.clockwork"); @@ -112,7 +112,7 @@ public class EngineClockwork extends Engine { tension *= 0.9995f; else tension = 0; - addEnergy(ENGINE_CLOCKWORK_ENERGY_PER_CYCLE * tension); + energyStorage.modifyEnergyStored(ENGINE_CLOCKWORK_ENERGY_PER_CYCLE * (int)tension); } @Override @@ -142,7 +142,7 @@ public class EngineClockwork extends Engine { return 0; float fromClockwork = (tension / ENGINE_CLOCKWORK_WIND_MAX) * Defaults.ENGINE_PISTON_SPEED_MAX; - return fromClockwork >= 0.01f ? fromClockwork : storedEnergy > 0 ? 0.01f : 0; + return fromClockwork >= 0.01f ? fromClockwork : energyStorage.getEnergyStored() > 0 ? 0.01f : 0; } @Override public void getGUINetworkData(int i, int j) {} diff --git a/src/main/java/forestry/energy/gadgets/EngineCopper.java b/src/main/java/forestry/energy/gadgets/EngineCopper.java index 3a3203e1e..7b89775b3 100755 --- a/src/main/java/forestry/energy/gadgets/EngineCopper.java +++ b/src/main/java/forestry/energy/gadgets/EngineCopper.java @@ -133,7 +133,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv if (isActivated()) { currentOutput = determineFuelValue(new ItemStack(fuelItem, 1, fuelItemMeta)); - addEnergy(currentOutput); + energyStorage.modifyEnergyStored(currentOutput); } } else if (isActivated()) { int fuelslot = getFuelSlot(); @@ -174,7 +174,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv if (isBurning()) { heat++; - if (((double) storedEnergy / (double) maxEnergy) > 0.5) + if (((double) energyStorage.getEnergyStored() / (double) maxEnergy) > 0.5) heat++; } @@ -333,7 +333,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv currentOutput = j; break; case 3: - storedEnergy = j; + energyStorage.setEnergyStored(j); break; case 4: heat = j; @@ -346,7 +346,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv iCrafting.sendProgressBarUpdate(containerEngine, 0, burnTime); iCrafting.sendProgressBarUpdate(containerEngine, 1, totalBurnTime); iCrafting.sendProgressBarUpdate(containerEngine, 2, currentOutput); - iCrafting.sendProgressBarUpdate(containerEngine, 3, (int)storedEnergy); + iCrafting.sendProgressBarUpdate(containerEngine, 3, energyStorage.getEnergyStored()); iCrafting.sendProgressBarUpdate(containerEngine, 4, heat); } diff --git a/src/main/java/forestry/energy/gadgets/EngineTin.java b/src/main/java/forestry/energy/gadgets/EngineTin.java index b138b889f..cad13807b 100755 --- a/src/main/java/forestry/energy/gadgets/EngineTin.java +++ b/src/main/java/forestry/energy/gadgets/EngineTin.java @@ -39,13 +39,13 @@ public class EngineTin extends Engine implements ISocketable, IInventory { protected static class EuConfig { public int euForCycle; - public int mjPerCycle; + public int rfPerCycle; public int euStorage; public int euMaxAccept = 512; - public EuConfig(int euForCycle, int mjPerCycle, int euStorage) { + public EuConfig(int euForCycle, int rfPerCycle, int euStorage) { this.euForCycle = euForCycle; - this.mjPerCycle = mjPerCycle; + this.rfPerCycle = rfPerCycle; this.euStorage = euStorage; } } @@ -136,7 +136,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { int gain = 0; if (isActivated() && isBurning()) { gain++; - if (((double) storedEnergy / (double) maxEnergy) > 0.5) + if (((double) energyStorage.getEnergyStored() / (double) maxEnergy) > 0.5) gain++; } @@ -184,8 +184,8 @@ public class EngineTin extends Engine implements ISocketable, IInventory { return; if (ic2EnergySink.useEnergy(euConfig.euForCycle)) { - currentOutput = euConfig.mjPerCycle; - addEnergy(euConfig.mjPerCycle); + currentOutput = euConfig.rfPerCycle; + energyStorage.modifyEnergyStored(euConfig.rfPerCycle); } } @@ -233,7 +233,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { currentOutput = j; break; case 1: - storedEnergy = j; + energyStorage.setEnergyStored(j); break; case 2: heat = j; @@ -248,7 +248,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { @Override public void sendGUINetworkData(Container containerEngine, ICrafting iCrafting) { iCrafting.sendProgressBarUpdate(containerEngine, 0, currentOutput); - iCrafting.sendProgressBarUpdate(containerEngine, 1, (int)storedEnergy); + iCrafting.sendProgressBarUpdate(containerEngine, 1, energyStorage.getEnergyStored()); iCrafting.sendProgressBarUpdate(containerEngine, 2, heat); if (ic2EnergySink != null) { iCrafting.sendProgressBarUpdate(containerEngine, 3, (short) ic2EnergySink.getEnergyStored()); @@ -258,7 +258,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { // / ENERGY CONFIG CHANGE public void changeEnergyConfig(int euChange, int mjChange, int storageChange) { euConfig.euForCycle += euChange; - euConfig.mjPerCycle += mjChange; + euConfig.rfPerCycle += mjChange; euConfig.euStorage += storageChange; if (ic2EnergySink != null) ic2EnergySink.setCapacity(euConfig.euStorage); From 76cd4941d5db9a1c6b452daffd1c8c30b0f10b74 Mon Sep 17 00:00:00 2001 From: Parker Young Date: Sat, 20 Sep 2014 16:31:02 -0400 Subject: [PATCH 11/37] Updated to Forestry 167 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 1d6d1d2b9..648a7c8ec 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.158-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.167-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From 5545bd870699dd45333a0ef16b92de6d39204699 Mon Sep 17 00:00:00 2001 From: Parker Young Date: Sat, 20 Sep 2014 19:55:37 -0400 Subject: [PATCH 12/37] Fixing tooltips and other general things Also updated to latest Forestry. --- build.gradle | 2 +- .../java/forestry/core/gadgets/Engine.java | 20 +------------------ .../forestry/energy/gadgets/EngineBronze.java | 2 +- .../forestry/energy/gadgets/EngineCopper.java | 2 +- .../java/forestry/energy/gui/GuiEngine.java | 6 +++--- 5 files changed, 7 insertions(+), 25 deletions(-) diff --git a/build.gradle b/build.gradle index 648a7c8ec..743828763 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.167-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.169-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index 9f76de487..2c3cc9f9a 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -84,29 +84,11 @@ public abstract class Engine extends TileBase implements IEnergyHandler { //powerProvider.configure(10, 200, 10, 100000); } - - @Override public void rotateAfterPlacement(World world, int x, int y, int z, EntityLivingBase entityliving, ItemStack itemstack) { rotateEngine(); } - /** - * @deprecated Use {@link cofh.api.energy.EnergyStorage#modifyEnergyStored(int)} instead - */ - @Deprecated - public void addEnergy(float addition) { - energyStorage.modifyEnergyStored((int)addition); - } - - /** - * @deprecated Use {@link #extractEnergy(net.minecraftforge.common.util.ForgeDirection, int, boolean)} instead - */ - @Deprecated - public double extractEnergy(double min, double max, boolean doExtract) { - return energyStorage.extractEnergy((int)max, !doExtract); - } - /** * Adds heat * @@ -207,7 +189,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { if (mayBurn()) burn(); else - extractEnergy(0, 2, true); + energyStorage.extractEnergy(2, false); } diff --git a/src/main/java/forestry/energy/gadgets/EngineBronze.java b/src/main/java/forestry/energy/gadgets/EngineBronze.java index 5028c3dc3..8c77acb2a 100755 --- a/src/main/java/forestry/energy/gadgets/EngineBronze.java +++ b/src/main/java/forestry/energy/gadgets/EngineBronze.java @@ -238,7 +238,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa */ private int determineFuelValue(Fluid fluid) { if (FuelManager.bronzeEngineFuel.containsKey(fluid)) - return FuelManager.bronzeEngineFuel.get(fluid).powerPerCycle; + return FuelManager.bronzeEngineFuel.get(fluid).powerPerCycle * 10; //Too Lazy to change all the numbers to RF, so just doing this. else return 0; } diff --git a/src/main/java/forestry/energy/gadgets/EngineCopper.java b/src/main/java/forestry/energy/gadgets/EngineCopper.java index 7b89775b3..bd1c46936 100755 --- a/src/main/java/forestry/energy/gadgets/EngineCopper.java +++ b/src/main/java/forestry/energy/gadgets/EngineCopper.java @@ -209,7 +209,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv */ private int determineFuelValue(ItemStack fuel) { if (FuelManager.copperEngineFuel.containsKey(fuel)) - return FuelManager.copperEngineFuel.get(fuel).powerPerCycle; + return FuelManager.copperEngineFuel.get(fuel).powerPerCycle * 10; //Too Lazy to change all the numbers to RF, so just doing this. else return 0; } diff --git a/src/main/java/forestry/energy/gui/GuiEngine.java b/src/main/java/forestry/energy/gui/GuiEngine.java index 5646a44a3..2358d7a3d 100755 --- a/src/main/java/forestry/energy/gui/GuiEngine.java +++ b/src/main/java/forestry/energy/gui/GuiEngine.java @@ -47,9 +47,9 @@ public abstract class GuiEngine extends GuiForestryTitled { fontRendererObj.drawStringWithShadow(StringUtil.localize("gui.energy"), x + 22, y + 8, fontColor.get("ledger.power.header")); fontRendererObj.drawStringWithShadow(StringUtil.localize("gui.currentOutput") + ":", x + 22, y + 20, fontColor.get("ledger.power.subheader")); - fontRendererObj.drawString(engine.getCurrentOutput() + " MJ/t", x + 22, y + 32, fontColor.get("ledger.power.text")); + fontRendererObj.drawString(engine.getCurrentOutput() + " RF/t", x + 22, y + 32, fontColor.get("ledger.power.text")); fontRendererObj.drawStringWithShadow(StringUtil.localize("gui.stored") + ":", x + 22, y + 44, fontColor.get("ledger.power.subheader")); - fontRendererObj.drawString(engine.getEnergyStored() + " MJ", x + 22, y + 56, fontColor.get("ledger.power.text")); + fontRendererObj.drawString(engine.getEnergyStored(engine.getOrientation()) + " RF", x + 22, y + 56, fontColor.get("ledger.power.text")); fontRendererObj.drawStringWithShadow(StringUtil.localize("gui.heat") + ":", x + 22, y + 68, fontColor.get("ledger.power.subheader")); fontRendererObj.drawString((((double) engine.getHeat() / (double) 10) + 20.0) + " C", x + 22, y + 80, fontColor.get("ledger.power.text")); @@ -57,7 +57,7 @@ public abstract class GuiEngine extends GuiForestryTitled { @Override public String getTooltip() { - return engine.getCurrentOutput() + " MJ/t"; + return engine.getCurrentOutput() + " RF/t"; } } From 51aef06564fc1b1fccbc56891cfd087ef75c2c3d Mon Sep 17 00:00:00 2001 From: Parker Young Date: Sat, 20 Sep 2014 21:10:24 -0400 Subject: [PATCH 13/37] Fixed engines generating energy without being active. Whoops. --- src/main/java/forestry/core/gadgets/Engine.java | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index 2c3cc9f9a..bf5a4ecd0 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -132,7 +132,9 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public void updateServerSide() { //doWork appears to be called before updateServerSide, so it's contents have been moved to here. - energyStorage.modifyEnergyStored(energyStorage.getMaxReceive()); + if(isActive) { + energyStorage.modifyEnergyStored(energyStorage.getMaxReceive()); + } TemperatureState energyState = getTemperatureState(); if (energyState == TemperatureState.MELTING && heat > 0) @@ -248,14 +250,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { return 0; } - /** - * @deprecated Use {@link #getEnergyStored(net.minecraftforge.common.util.ForgeDirection)} instead - */ - @Deprecated - public float getEnergyStored() { - return energyStorage.getEnergyStored(); - } - public int getHeat() { return heat; } From d212fb75ddfff97de29987ea287b8c50a50a2d17 Mon Sep 17 00:00:00 2001 From: Parker Young Date: Sun, 21 Sep 2014 12:18:29 -0400 Subject: [PATCH 14/37] Updated to Forestry 172 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 743828763..d8a212174 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.169-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.172-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From 301d19e00d50c11ced822fa1fc773037bd402f2b Mon Sep 17 00:00:00 2001 From: Parker Young Date: Sun, 21 Sep 2014 19:19:05 -0400 Subject: [PATCH 15/37] Updated to Forestry 173 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index d8a212174..72be05d61 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.172-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = "3.0.0.173-RF-" + System.getenv("DRONE_BUILD_NUMBER") group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From 0163031bf1b894fae93b35e5a22f097755fe93f6 Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 20:33:30 -0700 Subject: [PATCH 16/37] Engine *10 cleanup --- src/main/java/forestry/core/config/Defaults.java | 16 ++++++++-------- src/main/java/forestry/core/gadgets/Engine.java | 6 +++--- .../forestry/energy/gadgets/EngineBronze.java | 4 ++-- .../forestry/energy/gadgets/EngineClockwork.java | 2 +- .../forestry/energy/gadgets/EngineCopper.java | 4 ++-- .../java/forestry/energy/gadgets/EngineTin.java | 2 +- 6 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/main/java/forestry/core/config/Defaults.java b/src/main/java/forestry/core/config/Defaults.java index bf7c5b843..bfcf6137d 100755 --- a/src/main/java/forestry/core/config/Defaults.java +++ b/src/main/java/forestry/core/config/Defaults.java @@ -177,12 +177,12 @@ public class Defaults { public static final int ENGINE_CYCLE_DURATION_SEED_OIL = 2500; public static final int ENGINE_CYCLE_DURATION_BIOMASS = 2500; public static final int ENGINE_CYCLE_DURATION_ETHANOL = 15000; - public static final int ENGINE_FUEL_VALUE_WATER = 1; - public static final int ENGINE_FUEL_VALUE_JUICE = 1; - public static final int ENGINE_FUEL_VALUE_HONEY = 2; - public static final int ENGINE_FUEL_VALUE_MILK = 1; - public static final int ENGINE_FUEL_VALUE_SEED_OIL = 3; - public static final int ENGINE_FUEL_VALUE_BIOMASS = 5; + public static final int ENGINE_FUEL_VALUE_WATER = 10; + public static final int ENGINE_FUEL_VALUE_JUICE = 10; + public static final int ENGINE_FUEL_VALUE_HONEY = 20; + public static final int ENGINE_FUEL_VALUE_MILK = 10; + public static final int ENGINE_FUEL_VALUE_SEED_OIL = 30; + public static final int ENGINE_FUEL_VALUE_BIOMASS = 50; public static final int ENGINE_HEAT_VALUE_LAVA = 20; public static final float ENGINE_PISTON_SPEED_MAX = 0.08f; @@ -194,9 +194,9 @@ public class Defaults { public static final int ENGINE_BRONZE_HEAT_GENERATION_ENERGY = 1; public static final int ENGINE_COPPER_CYCLE_DURATION_PEAT = 5000; - public static final int ENGINE_COPPER_FUEL_VALUE_PEAT = 1; + public static final int ENGINE_COPPER_FUEL_VALUE_PEAT = 10; public static final int ENGINE_COPPER_CYCLE_DURATION_BITUMINOUS_PEAT = 6000; - public static final int ENGINE_COPPER_FUEL_VALUE_BITUMINOUS_PEAT = 2; + public static final int ENGINE_COPPER_FUEL_VALUE_BITUMINOUS_PEAT = 20; public static final int ENGINE_COPPER_HEAT_MAX = 10000; public static final int ENGINE_COPPER_ASH_FOR_ITEM = 7500; diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index bf5a4ecd0..dec1873ba 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -77,8 +77,8 @@ public abstract class Engine extends TileBase implements IEnergyHandler { public Engine(int maxHeat, int maxEnergy, int maxEnergyExtracted) { this.maxHeat = maxHeat; - this.maxEnergy = maxEnergy * 10; //TODO Temporary until all are converted - this.maxEnergyExtracted = maxEnergyExtracted * 10; + this.maxEnergy = maxEnergy; + this.maxEnergyExtracted = maxEnergyExtracted; energyStorage = new EnergyStorage(maxEnergy, maxEnergyExtracted); //powerProvider = new PowerHandler(this, PowerHandler.Type.ENGINE); //powerProvider.configure(10, 200, 10, 100000); @@ -191,7 +191,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { if (mayBurn()) burn(); else - energyStorage.extractEnergy(2, false); + energyStorage.extractEnergy(20, false); } diff --git a/src/main/java/forestry/energy/gadgets/EngineBronze.java b/src/main/java/forestry/energy/gadgets/EngineBronze.java index 8c77acb2a..7a2ffa03f 100755 --- a/src/main/java/forestry/energy/gadgets/EngineBronze.java +++ b/src/main/java/forestry/energy/gadgets/EngineBronze.java @@ -81,7 +81,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa private boolean shutdown; public EngineBronze() { - super(Defaults.ENGINE_BRONZE_HEAT_MAX, 30000, 500); + super(Defaults.ENGINE_BRONZE_HEAT_MAX, 300000, 5000); setHints(Config.hints.get("engine.bronze")); inventory = new TileInventoryAdapter(this, 1, "Items"); @@ -238,7 +238,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa */ private int determineFuelValue(Fluid fluid) { if (FuelManager.bronzeEngineFuel.containsKey(fluid)) - return FuelManager.bronzeEngineFuel.get(fluid).powerPerCycle * 10; //Too Lazy to change all the numbers to RF, so just doing this. + return FuelManager.bronzeEngineFuel.get(fluid).powerPerCycle; else return 0; } diff --git a/src/main/java/forestry/energy/gadgets/EngineClockwork.java b/src/main/java/forestry/energy/gadgets/EngineClockwork.java index 9a39d0153..7ed2ad196 100755 --- a/src/main/java/forestry/energy/gadgets/EngineClockwork.java +++ b/src/main/java/forestry/energy/gadgets/EngineClockwork.java @@ -38,7 +38,7 @@ public class EngineClockwork extends Engine { private short delay = 0; public EngineClockwork() { - super(ENGINE_CLOCKWORK_HEAT_MAX, 1000, 50); + super(ENGINE_CLOCKWORK_HEAT_MAX, 10000, 500); } @Override diff --git a/src/main/java/forestry/energy/gadgets/EngineCopper.java b/src/main/java/forestry/energy/gadgets/EngineCopper.java index bd1c46936..e5994bb5e 100755 --- a/src/main/java/forestry/energy/gadgets/EngineCopper.java +++ b/src/main/java/forestry/energy/gadgets/EngineCopper.java @@ -61,7 +61,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv private final TileInventoryAdapter inventory; public EngineCopper() { - super(Defaults.ENGINE_COPPER_HEAT_MAX, 20000, 400); + super(Defaults.ENGINE_COPPER_HEAT_MAX, 200000, 4000); setHints(Config.hints.get("engine.copper")); ashForItem = Defaults.ENGINE_COPPER_ASH_FOR_ITEM; @@ -209,7 +209,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv */ private int determineFuelValue(ItemStack fuel) { if (FuelManager.copperEngineFuel.containsKey(fuel)) - return FuelManager.copperEngineFuel.get(fuel).powerPerCycle * 10; //Too Lazy to change all the numbers to RF, so just doing this. + return FuelManager.copperEngineFuel.get(fuel).powerPerCycle; else return 0; } diff --git a/src/main/java/forestry/energy/gadgets/EngineTin.java b/src/main/java/forestry/energy/gadgets/EngineTin.java index cad13807b..ec046ff64 100755 --- a/src/main/java/forestry/energy/gadgets/EngineTin.java +++ b/src/main/java/forestry/energy/gadgets/EngineTin.java @@ -60,7 +60,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { private final DelayTimer delayUpdateTimer = new DelayTimer(); public EngineTin() { - super(Defaults.ENGINE_TIN_HEAT_MAX, 10000, 400); + super(Defaults.ENGINE_TIN_HEAT_MAX, 100000, 4000); setHints(Config.hints.get("engine.tin")); if (PluginIC2.instance.isAvailable()) ic2EnergySink = new BasicSink(this, euConfig.euStorage, 3); From 956e53dc66c4c1842f4868ab016d0375ab7565e3 Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 20:34:37 -0700 Subject: [PATCH 17/37] Build up engine storage correctly --- .../java/forestry/core/gadgets/Engine.java | 24 +++++-------------- 1 file changed, 6 insertions(+), 18 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index dec1873ba..6b16a9c3c 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -24,11 +24,8 @@ import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyHandler; import forestry.core.TemperatureState; import forestry.core.config.Defaults; -import forestry.core.interfaces.IPowerHandler; import forestry.core.network.PacketPayload; -import forestry.core.proxy.Proxies; import forestry.core.utils.BlockUtil; -import forestry.plugins.PluginBuildCraft; public abstract class Engine extends TileBase implements IEnergyHandler { @@ -131,11 +128,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public void updateServerSide() { - //doWork appears to be called before updateServerSide, so it's contents have been moved to here. - if(isActive) { - energyStorage.modifyEnergyStored(energyStorage.getMaxReceive()); - } - TemperatureState energyState = getTemperatureState(); if (energyState == TemperatureState.MELTING && heat > 0) forceCooldown = true; @@ -143,9 +135,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { forceCooldown = false; // Determine targeted tile - /*Position posTarget = new Position(xCoord, yCoord, zCoord, this.getOrientation()); - posTarget.moveForwards(1.0); - TileEntity tile = worldObj.getTileEntity((int) posTarget.x, (int) posTarget.y, (int) posTarget.z);*/ TileEntity tile = worldObj.getTileEntity(xCoord + getOrientation().offsetX, yCoord + getOrientation().offsetY, zCoord + getOrientation().offsetZ); float newPistonSpeed = getPistonSpeed(); @@ -163,11 +152,11 @@ public abstract class Engine extends TileBase implements IEnergyHandler { if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { IEnergyHandler receptor = (IEnergyHandler) tile; - int extractedEnergy = extractEnergy(getOrientation(), energyStorage.getMaxExtract(), false); //TODO What should I pass in here? - if (extractedEnergy > 0) - //PluginBuildCraft.instance.invokeReceiveEnergyMethod(PowerHandler.Type.ENGINE, receptor.getPowerReceiver(getOrientation().getOpposite()), extractedEnergy, getOrientation().getOpposite()); - receptor.receiveEnergy(getOrientation().getOpposite(), extractedEnergy, false); - // receptor.getPowerProvider().receiveEnergy(extractedEnergy); + int extractable = extractEnergy(getOrientation(), energyStorage.getMaxExtract(), true); + if (extractable > 0) { + int extracted = receptor.receiveEnergy(getOrientation().getOpposite(), extractable, false); + extractEnergy(getOrientation(), extracted, false); + } } } else if (progress >= 1) { @@ -176,8 +165,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { } } else if (canPowerTo(tile)) { // If we are not already running, check if - IEnergyHandler receptor = (IEnergyHandler) tile; - if (extractEnergy(getOrientation(), energyStorage.getMaxExtract(), true) > 0) { + if (extractEnergy(getOrientation(), 1, true) > 0) { stagePiston = 1; // If we can transfer energy, start running setActive(true); } else From e89e8b4f9d4259840de8bc148f55b587be2b80ef Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 20:35:41 -0700 Subject: [PATCH 18/37] Make engines output their energy on downstroke and upstroke --- src/main/java/forestry/core/gadgets/Engine.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index 6b16a9c3c..6b58481f8 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -147,7 +147,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { progress += pistonSpeedServer; - if (progress > 0.5 && stagePiston == 1) { + if (progress > 0.25 && stagePiston == 1) { stagePiston = 2; if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { @@ -159,7 +159,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { } } - } else if (progress >= 1) { + } else if (progress >= 0.5) { progress = 0; stagePiston = 0; } From 4e8a25d55c39f4cce120eeeb4eca0a96210e05cb Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 21:09:48 -0700 Subject: [PATCH 19/37] Fixed machines working without power --- src/main/java/forestry/core/gadgets/TilePowered.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index fd0324595..30193eb30 100755 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -127,7 +127,7 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine ic2registered = true; } - if (workCounter < WORK_CYCLES) { + if (workCounter < WORK_CYCLES && energyStorage.getEnergyStored() >= ENERGY_PER_USE) { energyStorage.modifyEnergyStored(-ENERGY_PER_USE); //TODO Make it continuous usage while doing work workCounter++; } From 09acd8e778734c775f3d791a2a3906b6325fe104 Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 21:16:29 -0700 Subject: [PATCH 20/37] Cleanup in TilePowered --- .../forestry/core/gadgets/TilePowered.java | 28 ++++++++++++++----- 1 file changed, 21 insertions(+), 7 deletions(-) mode change 100755 => 100644 src/main/java/forestry/core/gadgets/TilePowered.java diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java old mode 100755 new mode 100644 index 30193eb30..ae8247636 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -35,7 +35,6 @@ import forestry.core.fluids.tanks.StandardTank; public abstract class TilePowered extends TileBase implements IRenderableMachine, IEnergySink, IEnergyHandler { public static int WORK_CYCLES = 4; - public static int ENERGY_PER_USE = 150; //Temporary @Override public PacketPayload getPacketPayload() { @@ -72,12 +71,27 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine } } protected EnergyStorage energyStorage; + public int energyPerUse; - public TilePowered() { - energyStorage = new EnergyStorage(5000); - //energyStorage.setCapacity(Math.round(energyStorage.getMaxEnergyStored() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier"))); + public TilePowered() { + this(5000, 150); } + public TilePowered(int defaultCapacity, int defaultEnergyPerUse) { + this(defaultCapacity, defaultEnergyPerUse, defaultCapacity); + } + + public TilePowered(int defaultCapacity, int defaultEnergyPerUse, int defaultMaxTransfer) { + this.energyPerUse = scaleEnergyByDifficulty(defaultEnergyPerUse); + int capacity = scaleEnergyByDifficulty(defaultCapacity); + int maxTransfer = scaleEnergyByDifficulty(defaultMaxTransfer); + energyStorage = new EnergyStorage(capacity, maxTransfer); + } + + private static int scaleEnergyByDifficulty(int energyPerUse) { + return Math.round(energyPerUse * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")); + } + /*private final PowerHandler powerHandler; public TilePowered() { @@ -119,7 +133,7 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine @Override public void updateEntity() { super.updateEntity(); - if (worldObj.isRemote || !Proxies.common.isSimulating(worldObj)) + if (!Proxies.common.isSimulating(worldObj)) return; if (!ic2registered) { @@ -127,8 +141,8 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine ic2registered = true; } - if (workCounter < WORK_CYCLES && energyStorage.getEnergyStored() >= ENERGY_PER_USE) { - energyStorage.modifyEnergyStored(-ENERGY_PER_USE); //TODO Make it continuous usage while doing work + if (workCounter < WORK_CYCLES && energyStorage.getEnergyStored() >= energyPerUse) { + energyStorage.modifyEnergyStored(-energyPerUse); //TODO Make it continuous usage while doing work workCounter++; } From 98925d79276098a479ac9f0fd050f5dc0aae4131 Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 21:25:00 -0700 Subject: [PATCH 21/37] Cleanup MachineFabricator --- .../forestry/factory/gadgets/MachineFabricator.java | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/src/main/java/forestry/factory/gadgets/MachineFabricator.java b/src/main/java/forestry/factory/gadgets/MachineFabricator.java index 6baa674d3..4f962a984 100755 --- a/src/main/java/forestry/factory/gadgets/MachineFabricator.java +++ b/src/main/java/forestry/factory/gadgets/MachineFabricator.java @@ -27,9 +27,6 @@ import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; -import buildcraft.api.power.PowerHandler; - -import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; import forestry.api.recipes.IFabricatorManager; @@ -239,26 +236,19 @@ public class MachineFabricator extends TilePowered implements ICrafter, ISpecial private final TankManager tankManager; private FilteredTank moltenTank; private final InventoryAdapter inventory = new InventoryAdapter(30, "Items"); - private final int moltenTankIndex; private int heat = 0; private int guiMeltingPoint = 0; private FluidStack pendingSmelt; public MachineFabricator() { - energyStorage = new EnergyStorage(3300); + super(3300, 50, 1100); Fluid liquidGlass = FluidRegistry.getFluid(Defaults.LIQUID_GLASS); moltenTank = new FilteredTank(2 * Defaults.BUCKET_VOLUME, liquidGlass); moltenTank.tankMode = StandardTank.TankMode.INTERNAL; tankManager = new TankManager(moltenTank); - moltenTankIndex = moltenTank.getTankIndex(); } - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(50, 110, 5, 330); - }*/ - @Override public String getInventoryName() { return getUnlocalizedName(); From 60fa471910d3a3fa1892bfb4b9c7f9c65bcde69f Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 21:36:13 -0700 Subject: [PATCH 22/37] Removed IC2 power from TilePowered --- .../forestry/core/gadgets/TilePowered.java | 54 +------------------ 1 file changed, 1 insertion(+), 53 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index ae8247636..2b01a5377 100644 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -12,14 +12,9 @@ package forestry.core.gadgets; import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyHandler; -import ic2.api.energy.event.EnergyTileLoadEvent; -import ic2.api.energy.event.EnergyTileUnloadEvent; -import ic2.api.energy.tile.IEnergySink; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.tileentity.TileEntity; -import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; @@ -32,7 +27,7 @@ import forestry.core.proxy.Proxies; import forestry.core.utils.EnumTankLevel; import forestry.core.fluids.tanks.StandardTank; -public abstract class TilePowered extends TileBase implements IRenderableMachine, IEnergySink, IEnergyHandler { +public abstract class TilePowered extends TileBase implements IRenderableMachine, IEnergyHandler { public static int WORK_CYCLES = 4; @@ -136,11 +131,6 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine if (!Proxies.common.isSimulating(worldObj)) return; - if (!ic2registered) { - MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this)); - ic2registered = true; - } - if (workCounter < WORK_CYCLES && energyStorage.getEnergyStored() >= energyPerUse) { energyStorage.modifyEnergyStored(-energyPerUse); //TODO Make it continuous usage while doing work workCounter++; @@ -223,46 +213,4 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine public boolean canConnectEnergy(ForgeDirection from) { return true; } - - // ======== EU SUPPORT ============ - - private boolean ic2registered = false; - - @Override - public void invalidate() { - if (ic2registered) { - MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); - ic2registered = false; - } - super.invalidate(); - } - - @Override - public void onChunkUnload() { - if (ic2registered) { - MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); - ic2registered = false; - } - super.onChunkUnload(); - } - - @Override - public double getDemandedEnergy() { - return (energyStorage.getMaxEnergyStored() - energyStorage.getEnergyStored()) / 4; - } - - @Override - public int getSinkTier() { - return 2; - } - - @Override - public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage) { - return energyStorage.receiveEnergy((int)(amount * 4), false); //TODO May want to do something other than casting - } - - @Override - public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) { - return true; - } } From 6cc67e2df5c7c51cb11113dce3675c2a55775285 Mon Sep 17 00:00:00 2001 From: mezz Date: Sun, 21 Sep 2014 23:48:20 -0700 Subject: [PATCH 23/37] Created EnergyManager to help replicate previous behaviors --- .../java/forestry/core/config/Defaults.java | 8 +- src/main/java/forestry/core/gadgets/Mill.java | 1 + .../forestry/core/gadgets/TilePowered.java | 43 ++----- .../java/forestry/energy/EnergyManager.java | 117 ++++++++++++++++++ .../factory/gadgets/MachineBottler.java | 8 +- .../factory/gadgets/MachineCarpenter.java | 7 +- .../factory/gadgets/MachineCentrifuge.java | 6 +- .../factory/gadgets/MachineFabricator.java | 2 +- .../factory/gadgets/MachineFermenter.java | 7 +- .../factory/gadgets/MachineMoistener.java | 1 + .../factory/gadgets/MachineSqueezer.java | 7 +- .../factory/gadgets/MachineStill.java | 7 +- 12 files changed, 143 insertions(+), 71 deletions(-) create mode 100644 src/main/java/forestry/energy/EnergyManager.java diff --git a/src/main/java/forestry/core/config/Defaults.java b/src/main/java/forestry/core/config/Defaults.java index bfcf6137d..8ae35daa0 100755 --- a/src/main/java/forestry/core/config/Defaults.java +++ b/src/main/java/forestry/core/config/Defaults.java @@ -210,10 +210,10 @@ public class Defaults { public static final int PROCESSOR_TANK_CAPACITY = 10 * BUCKET_VOLUME; public static final int MACHINE_LATENCY = 1000; - public static final int MACHINE_MIN_ENERGY_RECEIVED = 5; - public static final int MACHINE_MAX_ENERGY_RECEIVED = 40; - public static final int MACHINE_MIN_ACTIVATION_ENERGY = 15; - public static final int MACHINE_MAX_ENERGY = 500; + public static final int MACHINE_MIN_ENERGY_RECEIVED = 50; + public static final int MACHINE_MAX_ENERGY_RECEIVED = 400; + public static final int MACHINE_MIN_ACTIVATION_ENERGY = 150; + public static final int MACHINE_MAX_ENERGY = 5000; public static final int RAINMAKER_RAIN_DURATION_IODINE = 10000; diff --git a/src/main/java/forestry/core/gadgets/Mill.java b/src/main/java/forestry/core/gadgets/Mill.java index 27e81d45d..21742781b 100755 --- a/src/main/java/forestry/core/gadgets/Mill.java +++ b/src/main/java/forestry/core/gadgets/Mill.java @@ -23,6 +23,7 @@ public abstract class Mill extends TilePowered { public float progress; public Mill() { + super(0, 0, 0, 0); speed = 0.01F; } diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index 2b01a5377..823316618 100644 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -10,7 +10,6 @@ ******************************************************************************/ package forestry.core.gadgets; -import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyHandler; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; @@ -18,7 +17,6 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; -import forestry.core.GameMode; import forestry.core.interfaces.IRenderableMachine; import forestry.core.network.ClassMap; import forestry.core.network.IndexInPayload; @@ -26,6 +24,7 @@ import forestry.core.network.PacketPayload; import forestry.core.proxy.Proxies; import forestry.core.utils.EnumTankLevel; import forestry.core.fluids.tanks.StandardTank; +import forestry.energy.EnergyManager; public abstract class TilePowered extends TileBase implements IRenderableMachine, IEnergyHandler { @@ -65,28 +64,13 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine ex.printStackTrace(); } } - protected EnergyStorage energyStorage; - public int energyPerUse; + protected final EnergyManager energyManager; - public TilePowered() { - this(5000, 150); + public TilePowered(int minAcceptedEnergy, int maxTransfer, int energyPerWork, int capacity) { + this.energyManager = new EnergyManager(minAcceptedEnergy, maxTransfer, energyPerWork, capacity); + this.energyManager.setReceiveOnly(); } - public TilePowered(int defaultCapacity, int defaultEnergyPerUse) { - this(defaultCapacity, defaultEnergyPerUse, defaultCapacity); - } - - public TilePowered(int defaultCapacity, int defaultEnergyPerUse, int defaultMaxTransfer) { - this.energyPerUse = scaleEnergyByDifficulty(defaultEnergyPerUse); - int capacity = scaleEnergyByDifficulty(defaultCapacity); - int maxTransfer = scaleEnergyByDifficulty(defaultMaxTransfer); - energyStorage = new EnergyStorage(capacity, maxTransfer); - } - - private static int scaleEnergyByDifficulty(int energyPerUse) { - return Math.round(energyPerUse * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")); - } - /*private final PowerHandler powerHandler; public TilePowered() { @@ -131,8 +115,7 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine if (!Proxies.common.isSimulating(worldObj)) return; - if (workCounter < WORK_CYCLES && energyStorage.getEnergyStored() >= energyPerUse) { - energyStorage.modifyEnergyStored(-energyPerUse); //TODO Make it continuous usage while doing work + if (workCounter < WORK_CYCLES && energyManager.consumeEnergyToDoWork()) { workCounter++; } @@ -147,13 +130,13 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine @Override public void writeToNBT(NBTTagCompound nbt) { super.writeToNBT(nbt); - energyStorage.writeToNBT(nbt); + energyManager.writeToNBT(nbt); } @Override public void readFromNBT(NBTTagCompound nbt) { super.readFromNBT(nbt); - energyStorage.readFromNBT(nbt); + energyManager.readFromNBT(nbt); } /* LIQUID CONTAINER HANDLING */ @@ -191,26 +174,26 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { - return energyStorage.receiveEnergy(maxReceive, simulate); + return energyManager.receiveEnergy(from, maxReceive, simulate); } @Override public int extractEnergy(ForgeDirection from, int maxReceive, boolean simulate) { - return 0; + return energyManager.extractEnergy(from, maxReceive, simulate); } @Override public int getEnergyStored(ForgeDirection from) { - return energyStorage.getEnergyStored(); + return energyManager.getEnergyStored(from); } @Override public int getMaxEnergyStored(ForgeDirection from) { - return energyStorage.getMaxEnergyStored(); + return energyManager.getMaxEnergyStored(from); } @Override public boolean canConnectEnergy(ForgeDirection from) { - return true; + return energyManager.canConnectEnergy(from); } } diff --git a/src/main/java/forestry/energy/EnergyManager.java b/src/main/java/forestry/energy/EnergyManager.java new file mode 100644 index 000000000..083e65c0c --- /dev/null +++ b/src/main/java/forestry/energy/EnergyManager.java @@ -0,0 +1,117 @@ +package forestry.energy; + +import cofh.api.energy.EnergyStorage; +import cofh.api.energy.IEnergyHandler; +import forestry.core.GameMode; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +public class EnergyManager implements IEnergyHandler { + private enum EnergyTransferMode { + EXTRACT, RECEIVE, BOTH; + } + + private int energyPerWork; + private int minAcceptedEnergy; + protected EnergyStorage energyStorage; + private EnergyTransferMode mode = EnergyTransferMode.BOTH; + + public EnergyManager(int minAcceptedEnergy, int maxTransfer, int energyPerWork, int capacity) { + this.energyPerWork = scaleForDifficulty(energyPerWork); + this.minAcceptedEnergy = scaleForDifficulty(minAcceptedEnergy); + energyStorage = new EnergyStorage(scaleForDifficulty(capacity), scaleForDifficulty(maxTransfer), scaleForDifficulty(maxTransfer)); + } + + private static int scaleForDifficulty(int energyPerUse) { + return Math.round(energyPerUse * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")); + } + + public void setExtractOnly() { + mode = EnergyTransferMode.EXTRACT; + } + + public void setReceiveOnly() { + mode = EnergyTransferMode.RECEIVE; + } + + private boolean canExtract() { + switch (mode) { + case EXTRACT: + case BOTH: + return true; + } + return false; + } + + private boolean canReceive() { + switch (mode) { + case RECEIVE: + case BOTH: + return true; + } + return false; + } + + /* NBT */ + public EnergyManager readFromNBT(NBTTagCompound nbt) { + + NBTTagCompound energyManagerNBT = nbt.getCompoundTag("EnergyManager"); + NBTTagCompound energyStorageNBT = energyManagerNBT.getCompoundTag("EnergyStorage"); + energyStorage.readFromNBT(energyStorageNBT); + + return this; + } + + public NBTTagCompound writeToNBT(NBTTagCompound nbt) { + + NBTTagCompound energyStorageNBT = new NBTTagCompound(); + energyStorage.writeToNBT(energyStorageNBT); + + NBTTagCompound energyManagerNBT = new NBTTagCompound(); + energyManagerNBT.setTag("EnergyStorage", energyStorageNBT); + nbt.setTag("EnergyManager", energyManagerNBT); + + return nbt; + } + + /* IEnergyHandler */ + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + if (!canReceive() || maxReceive < minAcceptedEnergy) + return 0; + return energyStorage.receiveEnergy(maxReceive, simulate); + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + if (!canExtract()) + return 0; + return energyStorage.extractEnergy(maxExtract, simulate); + } + + @Override + public int getEnergyStored(ForgeDirection from) { + return energyStorage.getEnergyStored(); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + return energyStorage.getMaxEnergyStored(); + } + + @Override + public boolean canConnectEnergy(ForgeDirection from) { + return true; + } + + /** + * Consumes one work cycle's worth of energy. + * @return true if the energy to do work was consumed + */ + public boolean consumeEnergyToDoWork() { + if (energyStorage.getEnergyStored() < energyPerWork) + return false; + energyStorage.modifyEnergyStored(-energyPerWork); + return true; + } +} diff --git a/src/main/java/forestry/factory/gadgets/MachineBottler.java b/src/main/java/forestry/factory/gadgets/MachineBottler.java index 7ad4e8ffb..5b3c04f9a 100755 --- a/src/main/java/forestry/factory/gadgets/MachineBottler.java +++ b/src/main/java/forestry/factory/gadgets/MachineBottler.java @@ -157,7 +157,7 @@ public class MachineBottler extends TilePowered implements ISidedInventory, ILiq private int fillingTotalTime; public MachineBottler() { - energyStorage = new EnergyStorage(4000); + super(500, 1100, 50, 4000); setHints(Config.hints.get("bottler")); resourceTank = new StandardTank(Defaults.PROCESSOR_TANK_CAPACITY); tankManager = new TankManager(resourceTank); @@ -173,12 +173,6 @@ public class MachineBottler extends TilePowered implements ISidedInventory, ILiq player.openGui(ForestryAPI.instance, GuiId.BottlerGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(50, 110, 5, 400); - }*/ - /* SAVING & LOADING */ @Override public void writeToNBT(NBTTagCompound nbttagcompound) { diff --git a/src/main/java/forestry/factory/gadgets/MachineCarpenter.java b/src/main/java/forestry/factory/gadgets/MachineCarpenter.java index 2cd99e463..f9a2b4532 100755 --- a/src/main/java/forestry/factory/gadgets/MachineCarpenter.java +++ b/src/main/java/forestry/factory/gadgets/MachineCarpenter.java @@ -235,7 +235,7 @@ public class MachineCarpenter extends TilePowered implements ISidedInventory, IL } public MachineCarpenter() { - energyStorage = new EnergyStorage(4000); + super(500, 1100, 50, 4000); setHints(Config.hints.get("carpenter")); resourceTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, RecipeManager.recipeFluids); craftingInventory = new TileInventoryAdapter(this, 10, "CraftItems"); @@ -254,11 +254,6 @@ public class MachineCarpenter extends TilePowered implements ISidedInventory, IL player.openGui(ForestryAPI.instance, GuiId.CarpenterGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(50, 110, 5, 400); - }*/ - /* LOADING & SAVING */ @Override public void writeToNBT(NBTTagCompound nbttagcompound) { diff --git a/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java b/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java index 44d37e105..b4edf5a32 100755 --- a/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java +++ b/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java @@ -143,6 +143,7 @@ public class MachineCentrifuge extends TilePowered implements ISidedInventory, I private int timePerItem; public MachineCentrifuge() { + super(400, 800, 40, Defaults.MACHINE_MAX_ENERGY); setHints(Config.hints.get("centrifuge")); } @@ -156,11 +157,6 @@ public class MachineCentrifuge extends TilePowered implements ISidedInventory, I player.openGui(ForestryAPI.instance, GuiId.CentrifugeGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(40, 80, 4, Defaults.MACHINE_MAX_ENERGY); - }*/ - /* LOADING & SAVING */ @Override public void writeToNBT(NBTTagCompound nbttagcompound) { diff --git a/src/main/java/forestry/factory/gadgets/MachineFabricator.java b/src/main/java/forestry/factory/gadgets/MachineFabricator.java index 4f962a984..59fd09eb5 100755 --- a/src/main/java/forestry/factory/gadgets/MachineFabricator.java +++ b/src/main/java/forestry/factory/gadgets/MachineFabricator.java @@ -242,7 +242,7 @@ public class MachineFabricator extends TilePowered implements ICrafter, ISpecial private FluidStack pendingSmelt; public MachineFabricator() { - super(3300, 50, 1100); + super(500, 1100, 50, 3300); Fluid liquidGlass = FluidRegistry.getFluid(Defaults.LIQUID_GLASS); moltenTank = new FilteredTank(2 * Defaults.BUCKET_VOLUME, liquidGlass); moltenTank.tankMode = StandardTank.TankMode.INTERNAL; diff --git a/src/main/java/forestry/factory/gadgets/MachineFermenter.java b/src/main/java/forestry/factory/gadgets/MachineFermenter.java index 0402b9f38..c9d583b04 100755 --- a/src/main/java/forestry/factory/gadgets/MachineFermenter.java +++ b/src/main/java/forestry/factory/gadgets/MachineFermenter.java @@ -198,7 +198,7 @@ public class MachineFermenter extends TilePowered implements ISidedInventory, IL public int fuelCurrentFerment = 0; public MachineFermenter() { - energyStorage = new EnergyStorage(8000); + super(50, 2000, 150, 8000); setHints(Config.hints.get("fermenter")); resourceTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, RecipeManager.recipeFluidInputs); resourceTank.tankMode = StandardTank.TankMode.INPUT; @@ -217,11 +217,6 @@ public class MachineFermenter extends TilePowered implements ISidedInventory, IL player.openGui(ForestryAPI.instance, GuiId.FermenterGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(5, 200, 15, 800); - }*/ - @Override public void writeToNBT(NBTTagCompound nbttagcompound) { super.writeToNBT(nbttagcompound); diff --git a/src/main/java/forestry/factory/gadgets/MachineMoistener.java b/src/main/java/forestry/factory/gadgets/MachineMoistener.java index dcb0bff73..31ae01e65 100755 --- a/src/main/java/forestry/factory/gadgets/MachineMoistener.java +++ b/src/main/java/forestry/factory/gadgets/MachineMoistener.java @@ -145,6 +145,7 @@ public class MachineMoistener extends TilePowered implements ISpecialInventory, private ItemStack pendingProduct; public MachineMoistener() { + super(0, 0, 0, 0); setHints(Config.hints.get("moistener")); resourceTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, FluidRegistry.WATER); tankManager = new TankManager(resourceTank); diff --git a/src/main/java/forestry/factory/gadgets/MachineSqueezer.java b/src/main/java/forestry/factory/gadgets/MachineSqueezer.java index 135889ecb..0e9b41a0f 100755 --- a/src/main/java/forestry/factory/gadgets/MachineSqueezer.java +++ b/src/main/java/forestry/factory/gadgets/MachineSqueezer.java @@ -151,7 +151,7 @@ public class MachineSqueezer extends TilePowered implements ISpecialInventory, I private int timePerItem; public MachineSqueezer() { - energyStorage = new EnergyStorage(4000); + super(500, 1100, 50, 4000); setHints(Config.hints.get("squeezer")); productTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, RecipeManager.recipeFluids); productTank.tankMode = StandardTank.TankMode.OUTPUT; @@ -168,11 +168,6 @@ public class MachineSqueezer extends TilePowered implements ISpecialInventory, I player.openGui(ForestryAPI.instance, GuiId.SqueezerGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(50, 110, 5, 400); - }*/ - /* LOADING & SAVING */ @Override public void writeToNBT(NBTTagCompound nbttagcompound) { diff --git a/src/main/java/forestry/factory/gadgets/MachineStill.java b/src/main/java/forestry/factory/gadgets/MachineStill.java index c8d4816b3..9888d352c 100755 --- a/src/main/java/forestry/factory/gadgets/MachineStill.java +++ b/src/main/java/forestry/factory/gadgets/MachineStill.java @@ -141,7 +141,7 @@ public class MachineStill extends TilePowered implements ISpecialInventory, ISid public int distillationTotalTime = 0; public MachineStill() { - energyStorage = new EnergyStorage(8000); + super(500, 1100, 50, 8000); setHints(Config.hints.get("still")); resourceTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, RecipeManager.recipeFluidInputs); resourceTank.tankMode = StandardTank.TankMode.INPUT; @@ -160,11 +160,6 @@ public class MachineStill extends TilePowered implements ISpecialInventory, ISid player.openGui(ForestryAPI.instance, GuiId.StillGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord); } - /*@Override //TODO - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(50, 110, 5, 800); - }*/ - @Override public void writeToNBT(NBTTagCompound nbttagcompound) { super.writeToNBT(nbttagcompound); From 436a61978a4a813b5ac33af00c669ba4ecb60c0e Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 00:36:05 -0700 Subject: [PATCH 24/37] Have engines use EnergyManager --- .../java/forestry/core/gadgets/Engine.java | 55 ++++------------ .../java/forestry/energy/EnergyManager.java | 62 +++++++++++++++++++ .../forestry/energy/gadgets/EngineBronze.java | 6 +- .../energy/gadgets/EngineClockwork.java | 4 +- .../forestry/energy/gadgets/EngineCopper.java | 8 +-- .../forestry/energy/gadgets/EngineTin.java | 8 +-- 6 files changed, 87 insertions(+), 56 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index 6b58481f8..2e5ec48c7 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -20,12 +20,12 @@ import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; -import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyHandler; import forestry.core.TemperatureState; import forestry.core.config.Defaults; import forestry.core.network.PacketPayload; import forestry.core.utils.BlockUtil; +import forestry.energy.EnergyManager; public abstract class Engine extends TileBase implements IEnergyHandler { @@ -37,7 +37,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { payload.intPayload[0] = 1; else payload.intPayload[0] = 0; - payload.intPayload[1] = energyStorage.getEnergyStored(); + payload.intPayload[1] = energyManager.toPacketInt(); payload.intPayload[2] = heat; payload.floatPayload[0] = pistonSpeedServer; @@ -48,7 +48,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { public void fromPacketPayload(PacketPayload payload) { isActive = payload.intPayload[0] > 0; - energyStorage.setEnergyStored(payload.intPayload[1]); + energyManager.fromPacketInt(payload.intPayload[1]); heat = payload.intPayload[2]; pistonSpeedServer = payload.floatPayload[0]; @@ -70,15 +70,13 @@ public abstract class Engine extends TileBase implements IEnergyHandler { protected final int maxHeat; protected boolean forceCooldown = false; public float progress; - protected EnergyStorage energyStorage; + protected EnergyManager energyManager; public Engine(int maxHeat, int maxEnergy, int maxEnergyExtracted) { this.maxHeat = maxHeat; this.maxEnergy = maxEnergy; this.maxEnergyExtracted = maxEnergyExtracted; - energyStorage = new EnergyStorage(maxEnergy, maxEnergyExtracted); - //powerProvider = new PowerHandler(this, PowerHandler.Type.ENGINE); - //powerProvider.configure(10, 200, 10, 100000); + energyManager = new EnergyManager(100, 2000, 100, 1000000); } @Override @@ -102,10 +100,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { public abstract int generateHeat(); - public int maxEnergyReceived() { - return 200; - } - public boolean mayBurn() { return !forceCooldown; } @@ -150,14 +144,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { if (progress > 0.25 && stagePiston == 1) { stagePiston = 2; - if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { - IEnergyHandler receptor = (IEnergyHandler) tile; - int extractable = extractEnergy(getOrientation(), energyStorage.getMaxExtract(), true); - if (extractable > 0) { - int extracted = receptor.receiveEnergy(getOrientation().getOpposite(), extractable, false); - extractEnergy(getOrientation(), extracted, false); - } - } + energyManager.sendEnergy(getOrientation(), tile); } else if (progress >= 0.5) { progress = 0; @@ -179,7 +166,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { if (mayBurn()) burn(); else - energyStorage.extractEnergy(20, false); + energyManager.drainEnergy(20); } @@ -201,10 +188,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { for (int i = getOrientation().ordinal() + 1; i <= getOrientation().ordinal() + 6; ++i) { ForgeDirection orient = ForgeDirection.values()[i % 6]; - /*Position pos = new Position(xCoord, yCoord, zCoord, orient); - pos.moveForwards(1.0F); - - TileEntity tile = worldObj.getTileEntity((int) pos.x, (int) pos.y, (int) pos.z);*/ TileEntity tile = worldObj.getTileEntity(xCoord + orient.offsetX, yCoord + orient.offsetY, zCoord + orient.offsetZ); if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { @@ -293,13 +276,9 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public void readFromNBT(NBTTagCompound nbt) { super.readFromNBT(nbt); - energyStorage.readFromNBT(nbt); + energyManager.readFromNBT(nbt); heat = nbt.getInteger("EngineHeat"); - /*if (nbt.hasKey("EngineStoredEnergy")) - storedEnergy = nbt.getInteger("EngineStoredEnergy"); - else - storedEnergy = nbt.getFloat("EngineStored");*/ progress = nbt.getFloat("EngineProgress"); forceCooldown = nbt.getBoolean("ForceCooldown"); @@ -308,10 +287,9 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public void writeToNBT(NBTTagCompound nbt) { super.writeToNBT(nbt); - energyStorage.writeToNBT(nbt); + energyManager.writeToNBT(nbt); nbt.setInteger("EngineHeat", heat); - //nbt.setFloat("EngineStored", storedEnergy); nbt.setFloat("EngineProgress", progress); nbt.setBoolean("ForceCooldown", forceCooldown); } @@ -321,15 +299,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { public abstract void sendGUINetworkData(Container containerEngine, ICrafting iCrafting); - /*@Override - public void doWork(PowerHandler workProvider) { - if (!Proxies.common.isSimulating(worldObj)) - return; - - addEnergy((int) (PluginBuildCraft.instance.invokeUseEnergyMethod(workProvider, 1, maxEnergyReceived(), true) * 0.95F)); - - }*/ - @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { return 0; @@ -337,17 +306,17 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { - return energyStorage.extractEnergy(maxExtract, simulate); //TODO + return energyManager.extractEnergy(from, maxExtract, simulate); } @Override public int getEnergyStored(ForgeDirection from) { - return energyStorage.getEnergyStored(); + return energyManager.getEnergyStored(from); } @Override public int getMaxEnergyStored(ForgeDirection from) { - return energyStorage.getMaxEnergyStored(); + return energyManager.getMaxEnergyStored(from); } @Override diff --git a/src/main/java/forestry/energy/EnergyManager.java b/src/main/java/forestry/energy/EnergyManager.java index 083e65c0c..513f9090f 100644 --- a/src/main/java/forestry/energy/EnergyManager.java +++ b/src/main/java/forestry/energy/EnergyManager.java @@ -3,7 +3,9 @@ package forestry.energy; import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyHandler; import forestry.core.GameMode; +import forestry.core.utils.BlockUtil; import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; import net.minecraftforge.common.util.ForgeDirection; public class EnergyManager implements IEnergyHandler { @@ -74,6 +76,15 @@ public class EnergyManager implements IEnergyHandler { return nbt; } + /* Packets */ + public int toPacketInt() { + return energyStorage.getEnergyStored(); + } + + public void fromPacketInt(int packetInt) { + energyStorage.setEnergyStored(packetInt); + } + /* IEnergyHandler */ @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { @@ -94,6 +105,10 @@ public class EnergyManager implements IEnergyHandler { return energyStorage.getEnergyStored(); } + public int getTotalEnergyStored() { + return energyStorage.getEnergyStored(); + } + @Override public int getMaxEnergyStored(ForgeDirection from) { return energyStorage.getMaxEnergyStored(); @@ -114,4 +129,51 @@ public class EnergyManager implements IEnergyHandler { energyStorage.modifyEnergyStored(-energyPerWork); return true; } + + /** + * Sends as much energy as it can to the tile at orientation + * @param orientation + * @param tile + * @return amount sent + */ + public int sendEnergy(ForgeDirection orientation, TileEntity tile) { + return sendEnergy(orientation, tile, Integer.MAX_VALUE); + } + + /** + * Sends amount of energy to the tile at orientation + * @param orientation + * @param tile + * @param amount + * @return amount sent + */ + public int sendEnergy(ForgeDirection orientation, TileEntity tile, int amount) { + int sent = 0; + if (BlockUtil.isRFTile(orientation.getOpposite(), tile)) { + IEnergyHandler receptor = (IEnergyHandler) tile; + + int extractable = extractEnergy(orientation, amount, true); + if (extractable > 0) { + sent = receptor.receiveEnergy(orientation.getOpposite(), extractable, false); + extractEnergy(orientation, sent, false); + } + } + return sent; + } + + /** + * Drains an amount of energy, due to decay from lack of work or other factors + * @param amount + */ + public void drainEnergy(int amount) { + energyStorage.modifyEnergyStored(-amount); + } + + /** + * Creates an amount of energy, generated by engines + * @param amount + */ + public void generateEnergy(int amount) { + energyStorage.modifyEnergyStored(amount); + } } diff --git a/src/main/java/forestry/energy/gadgets/EngineBronze.java b/src/main/java/forestry/energy/gadgets/EngineBronze.java index 7a2ffa03f..bbc8b282b 100755 --- a/src/main/java/forestry/energy/gadgets/EngineBronze.java +++ b/src/main/java/forestry/energy/gadgets/EngineBronze.java @@ -167,7 +167,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa if (burnTime > 0) { burnTime--; currentOutput = determineFuelValue(FluidRegistry.getFluid(currentFluidId)); - energyStorage.modifyEnergyStored(currentOutput); + energyManager.generateEnergy(currentOutput); } else { burnTime = totalTime = this.determineBurnTime(fuelTank.getFluid().getFluid()); currentFluidId = fuelTank.getFluid().getFluid().getID(); @@ -353,7 +353,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa currentOutput = data; break; case 3: - energyStorage.setEnergyStored(data); + energyManager.fromPacketInt(data); break; case 4: heat = data; @@ -370,7 +370,7 @@ public class EngineBronze extends Engine implements ISpecialInventory, ILiquidTa iCrafting.sendProgressBarUpdate(containerEngine, i, burnTime); iCrafting.sendProgressBarUpdate(containerEngine, i + 1, totalTime); iCrafting.sendProgressBarUpdate(containerEngine, i + 2, currentOutput); - iCrafting.sendProgressBarUpdate(containerEngine, i + 3, energyStorage.getEnergyStored()); + iCrafting.sendProgressBarUpdate(containerEngine, i + 3, energyManager.toPacketInt()); iCrafting.sendProgressBarUpdate(containerEngine, i + 4, heat); iCrafting.sendProgressBarUpdate(containerEngine, i + 5, currentFluidId); } diff --git a/src/main/java/forestry/energy/gadgets/EngineClockwork.java b/src/main/java/forestry/energy/gadgets/EngineClockwork.java index 7ed2ad196..718cd4d0a 100755 --- a/src/main/java/forestry/energy/gadgets/EngineClockwork.java +++ b/src/main/java/forestry/energy/gadgets/EngineClockwork.java @@ -112,7 +112,7 @@ public class EngineClockwork extends Engine { tension *= 0.9995f; else tension = 0; - energyStorage.modifyEnergyStored(ENGINE_CLOCKWORK_ENERGY_PER_CYCLE * (int)tension); + energyManager.generateEnergy(ENGINE_CLOCKWORK_ENERGY_PER_CYCLE * (int)tension); } @Override @@ -142,7 +142,7 @@ public class EngineClockwork extends Engine { return 0; float fromClockwork = (tension / ENGINE_CLOCKWORK_WIND_MAX) * Defaults.ENGINE_PISTON_SPEED_MAX; - return fromClockwork >= 0.01f ? fromClockwork : energyStorage.getEnergyStored() > 0 ? 0.01f : 0; + return fromClockwork >= 0.01f ? fromClockwork : energyManager.getTotalEnergyStored() > 0 ? 0.01f : 0; } @Override public void getGUINetworkData(int i, int j) {} diff --git a/src/main/java/forestry/energy/gadgets/EngineCopper.java b/src/main/java/forestry/energy/gadgets/EngineCopper.java index e5994bb5e..27388234f 100755 --- a/src/main/java/forestry/energy/gadgets/EngineCopper.java +++ b/src/main/java/forestry/energy/gadgets/EngineCopper.java @@ -133,7 +133,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv if (isActivated()) { currentOutput = determineFuelValue(new ItemStack(fuelItem, 1, fuelItemMeta)); - energyStorage.modifyEnergyStored(currentOutput); + energyManager.generateEnergy(currentOutput); } } else if (isActivated()) { int fuelslot = getFuelSlot(); @@ -174,7 +174,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv if (isBurning()) { heat++; - if (((double) energyStorage.getEnergyStored() / (double) maxEnergy) > 0.5) + if (((double) energyManager.getTotalEnergyStored() / (double) maxEnergy) > 0.5) heat++; } @@ -333,7 +333,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv currentOutput = j; break; case 3: - energyStorage.setEnergyStored(j); + energyManager.fromPacketInt(j); break; case 4: heat = j; @@ -346,7 +346,7 @@ public class EngineCopper extends Engine implements ISpecialInventory, ISidedInv iCrafting.sendProgressBarUpdate(containerEngine, 0, burnTime); iCrafting.sendProgressBarUpdate(containerEngine, 1, totalBurnTime); iCrafting.sendProgressBarUpdate(containerEngine, 2, currentOutput); - iCrafting.sendProgressBarUpdate(containerEngine, 3, energyStorage.getEnergyStored()); + iCrafting.sendProgressBarUpdate(containerEngine, 3, energyManager.toPacketInt()); iCrafting.sendProgressBarUpdate(containerEngine, 4, heat); } diff --git a/src/main/java/forestry/energy/gadgets/EngineTin.java b/src/main/java/forestry/energy/gadgets/EngineTin.java index ec046ff64..37722db17 100755 --- a/src/main/java/forestry/energy/gadgets/EngineTin.java +++ b/src/main/java/forestry/energy/gadgets/EngineTin.java @@ -136,7 +136,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { int gain = 0; if (isActivated() && isBurning()) { gain++; - if (((double) energyStorage.getEnergyStored() / (double) maxEnergy) > 0.5) + if (((double) energyManager.getTotalEnergyStored() / (double) maxEnergy) > 0.5) gain++; } @@ -185,7 +185,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { if (ic2EnergySink.useEnergy(euConfig.euForCycle)) { currentOutput = euConfig.rfPerCycle; - energyStorage.modifyEnergyStored(euConfig.rfPerCycle); + energyManager.generateEnergy(euConfig.rfPerCycle); } } @@ -233,7 +233,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { currentOutput = j; break; case 1: - energyStorage.setEnergyStored(j); + energyManager.fromPacketInt(j); break; case 2: heat = j; @@ -248,7 +248,7 @@ public class EngineTin extends Engine implements ISocketable, IInventory { @Override public void sendGUINetworkData(Container containerEngine, ICrafting iCrafting) { iCrafting.sendProgressBarUpdate(containerEngine, 0, currentOutput); - iCrafting.sendProgressBarUpdate(containerEngine, 1, energyStorage.getEnergyStored()); + iCrafting.sendProgressBarUpdate(containerEngine, 1, energyManager.toPacketInt()); iCrafting.sendProgressBarUpdate(containerEngine, 2, heat); if (ic2EnergySink != null) { iCrafting.sendProgressBarUpdate(containerEngine, 3, (short) ic2EnergySink.getEnergyStored()); From eab4cecb5b32a6374f8b39e43a1a36c68c232407 Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 00:36:41 -0700 Subject: [PATCH 25/37] Let engines accept energy (for chaining engines like before) --- src/main/java/forestry/core/gadgets/Engine.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index 2e5ec48c7..12f5e790d 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -301,11 +301,15 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { - return 0; + if (from == getOrientation()) + return 0; + return energyManager.receiveEnergy(from, maxReceive, simulate); } @Override public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + if (from != getOrientation()) + return 0; return energyManager.extractEnergy(from, maxExtract, simulate); } @@ -321,6 +325,6 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public boolean canConnectEnergy(ForgeDirection from) { - return from == getOrientation(); + return energyManager.canConnectEnergy(from); } } From aea2ee526820f9de3a1d7eefcfa13155131c22e5 Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 01:04:28 -0700 Subject: [PATCH 26/37] Convert Alveary Heater and Fan to RF --- .../apiculture/gadgets/TileAlveary.java | 1 - .../gadgets/TileAlvearyClimatiser.java | 92 ++++++++++--------- .../java/forestry/energy/EnergyManager.java | 4 + 3 files changed, 52 insertions(+), 45 deletions(-) diff --git a/src/main/java/forestry/apiculture/gadgets/TileAlveary.java b/src/main/java/forestry/apiculture/gadgets/TileAlveary.java index e60511584..744762ddb 100755 --- a/src/main/java/forestry/apiculture/gadgets/TileAlveary.java +++ b/src/main/java/forestry/apiculture/gadgets/TileAlveary.java @@ -12,7 +12,6 @@ package forestry.apiculture.gadgets; import java.util.LinkedList; -import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.IInventory; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/main/java/forestry/apiculture/gadgets/TileAlvearyClimatiser.java b/src/main/java/forestry/apiculture/gadgets/TileAlvearyClimatiser.java index 75f3648fb..06b2442dc 100755 --- a/src/main/java/forestry/apiculture/gadgets/TileAlvearyClimatiser.java +++ b/src/main/java/forestry/apiculture/gadgets/TileAlvearyClimatiser.java @@ -10,20 +10,15 @@ ******************************************************************************/ package forestry.apiculture.gadgets; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.nbt.NBTTagCompound; - -import net.minecraftforge.common.util.ForgeDirection; - -import buildcraft.api.power.IPowerReceptor; -import buildcraft.api.power.PowerHandler; -import buildcraft.api.power.PowerHandler.PowerReceiver; -import buildcraft.api.power.PowerHandler.Type; - +import cofh.api.energy.IEnergyHandler; import forestry.api.apiculture.IAlvearyComponent; import forestry.core.network.PacketPayload; +import forestry.energy.EnergyManager; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; -public abstract class TileAlvearyClimatiser extends TileAlveary implements IPowerReceptor { +public abstract class TileAlvearyClimatiser extends TileAlveary implements IEnergyHandler { public static class ClimateControl { @@ -37,7 +32,7 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IPowe this.boundaryUp = boundaryUp; } } - PowerHandler powerProvider; + protected EnergyManager energyManager; ClimateControl climateControl; private int transferTime = 0; private int animationDelay = 0; @@ -47,8 +42,8 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IPowe public TileAlvearyClimatiser(ClimateControl control, int textureOff, int textureOn, int componentBlockMeta) { super(componentBlockMeta); this.climateControl = control; - powerProvider = new PowerHandler(this, Type.MACHINE); - powerProvider.configure(10, 100, 25, 200); + energyManager = new EnergyManager(100, 1000, 250, 2000); + energyManager.setReceiveOnly(); this.textureOff = textureOff; this.textureOn = textureOn; } @@ -62,14 +57,20 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IPowe protected void updateServerSide() { super.updateServerSide(); - // BC Power - if (powerProvider != null) { - powerProvider.update(); - } - if (!this.hasMaster()) return; + if (energyManager.consumeEnergyToDoWork()) { + + transferTime = energyManager.getEnergyPerWork(); + + if (animationDelay <= 0) { + animationDelay = 100; + sendNetworkUpdate(); + } else + animationDelay = 100; + } + if (transferTime > 0) { transferTime--; IAlvearyComponent component = (IAlvearyComponent) this.getCentralTE(); @@ -98,41 +99,18 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IPowe return textureOff; } - /* IPOWERRECEPTOR */ - @Override - public void doWork(PowerHandler workProvider) { - if (!this.hasMaster()) - return; - - if (powerProvider.useEnergy(powerProvider.getActivationEnergy(), powerProvider.getEnergyStored(), false) < powerProvider.getActivationEnergy()) - return; - - transferTime = (int) Math.round(powerProvider.useEnergy(powerProvider.getActivationEnergy(), powerProvider.getEnergyStored(), true)); - - if (animationDelay <= 0) { - animationDelay = 100; - sendNetworkUpdate(); - } else - animationDelay = 100; - } - - @Override - public PowerReceiver getPowerReceiver(ForgeDirection side) { - return powerProvider.getPowerReceiver(); - } - /* LOADING & SAVING */ @Override public void readFromNBT(NBTTagCompound nbttagcompound) { super.readFromNBT(nbttagcompound); - powerProvider.readFromNBT(nbttagcompound); + energyManager.readFromNBT(nbttagcompound); transferTime = nbttagcompound.getInteger("Heating"); } @Override public void writeToNBT(NBTTagCompound nbttagcompound) { super.writeToNBT(nbttagcompound); - powerProvider.writeToNBT(nbttagcompound); + energyManager.writeToNBT(nbttagcompound); nbttagcompound.setInteger("Heating", transferTime); } @@ -153,4 +131,30 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IPowe payload.shortPayload[0] = (short) animationDelay; return payload; } + + /* IEnergyHandler */ + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + return energyManager.receiveEnergy(from, maxReceive, simulate); + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + return energyManager.extractEnergy(from, maxExtract, simulate); + } + + @Override + public int getEnergyStored(ForgeDirection from) { + return energyManager.getEnergyStored(from); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + return energyManager.getMaxEnergyStored(from); + } + + @Override + public boolean canConnectEnergy(ForgeDirection from) { + return energyManager.canConnectEnergy(from); + } } diff --git a/src/main/java/forestry/energy/EnergyManager.java b/src/main/java/forestry/energy/EnergyManager.java index 513f9090f..2090b0e76 100644 --- a/src/main/java/forestry/energy/EnergyManager.java +++ b/src/main/java/forestry/energy/EnergyManager.java @@ -119,6 +119,10 @@ public class EnergyManager implements IEnergyHandler { return true; } + public int getEnergyPerWork() { + return energyPerWork; + } + /** * Consumes one work cycle's worth of energy. * @return true if the energy to do work was consumed From ca5a14d837d443769bb46c2afd8ff356a06bd4d1 Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 01:10:06 -0700 Subject: [PATCH 27/37] remove unused imports --- src/main/java/forestry/factory/gadgets/MachineBottler.java | 2 -- src/main/java/forestry/factory/gadgets/MachineCarpenter.java | 2 -- src/main/java/forestry/factory/gadgets/MachineCentrifuge.java | 1 - src/main/java/forestry/factory/gadgets/MachineFermenter.java | 2 -- src/main/java/forestry/factory/gadgets/MachineSqueezer.java | 2 -- src/main/java/forestry/factory/gadgets/MachineStill.java | 2 -- 6 files changed, 11 deletions(-) diff --git a/src/main/java/forestry/factory/gadgets/MachineBottler.java b/src/main/java/forestry/factory/gadgets/MachineBottler.java index 5b3c04f9a..348a644b3 100755 --- a/src/main/java/forestry/factory/gadgets/MachineBottler.java +++ b/src/main/java/forestry/factory/gadgets/MachineBottler.java @@ -34,9 +34,7 @@ import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidTankInfo; import buildcraft.api.gates.ITrigger; -import buildcraft.api.power.PowerHandler; -import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.core.EnumErrorCode; import forestry.core.config.Config; diff --git a/src/main/java/forestry/factory/gadgets/MachineCarpenter.java b/src/main/java/forestry/factory/gadgets/MachineCarpenter.java index f9a2b4532..4b90bdd73 100755 --- a/src/main/java/forestry/factory/gadgets/MachineCarpenter.java +++ b/src/main/java/forestry/factory/gadgets/MachineCarpenter.java @@ -35,9 +35,7 @@ import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidTankInfo; import buildcraft.api.gates.ITrigger; -import buildcraft.api.power.PowerHandler; -import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.recipes.ICarpenterManager; import forestry.core.EnumErrorCode; diff --git a/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java b/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java index b4edf5a32..54d117338 100755 --- a/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java +++ b/src/main/java/forestry/factory/gadgets/MachineCentrifuge.java @@ -27,7 +27,6 @@ import net.minecraft.nbt.NBTTagList; import net.minecraftforge.common.util.ForgeDirection; import buildcraft.api.gates.ITrigger; -import buildcraft.api.power.PowerHandler; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; diff --git a/src/main/java/forestry/factory/gadgets/MachineFermenter.java b/src/main/java/forestry/factory/gadgets/MachineFermenter.java index c9d583b04..51a4a65ff 100755 --- a/src/main/java/forestry/factory/gadgets/MachineFermenter.java +++ b/src/main/java/forestry/factory/gadgets/MachineFermenter.java @@ -30,9 +30,7 @@ import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; -import buildcraft.api.power.PowerHandler; -import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.fuels.FuelManager; import forestry.api.recipes.IFermenterManager; diff --git a/src/main/java/forestry/factory/gadgets/MachineSqueezer.java b/src/main/java/forestry/factory/gadgets/MachineSqueezer.java index 0e9b41a0f..601226c60 100755 --- a/src/main/java/forestry/factory/gadgets/MachineSqueezer.java +++ b/src/main/java/forestry/factory/gadgets/MachineSqueezer.java @@ -32,9 +32,7 @@ import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; -import buildcraft.api.power.PowerHandler; -import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; import forestry.api.recipes.ISqueezerManager; diff --git a/src/main/java/forestry/factory/gadgets/MachineStill.java b/src/main/java/forestry/factory/gadgets/MachineStill.java index 9888d352c..ab0e624a2 100755 --- a/src/main/java/forestry/factory/gadgets/MachineStill.java +++ b/src/main/java/forestry/factory/gadgets/MachineStill.java @@ -29,9 +29,7 @@ import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; import net.minecraftforge.fluids.FluidStack; import buildcraft.api.gates.ITrigger; -import buildcraft.api.power.PowerHandler; -import cofh.api.energy.EnergyStorage; import forestry.api.core.ForestryAPI; import forestry.api.core.ISpecialInventory; import forestry.api.recipes.IStillManager; From 7de0258389ac9c4b2ceca8e416b8bed0104b09e9 Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 01:24:55 -0700 Subject: [PATCH 28/37] Converted farm gearbox to RF --- .../forestry/farming/gadgets/TileGearbox.java | 77 +++++++++---------- 1 file changed, 38 insertions(+), 39 deletions(-) diff --git a/src/main/java/forestry/farming/gadgets/TileGearbox.java b/src/main/java/forestry/farming/gadgets/TileGearbox.java index 007c638e2..726cd2a3d 100755 --- a/src/main/java/forestry/farming/gadgets/TileGearbox.java +++ b/src/main/java/forestry/farming/gadgets/TileGearbox.java @@ -10,37 +10,24 @@ ******************************************************************************/ package forestry.farming.gadgets; +import cofh.api.energy.IEnergyHandler; + +import forestry.energy.EnergyManager; import net.minecraft.nbt.NBTTagCompound; -import net.minecraftforge.common.util.ForgeDirection; - -import buildcraft.api.power.PowerHandler; -import buildcraft.api.power.PowerHandler.PowerReceiver; -import buildcraft.api.power.PowerHandler.Type; - import forestry.api.core.ITileStructure; import forestry.api.farming.IFarmHousing; -import forestry.core.GameMode; -import forestry.core.interfaces.IPowerHandler; +import net.minecraftforge.common.util.ForgeDirection; -public class TileGearbox extends TileFarm implements IPowerHandler { +public class TileGearbox extends TileFarm implements IEnergyHandler { public static int WORK_CYCLES = 4; - public static int MIN_ENERGY_RECEIVED = 5; - public static int MAX_ENERGY_RECEIVED = 20; - public static int MIN_ACTIVATION_ENERGY = 5; - public static int MAX_ENERGY = 1000; private int activationDelay = 0; private int previousDelays = 0; private int workCounter; public TileGearbox() { - powerProvider = new PowerHandler(this, Type.MACHINE); - powerProvider.configurePowerPerdition(0, 100); - powerProvider.configure(MIN_ENERGY_RECEIVED, - Math.round(MAX_ENERGY_RECEIVED * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")), - Math.round(MIN_ACTIVATION_ENERGY * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")), - Math.round(MAX_ENERGY * GameMode.getGameMode().getFloatSetting("energy.demand.modifier"))); + energyManager = new EnergyManager(50, 200, 50, 10000); fixedType = TYPE_GEARS; } @@ -58,7 +45,7 @@ public class TileGearbox extends TileFarm implements IPowerHandler { @Override public void readFromNBT(NBTTagCompound nbttagcompound) { super.readFromNBT(nbttagcompound); - powerProvider.readFromNBT(nbttagcompound); + energyManager.readFromNBT(nbttagcompound); activationDelay = nbttagcompound.getInteger("ActivationDelay"); previousDelays = nbttagcompound.getInteger("PrevDelays"); @@ -67,24 +54,14 @@ public class TileGearbox extends TileFarm implements IPowerHandler { @Override public void writeToNBT(NBTTagCompound nbttagcompound) { super.writeToNBT(nbttagcompound); - powerProvider.writeToNBT(nbttagcompound); + energyManager.writeToNBT(nbttagcompound); nbttagcompound.setInteger("ActivationDelay", activationDelay); nbttagcompound.setInteger("PrevDelays", previousDelays); } - /* IPOWERRECEPTOR */ - PowerHandler powerProvider; - - @Override - public PowerReceiver getPowerReceiver(ForgeDirection side) { - return powerProvider.getPowerReceiver(); - } - - @Override - public PowerHandler getPowerHandler() { - return powerProvider; - } + /* POWER */ + EnergyManager energyManager; @Override protected void updateServerSide() { @@ -95,6 +72,11 @@ public class TileGearbox extends TileFarm implements IPowerHandler { return; } + // Hard limit to 4 cycles / second. + if (workCounter < WORK_CYCLES && energyManager.consumeEnergyToDoWork()) { + workCounter++; + } + if (workCounter >= WORK_CYCLES && worldObj.getTotalWorldTime() % 5 == 0) { ITileStructure central = getCentralTE(); if (!(central instanceof IFarmHousing)) @@ -111,12 +93,29 @@ public class TileGearbox extends TileFarm implements IPowerHandler { } } + /* IEnergyHandler */ @Override - public void doWork(PowerHandler workProvider) { - // Hard limit to 4 cycles / second. - if (workCounter < WORK_CYCLES) { - powerProvider.useEnergy(MIN_ACTIVATION_ENERGY, MIN_ACTIVATION_ENERGY, true); - workCounter++; - } + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + return energyManager.receiveEnergy(from, maxReceive, simulate); + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + return energyManager.extractEnergy(from, maxExtract, simulate); + } + + @Override + public int getEnergyStored(ForgeDirection from) { + return energyManager.getEnergyStored(from); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + return energyManager.getMaxEnergyStored(from); + } + + @Override + public boolean canConnectEnergy(ForgeDirection from) { + return energyManager.canConnectEnergy(from); } } From 3468169bf945becd884117ec08b068254cc4d228 Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 02:13:57 -0700 Subject: [PATCH 29/37] Removed last of buildcraft.api.power --- .../forestry/core/gadgets/TileForestry.java | 17 ------- .../forestry/core/gadgets/TilePowered.java | 45 +++++++------------ .../java/forestry/core/gui/GuiForestry.java | 2 +- .../java/forestry/core/gui/PowerLedger.java | 13 +++--- .../core/interfaces/IPowerHandler.java | 8 ++-- .../java/forestry/energy/EnergyManager.java | 8 ++++ .../forestry/farming/gadgets/TileGearbox.java | 21 ++++----- .../forestry/plugins/PluginBuildCraft.java | 11 ----- 8 files changed, 45 insertions(+), 80 deletions(-) diff --git a/src/main/java/forestry/core/gadgets/TileForestry.java b/src/main/java/forestry/core/gadgets/TileForestry.java index 38e2fcdc3..a9304f064 100755 --- a/src/main/java/forestry/core/gadgets/TileForestry.java +++ b/src/main/java/forestry/core/gadgets/TileForestry.java @@ -23,9 +23,6 @@ import net.minecraft.util.MathHelper; import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.FluidTankInfo; import buildcraft.api.gates.ITrigger; import com.mojang.authlib.GameProfile; @@ -33,27 +30,20 @@ import com.mojang.authlib.GameProfile; import forestry.core.EnumErrorCode; import forestry.core.config.Config; import forestry.core.config.Defaults; -import forestry.core.fluids.tanks.FakeTank; import forestry.core.interfaces.IErrorSource; -import forestry.core.interfaces.ILiquidTankContainer; import forestry.core.interfaces.IOwnable; -import forestry.core.interfaces.IPowerHandler; import forestry.core.network.ForestryPacket; import forestry.core.network.INetworkedEntity; import forestry.core.network.PacketPayload; import forestry.core.network.PacketTileUpdate; import forestry.core.proxy.Proxies; import forestry.core.utils.EnumAccess; -import forestry.core.fluids.tanks.StandardTank; import forestry.core.utils.InventoryAdapter; import forestry.core.utils.Vect; public abstract class TileForestry extends TileEntity implements INetworkedEntity, IOwnable, IErrorSource { protected boolean isInited = false; - protected int energyConsumed; - protected int energyLast; - protected int energyReceived; public Vect Coords() { return new Vect(xCoord, yCoord, zCoord); @@ -90,13 +80,6 @@ public abstract class TileForestry extends TileEntity implements INetworkedEntit if (!Proxies.common.isSimulating(worldObj)) return; - - if (this instanceof IPowerHandler) { - IPowerHandler receptor = (IPowerHandler) this; - if (receptor.getPowerHandler() != null) { - receptor.getPowerHandler().update(); - } - } } public abstract void initialize(); diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index 823316618..246e10024 100644 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -10,23 +10,22 @@ ******************************************************************************/ package forestry.core.gadgets; -import cofh.api.energy.IEnergyHandler; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; - -import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; - +import forestry.core.fluids.tanks.StandardTank; +import forestry.core.interfaces.IPowerHandler; import forestry.core.interfaces.IRenderableMachine; import forestry.core.network.ClassMap; +import forestry.core.network.EntityNetData; import forestry.core.network.IndexInPayload; import forestry.core.network.PacketPayload; import forestry.core.proxy.Proxies; import forestry.core.utils.EnumTankLevel; -import forestry.core.fluids.tanks.StandardTank; import forestry.energy.EnergyManager; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; -public abstract class TilePowered extends TileBase implements IRenderableMachine, IEnergyHandler { +public abstract class TilePowered extends TileBase implements IRenderableMachine, IPowerHandler { public static int WORK_CYCLES = 4; @@ -64,6 +63,7 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine ex.printStackTrace(); } } + protected final EnergyManager energyManager; public TilePowered(int minAcceptedEnergy, int maxTransfer, int energyPerWork, int capacity) { @@ -71,27 +71,6 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine this.energyManager.setReceiveOnly(); } - /*private final PowerHandler powerHandler; - - public TilePowered() { - powerHandler = new PowerHandler(this, Type.MACHINE); - configurePowerProvider(powerHandler); - adjustPowerProvider(powerHandler); - } - - protected void configurePowerProvider(PowerHandler provider) { - provider.configure(Defaults.MACHINE_MIN_ENERGY_RECEIVED, Defaults.MACHINE_MAX_ENERGY_RECEIVED, - Defaults.MACHINE_MIN_ACTIVATION_ENERGY, Defaults.MACHINE_MAX_ENERGY); - } - - private void adjustPowerProvider(PowerHandler provider) { - provider.configure( - provider.getMinEnergyReceived(), - Math.round(provider.getMaxEnergyReceived() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")), - Math.round(provider.getActivationEnergy() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier")), - Math.round(provider.getMaxEnergyStored() * GameMode.getGameMode().getFloatSetting("energy.demand.modifier"))); - }*/ - /* STATE INFORMATION */ public abstract boolean isWorking(); @@ -172,6 +151,12 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine return EnumTankLevel.EMPTY; } + /* IPowerHandler */ + @Override + public EnergyManager getEnergyManager() { + return energyManager; + } + @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { return energyManager.receiveEnergy(from, maxReceive, simulate); diff --git a/src/main/java/forestry/core/gui/GuiForestry.java b/src/main/java/forestry/core/gui/GuiForestry.java index c1af240dd..7a9c15c2d 100755 --- a/src/main/java/forestry/core/gui/GuiForestry.java +++ b/src/main/java/forestry/core/gui/GuiForestry.java @@ -96,7 +96,7 @@ public abstract class GuiForestry extends GuiContainer i if (inventory instanceof IClimatised && ((IClimatised) inventory).isClimatized()) ledgerManager.add(new ClimateLedger(ledgerManager, (IClimatised) inventory)); - if (!Config.disableEnergyStat && inventory instanceof IPowerHandler) + if (!Config.disableEnergyStat && inventory instanceof IPowerHandler && ((IPowerHandler) inventory).getEnergyManager().getMaxEnergyStored() > 0) ledgerManager.add(new PowerLedger(ledgerManager, (IPowerHandler) inventory)); if (!Config.disableHints && inventory instanceof IHintSource && ((IHintSource) inventory).hasHints()) diff --git a/src/main/java/forestry/core/gui/PowerLedger.java b/src/main/java/forestry/core/gui/PowerLedger.java index 9c185432b..87ca3b98d 100755 --- a/src/main/java/forestry/core/gui/PowerLedger.java +++ b/src/main/java/forestry/core/gui/PowerLedger.java @@ -10,11 +10,10 @@ ******************************************************************************/ package forestry.core.gui; -import buildcraft.api.power.PowerHandler; - import forestry.core.interfaces.IPowerHandler; import forestry.core.render.TextureManager; import forestry.core.utils.StringUtil; +import forestry.energy.EnergyManager; public class PowerLedger extends Ledger { @@ -38,23 +37,23 @@ public class PowerLedger extends Ledger { if (!isFullyOpened()) return; - PowerHandler handler = tile.getPowerHandler(); + EnergyManager energyManager = tile.getEnergyManager(); manager.minecraft.fontRenderer.drawStringWithShadow(StringUtil.localize("gui.energy"), x + 22, y + 8, manager.gui.fontColor.get("ledger.power.header")); manager.minecraft.fontRenderer.drawStringWithShadow(StringUtil.localize("gui.stored") + ":", x + 22, y + 20, manager.gui.fontColor.get("ledger.power.subheader")); - manager.minecraft.fontRenderer.drawString(handler.getEnergyStored() + " MJ", x + 22, y + 32, manager.gui.fontColor.get("ledger.power.text")); + manager.minecraft.fontRenderer.drawString(energyManager.getTotalEnergyStored() + " RF", x + 22, y + 32, manager.gui.fontColor.get("ledger.power.text")); manager.minecraft.fontRenderer.drawStringWithShadow(StringUtil.localize("gui.maxenergy") + ":", x + 22, y + 44, manager.gui.fontColor.get("ledger.power.subheader")); - manager.minecraft.fontRenderer.drawString(handler.getMaxEnergyStored() + " MJ", x + 22, y + 56, manager.gui.fontColor.get("ledger.power.text")); + manager.minecraft.fontRenderer.drawString(energyManager.getMaxEnergyStored() + " RF", x + 22, y + 56, manager.gui.fontColor.get("ledger.power.text")); manager.minecraft.fontRenderer.drawStringWithShadow(StringUtil.localize("gui.maxenergyreceive") + ":", x + 22, y + 68, manager.gui.fontColor.get("ledger.power.subheader")); - manager.minecraft.fontRenderer.drawString(handler.getMaxEnergyReceived() + " MJ", x + 22, y + 80, manager.gui.fontColor.get("ledger.power.text")); + manager.minecraft.fontRenderer.drawString(energyManager.getMaxEnergyReceived() + " RF", x + 22, y + 80, manager.gui.fontColor.get("ledger.power.text")); } @Override public String getTooltip() { - return tile.getPowerHandler().getEnergyStored() + " MJ"; + return tile.getEnergyManager().getTotalEnergyStored() + " RF"; } } diff --git a/src/main/java/forestry/core/interfaces/IPowerHandler.java b/src/main/java/forestry/core/interfaces/IPowerHandler.java index 0e731babf..10dcd1f23 100755 --- a/src/main/java/forestry/core/interfaces/IPowerHandler.java +++ b/src/main/java/forestry/core/interfaces/IPowerHandler.java @@ -10,9 +10,9 @@ ******************************************************************************/ package forestry.core.interfaces; -import buildcraft.api.power.IPowerReceptor; -import buildcraft.api.power.PowerHandler; +import cofh.api.energy.IEnergyHandler; +import forestry.energy.EnergyManager; -public interface IPowerHandler extends IPowerReceptor { - PowerHandler getPowerHandler(); +public interface IPowerHandler extends IEnergyHandler { + EnergyManager getEnergyManager(); } diff --git a/src/main/java/forestry/energy/EnergyManager.java b/src/main/java/forestry/energy/EnergyManager.java index 2090b0e76..d3eb4eec4 100644 --- a/src/main/java/forestry/energy/EnergyManager.java +++ b/src/main/java/forestry/energy/EnergyManager.java @@ -114,6 +114,14 @@ public class EnergyManager implements IEnergyHandler { return energyStorage.getMaxEnergyStored(); } + public int getMaxEnergyStored() { + return energyStorage.getMaxEnergyStored(); + } + + public int getMaxEnergyReceived() { + return energyStorage.getMaxReceive(); + } + @Override public boolean canConnectEnergy(ForgeDirection from) { return true; diff --git a/src/main/java/forestry/farming/gadgets/TileGearbox.java b/src/main/java/forestry/farming/gadgets/TileGearbox.java index 726cd2a3d..b6012c761 100755 --- a/src/main/java/forestry/farming/gadgets/TileGearbox.java +++ b/src/main/java/forestry/farming/gadgets/TileGearbox.java @@ -10,21 +10,20 @@ ******************************************************************************/ package forestry.farming.gadgets; -import cofh.api.energy.IEnergyHandler; - -import forestry.energy.EnergyManager; -import net.minecraft.nbt.NBTTagCompound; - import forestry.api.core.ITileStructure; import forestry.api.farming.IFarmHousing; +import forestry.core.interfaces.IPowerHandler; +import forestry.energy.EnergyManager; +import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.common.util.ForgeDirection; -public class TileGearbox extends TileFarm implements IEnergyHandler { +public class TileGearbox extends TileFarm implements IPowerHandler { public static int WORK_CYCLES = 4; private int activationDelay = 0; private int previousDelays = 0; private int workCounter; + private final EnergyManager energyManager; public TileGearbox() { energyManager = new EnergyManager(50, 200, 50, 10000); @@ -60,9 +59,6 @@ public class TileGearbox extends TileFarm implements IEnergyHandler { nbttagcompound.setInteger("PrevDelays", previousDelays); } - /* POWER */ - EnergyManager energyManager; - @Override protected void updateServerSide() { super.updateServerSide(); @@ -93,7 +89,12 @@ public class TileGearbox extends TileFarm implements IEnergyHandler { } } - /* IEnergyHandler */ + /* IPowerHandler */ + @Override + public EnergyManager getEnergyManager() { + return energyManager; + } + @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { return energyManager.receiveEnergy(from, maxReceive, simulate); diff --git a/src/main/java/forestry/plugins/PluginBuildCraft.java b/src/main/java/forestry/plugins/PluginBuildCraft.java index 5b0c5a636..4cfe9a58b 100755 --- a/src/main/java/forestry/plugins/PluginBuildCraft.java +++ b/src/main/java/forestry/plugins/PluginBuildCraft.java @@ -17,7 +17,6 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; -import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; @@ -26,8 +25,6 @@ import buildcraft.api.fuels.IronEngineFuel; import buildcraft.api.gates.ActionManager; import buildcraft.api.gates.ITrigger; import buildcraft.api.gates.ITriggerProvider; -import buildcraft.api.power.PowerHandler; -import buildcraft.api.power.PowerHandler.PowerReceiver; import buildcraft.api.recipes.BuildcraftRecipes; import buildcraft.api.transport.IPipeTile; @@ -134,14 +131,6 @@ public class PluginBuildCraft extends ForestryPlugin implements ITriggerProvider Proxies.common.addRecipe(new ItemStack(pipeWaterproof), "#", '#', ForestryItem.beeswax); } - public double invokeUseEnergyMethod(PowerHandler workProvider, float min, float max, boolean doUse) { - return workProvider.useEnergy(min, max, doUse); - } - - public void invokeReceiveEnergyMethod(PowerHandler.Type type, PowerReceiver receiver, double extractedEnergy, ForgeDirection from) { - receiver.receiveEnergy(type, extractedEnergy, from); - } - // / ITRIGGERPROVIDER @Override public LinkedList getPipeTriggers(IPipeTile pipe) { From a80bcef949b59199092a897c69f5ffd9fe369d5a Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 02:21:59 -0700 Subject: [PATCH 30/37] Converted MJ to RF in circuits and Tin Engine --- .../forestry/energy/circuits/CircuitElectricBoost.java | 4 ++-- .../energy/circuits/CircuitElectricChange.java | 10 +++++----- .../forestry/energy/circuits/CircuitElectricChoke.java | 2 +- src/main/java/forestry/energy/gadgets/EngineTin.java | 4 ++-- src/main/java/forestry/plugins/PluginEnergy.java | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/main/java/forestry/energy/circuits/CircuitElectricBoost.java b/src/main/java/forestry/energy/circuits/CircuitElectricBoost.java index acdad1149..5e0293127 100755 --- a/src/main/java/forestry/energy/circuits/CircuitElectricBoost.java +++ b/src/main/java/forestry/energy/circuits/CircuitElectricBoost.java @@ -12,10 +12,10 @@ package forestry.energy.circuits; public class CircuitElectricBoost extends CircuitElectricChange { - public CircuitElectricBoost(String uid, int limit, int eu, int mj) { + public CircuitElectricBoost(String uid, int limit, int eu, int rf) { super(uid, false); this.setLimit(limit); - this.configureChange(eu, mj); + this.configureChange(eu, rf); } } diff --git a/src/main/java/forestry/energy/circuits/CircuitElectricChange.java b/src/main/java/forestry/energy/circuits/CircuitElectricChange.java index a438271e0..9b9ac78fa 100755 --- a/src/main/java/forestry/energy/circuits/CircuitElectricChange.java +++ b/src/main/java/forestry/energy/circuits/CircuitElectricChange.java @@ -18,15 +18,15 @@ import forestry.energy.gadgets.EngineTin; public abstract class CircuitElectricChange extends Circuit { int euChange = 7; - int mjChange = 2; + int rfChange = 20; public CircuitElectricChange(String uid, boolean requiresDiscovery) { super(uid, requiresDiscovery); } - protected void configureChange(int euChange, int mjChange) { + protected void configureChange(int euChange, int rfChange) { this.euChange = euChange; - this.mjChange = mjChange; + this.rfChange = rfChange; } @Override @@ -40,7 +40,7 @@ public abstract class CircuitElectricChange extends Circuit { return; EngineTin engine = (EngineTin) tile; - engine.changeEnergyConfig(euChange, mjChange, 2 * euChange); + engine.changeEnergyConfig(euChange, rfChange, 2 * euChange); } @Override @@ -54,7 +54,7 @@ public abstract class CircuitElectricChange extends Circuit { return; EngineTin engine = (EngineTin) tile; - engine.changeEnergyConfig(-euChange, -mjChange, -(2 * euChange)); + engine.changeEnergyConfig(-euChange, -rfChange, -(2 * euChange)); } @Override diff --git a/src/main/java/forestry/energy/circuits/CircuitElectricChoke.java b/src/main/java/forestry/energy/circuits/CircuitElectricChoke.java index e385e9032..0f706cb59 100755 --- a/src/main/java/forestry/energy/circuits/CircuitElectricChoke.java +++ b/src/main/java/forestry/energy/circuits/CircuitElectricChoke.java @@ -14,7 +14,7 @@ public class CircuitElectricChoke extends CircuitElectricChange { public CircuitElectricChoke(String uid) { super(uid, false); - this.configureChange(-2, -1); + this.configureChange(-2, -10); this.setLimit(1); } } diff --git a/src/main/java/forestry/energy/gadgets/EngineTin.java b/src/main/java/forestry/energy/gadgets/EngineTin.java index 37722db17..3ea63c568 100755 --- a/src/main/java/forestry/energy/gadgets/EngineTin.java +++ b/src/main/java/forestry/energy/gadgets/EngineTin.java @@ -256,9 +256,9 @@ public class EngineTin extends Engine implements ISocketable, IInventory { } // / ENERGY CONFIG CHANGE - public void changeEnergyConfig(int euChange, int mjChange, int storageChange) { + public void changeEnergyConfig(int euChange, int rfChange, int storageChange) { euConfig.euForCycle += euChange; - euConfig.rfPerCycle += mjChange; + euConfig.rfPerCycle += rfChange; euConfig.euStorage += storageChange; if (ic2EnergySink != null) ic2EnergySink.setCapacity(euConfig.euStorage); diff --git a/src/main/java/forestry/plugins/PluginEnergy.java b/src/main/java/forestry/plugins/PluginEnergy.java index 95f98caf4..9d3bbb370 100755 --- a/src/main/java/forestry/plugins/PluginEnergy.java +++ b/src/main/java/forestry/plugins/PluginEnergy.java @@ -153,8 +153,8 @@ public class PluginEnergy extends ForestryPlugin { Circuit.energyElectricChoke1 = new CircuitElectricChoke("electric.choke.1"); Circuit.energyFireDampener1 = new CircuitFireDampener("dampener.1"); Circuit.energyElectricEfficiency1 = new CircuitElectricEfficiency("electric.efficiency.1"); - Circuit.energyElectricBoost1 = new CircuitElectricBoost("electric.boost.1", 2, 7, 2); - Circuit.energyElectricBoost2 = new CircuitElectricBoost("electric.boost.2", 2, 15, 4); + Circuit.energyElectricBoost1 = new CircuitElectricBoost("electric.boost.1", 2, 7, 20); + Circuit.energyElectricBoost2 = new CircuitElectricBoost("electric.boost.2", 2, 15, 40); } @Override From ef49ae7a4a6a067e368724860fc71160e4a7b385 Mon Sep 17 00:00:00 2001 From: mezz Date: Mon, 22 Sep 2014 02:35:33 -0700 Subject: [PATCH 31/37] Convert MJ hints and descriptions to RF --- lang | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lang b/lang index c3743cfd7..bf2d9ab15 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit c3743cfd74a24aa096240e637868da95eaad7d03 +Subproject commit bf2d9ab15e8070e73a1377ebb5b070b539bea4cf From 27d8f9f585ab8f6bcbc8bbffd8cc0876da53efed Mon Sep 17 00:00:00 2001 From: CovertJaguar Date: Mon, 22 Sep 2014 06:26:28 -0700 Subject: [PATCH 32/37] Update submodules --- lang | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lang b/lang index bf2d9ab15..6577b87e0 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit bf2d9ab15e8070e73a1377ebb5b070b539bea4cf +Subproject commit 6577b87e0739355c7bed48e2280b5c6290b5acfb From 4e124f680d2a081cb88d184bc5cbe2d851729ae8 Mon Sep 17 00:00:00 2001 From: mezz Date: Thu, 25 Sep 2014 02:53:20 -0700 Subject: [PATCH 33/37] Convert MJ hints and descriptions to RF --- lang | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lang b/lang index a96c1f92b..336f0558c 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit a96c1f92b21206f0ffd6a0e69fb4b6050c551c7f +Subproject commit 336f0558c79c4a9f01706a6e874eac5cb83a8d08 From a8f4cf0e5cf95940742648b8c1285a67e6ce00b2 Mon Sep 17 00:00:00 2001 From: mezz Date: Thu, 25 Sep 2014 03:02:50 -0700 Subject: [PATCH 34/37] Set build.gradle versioning back to normal --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 72be05d61..861cd23d1 100755 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ apply plugin: 'maven' loadProperties() -version = "3.0.0.173-RF-" + System.getenv("DRONE_BUILD_NUMBER") +version = version_major + '.' + version_minor + '.' + version_patch + '.' + getBuildNumber() group= "net.sengir.forestry" // http://maven.apache.org/guides/mini/guide-naming-conventions.html archivesBaseName = "forestry_" + mcversion From 730c08332ece14457031fe276d460d62b04de4b9 Mon Sep 17 00:00:00 2001 From: mezz Date: Thu, 25 Sep 2014 03:04:25 -0700 Subject: [PATCH 35/37] remove isPoweredTile --- src/main/java/forestry/core/utils/BlockUtil.java | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/src/main/java/forestry/core/utils/BlockUtil.java b/src/main/java/forestry/core/utils/BlockUtil.java index de34903a8..1d447c55a 100755 --- a/src/main/java/forestry/core/utils/BlockUtil.java +++ b/src/main/java/forestry/core/utils/BlockUtil.java @@ -147,21 +147,6 @@ public class BlockUtil { return false; } - /** - * @deprecated To be removed when MJ is gone. Use {@link #isRFTile} for now. - */ - @Deprecated - public static boolean isPoweredTile(ForgeDirection side, TileEntity tile) { - if (tile == null) - return false; - - if (!(tile instanceof IPowerReceptor)) - return false; - - IPowerReceptor receptor = (IPowerReceptor) tile; - return receptor.getPowerReceiver(side) != null; - } - public static boolean isRFTile(ForgeDirection side, TileEntity tile) { if (tile == null) return false; From 9df9f1d403c1f54e90539cebd61675fa557e66f1 Mon Sep 17 00:00:00 2001 From: mezz Date: Thu, 25 Sep 2014 03:05:01 -0700 Subject: [PATCH 36/37] Spaces to tabs --- .../java/forestry/core/gadgets/Engine.java | 48 +++++++++---------- .../forestry/core/gadgets/TilePowered.java | 12 ++--- .../java/forestry/core/utils/BlockUtil.java | 16 +++---- 3 files changed, 38 insertions(+), 38 deletions(-) mode change 100755 => 100644 src/main/java/forestry/core/utils/BlockUtil.java diff --git a/src/main/java/forestry/core/gadgets/Engine.java b/src/main/java/forestry/core/gadgets/Engine.java index 12f5e790d..ce3117364 100755 --- a/src/main/java/forestry/core/gadgets/Engine.java +++ b/src/main/java/forestry/core/gadgets/Engine.java @@ -47,7 +47,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public void fromPacketPayload(PacketPayload payload) { - isActive = payload.intPayload[0] > 0; + isActive = payload.intPayload[0] > 0; energyManager.fromPacketInt(payload.intPayload[1]); heat = payload.intPayload[2]; @@ -70,7 +70,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { protected final int maxHeat; protected boolean forceCooldown = false; public float progress; - protected EnergyManager energyManager; + protected EnergyManager energyManager; public Engine(int maxHeat, int maxEnergy, int maxEnergyExtracted) { this.maxHeat = maxHeat; @@ -129,7 +129,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { forceCooldown = false; // Determine targeted tile - TileEntity tile = worldObj.getTileEntity(xCoord + getOrientation().offsetX, yCoord + getOrientation().offsetY, zCoord + getOrientation().offsetZ); + TileEntity tile = worldObj.getTileEntity(xCoord + getOrientation().offsetX, yCoord + getOrientation().offsetY, zCoord + getOrientation().offsetZ); float newPistonSpeed = getPistonSpeed(); if (newPistonSpeed != pistonSpeedServer) { @@ -188,7 +188,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { for (int i = getOrientation().ordinal() + 1; i <= getOrientation().ordinal() + 6; ++i) { ForgeDirection orient = ForgeDirection.values()[i % 6]; - TileEntity tile = worldObj.getTileEntity(xCoord + orient.offsetX, yCoord + orient.offsetY, zCoord + orient.offsetZ); + TileEntity tile = worldObj.getTileEntity(xCoord + orient.offsetX, yCoord + orient.offsetY, zCoord + orient.offsetZ); if (BlockUtil.isRFTile(getOrientation().getOpposite(), tile)) { setOrientation(orient); @@ -276,7 +276,7 @@ public abstract class Engine extends TileBase implements IEnergyHandler { @Override public void readFromNBT(NBTTagCompound nbt) { super.readFromNBT(nbt); - energyManager.readFromNBT(nbt); + energyManager.readFromNBT(nbt); heat = nbt.getInteger("EngineHeat"); @@ -299,32 +299,32 @@ public abstract class Engine extends TileBase implements IEnergyHandler { public abstract void sendGUINetworkData(Container containerEngine, ICrafting iCrafting); - @Override - public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { if (from == getOrientation()) return 0; return energyManager.receiveEnergy(from, maxReceive, simulate); - } + } - @Override - public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { if (from != getOrientation()) return 0; - return energyManager.extractEnergy(from, maxExtract, simulate); - } + return energyManager.extractEnergy(from, maxExtract, simulate); + } - @Override - public int getEnergyStored(ForgeDirection from) { - return energyManager.getEnergyStored(from); - } + @Override + public int getEnergyStored(ForgeDirection from) { + return energyManager.getEnergyStored(from); + } - @Override - public int getMaxEnergyStored(ForgeDirection from) { - return energyManager.getMaxEnergyStored(from); - } + @Override + public int getMaxEnergyStored(ForgeDirection from) { + return energyManager.getMaxEnergyStored(from); + } - @Override - public boolean canConnectEnergy(ForgeDirection from) { - return energyManager.canConnectEnergy(from); - } + @Override + public boolean canConnectEnergy(ForgeDirection from) { + return energyManager.canConnectEnergy(from); + } } diff --git a/src/main/java/forestry/core/gadgets/TilePowered.java b/src/main/java/forestry/core/gadgets/TilePowered.java index 246e10024..d67c8f0be 100644 --- a/src/main/java/forestry/core/gadgets/TilePowered.java +++ b/src/main/java/forestry/core/gadgets/TilePowered.java @@ -64,12 +64,12 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine } } - protected final EnergyManager energyManager; + protected final EnergyManager energyManager; public TilePowered(int minAcceptedEnergy, int maxTransfer, int energyPerWork, int capacity) { this.energyManager = new EnergyManager(minAcceptedEnergy, maxTransfer, energyPerWork, capacity); this.energyManager.setReceiveOnly(); - } + } /* STATE INFORMATION */ public abstract boolean isWorking(); @@ -94,9 +94,9 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine if (!Proxies.common.isSimulating(worldObj)) return; - if (workCounter < WORK_CYCLES && energyManager.consumeEnergyToDoWork()) { - workCounter++; - } + if (workCounter < WORK_CYCLES && energyManager.consumeEnergyToDoWork()) { + workCounter++; + } if (workCounter >= WORK_CYCLES && worldObj.getTotalWorldTime() % 5 == 0) { if (workCycle()) @@ -159,7 +159,7 @@ public abstract class TilePowered extends TileBase implements IRenderableMachine @Override public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { - return energyManager.receiveEnergy(from, maxReceive, simulate); + return energyManager.receiveEnergy(from, maxReceive, simulate); } @Override diff --git a/src/main/java/forestry/core/utils/BlockUtil.java b/src/main/java/forestry/core/utils/BlockUtil.java old mode 100755 new mode 100644 index 1d447c55a..6de8a50f9 --- a/src/main/java/forestry/core/utils/BlockUtil.java +++ b/src/main/java/forestry/core/utils/BlockUtil.java @@ -147,16 +147,16 @@ public class BlockUtil { return false; } - public static boolean isRFTile(ForgeDirection side, TileEntity tile) { - if (tile == null) - return false; + public static boolean isRFTile(ForgeDirection side, TileEntity tile) { + if (tile == null) + return false; - if (!(tile instanceof IEnergyHandler)) - return false; + if (!(tile instanceof IEnergyHandler)) + return false; - IEnergyHandler receptor = (IEnergyHandler) tile; - return receptor.canConnectEnergy(side); - } + IEnergyHandler receptor = (IEnergyHandler) tile; + return receptor.canConnectEnergy(side); + } public static boolean tryPlantPot(World world, int x, int y, int z, Block block) { From 0e3b65130019d505c6ac2797358e3526ba65224e Mon Sep 17 00:00:00 2001 From: mezz Date: Thu, 25 Sep 2014 03:33:21 -0700 Subject: [PATCH 37/37] Don't include the IC2 API --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 861cd23d1..a4f40b52b 100755 --- a/build.gradle +++ b/build.gradle @@ -72,7 +72,7 @@ configurations { } dependencies { - apis 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api' + compile 'net.industrial-craft:industrialcraft-2:2.2.575-experimental:api' apis 'com.mod-buildcraft:buildcraft:6.0.18:dev' }