From 5834a266fdf425ad56558db71691f9b3b0df5e31 Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Tue, 17 Jan 2017 19:41:46 +1000 Subject: % Tried to improve the logic for the Tree Farmer, to support Forestry 4. % Moved COFH API related files. + Added a child mod, for misc handling. $$ Borrowed some code from MFR, to attempt forestry support. (Credit left, will re-do if I even get it working). --- src/Java/api/cofh/energy/EnergyStorage.java | 129 ---------- src/Java/api/cofh/energy/IEnergyConnection.java | 8 - src/Java/api/cofh/energy/IEnergyContainerItem.java | 14 - src/Java/api/cofh/energy/IEnergyHandler.java | 15 -- src/Java/api/cofh/energy/IEnergyProvider.java | 13 - src/Java/api/cofh/energy/IEnergyReceiver.java | 13 - src/Java/api/cofh/energy/IEnergyStorage.java | 12 - src/Java/api/cofh/energy/ItemEnergyContainer.java | 98 ------- src/Java/api/cofh/energy/TileEnergyHandler.java | 49 ---- src/Java/cofh/energy/EnergyStorage.java | 129 ++++++++++ src/Java/cofh/energy/IEnergyConnection.java | 8 + src/Java/cofh/energy/IEnergyContainerItem.java | 14 + src/Java/cofh/energy/IEnergyHandler.java | 15 ++ src/Java/cofh/energy/IEnergyProvider.java | 13 + src/Java/cofh/energy/IEnergyReceiver.java | 13 + src/Java/cofh/energy/IEnergyStorage.java | 12 + src/Java/cofh/energy/ItemEnergyContainer.java | 98 +++++++ src/Java/cofh/energy/TileEnergyHandler.java | 49 ++++ src/Java/cofh/mod/BaseMod.java | 284 +++++++++++++++++++++ src/Java/cofh/mod/ChildMod.java | 17 ++ src/Java/cofh/mod/ChildModContainer.java | 43 ++++ .../core/item/general/RF2EU_Battery.java | 2 +- src/Java/gtPlusPlus/xmod/forestry/Forestry.java | 127 +++++++++ .../xmod/forestry/trees/ForestryLeaf.java | 160 ++++++++++++ .../xmod/forestry/trees/ForestrySapling.java | 55 ++++ .../xmod/forestry/trees/TreefarmManager.java | 20 +- .../GregtechMetaPipeEntity_Cable.java | 2 +- .../GregtechMetaPipeEntity_SuperConductor.java | 2 +- .../base/GregtechMetaPipeEntityBase_Cable.java | 2 +- .../multi/GregtechMetaTileEntityTreeFarm.java | 220 +++++++++++----- .../minefactoryreloaded/api/EmptyReplacement.java | 20 ++ .../minefactoryreloaded/api/HarvestType.java | 56 ++++ .../minefactoryreloaded/api/IFactoryFruit.java | 106 ++++++++ .../api/IFactoryHarvestable.java | 104 ++++++++ .../minefactoryreloaded/api/IFactoryPlantable.java | 94 +++++++ .../minefactoryreloaded/api/ReplacementBlock.java | 135 ++++++++++ .../harvestables/HarvestableShearable.java | 50 ++++ .../harvestables/HarvestableStandard.java | 71 ++++++ .../harvestables/HarvestableTreeLeaves.java | 33 +++ .../farmables/plantables/PlantableStandard.java | 116 +++++++++ 40 files changed, 2007 insertions(+), 414 deletions(-) delete mode 100644 src/Java/api/cofh/energy/EnergyStorage.java delete mode 100644 src/Java/api/cofh/energy/IEnergyConnection.java delete mode 100644 src/Java/api/cofh/energy/IEnergyContainerItem.java delete mode 100644 src/Java/api/cofh/energy/IEnergyHandler.java delete mode 100644 src/Java/api/cofh/energy/IEnergyProvider.java delete mode 100644 src/Java/api/cofh/energy/IEnergyReceiver.java delete mode 100644 src/Java/api/cofh/energy/IEnergyStorage.java delete mode 100644 src/Java/api/cofh/energy/ItemEnergyContainer.java delete mode 100644 src/Java/api/cofh/energy/TileEnergyHandler.java create mode 100644 src/Java/cofh/energy/EnergyStorage.java create mode 100644 src/Java/cofh/energy/IEnergyConnection.java create mode 100644 src/Java/cofh/energy/IEnergyContainerItem.java create mode 100644 src/Java/cofh/energy/IEnergyHandler.java create mode 100644 src/Java/cofh/energy/IEnergyProvider.java create mode 100644 src/Java/cofh/energy/IEnergyReceiver.java create mode 100644 src/Java/cofh/energy/IEnergyStorage.java create mode 100644 src/Java/cofh/energy/ItemEnergyContainer.java create mode 100644 src/Java/cofh/energy/TileEnergyHandler.java create mode 100644 src/Java/cofh/mod/BaseMod.java create mode 100644 src/Java/cofh/mod/ChildMod.java create mode 100644 src/Java/cofh/mod/ChildModContainer.java create mode 100644 src/Java/gtPlusPlus/xmod/forestry/Forestry.java create mode 100644 src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java create mode 100644 src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java create mode 100644 src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java (limited to 'src/Java') diff --git a/src/Java/api/cofh/energy/EnergyStorage.java b/src/Java/api/cofh/energy/EnergyStorage.java deleted file mode 100644 index a6ec363709..0000000000 --- a/src/Java/api/cofh/energy/EnergyStorage.java +++ /dev/null @@ -1,129 +0,0 @@ -package api.cofh.energy; - -import net.minecraft.nbt.NBTTagCompound; - -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 (this.energy > this.capacity) { - this.energy = this.capacity; - } - return this; - } - - public NBTTagCompound writeToNBT(NBTTagCompound nbt) - { - if (this.energy < 0) { - this.energy = 0; - } - nbt.setInteger("Energy", this.energy); - return nbt; - } - - public void setCapacity(int capacity) - { - this.capacity = capacity; - if (this.energy > capacity) { - this.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 this.maxReceive; - } - - public int getMaxExtract() - { - return this.maxExtract; - } - - public void setEnergyStored(int energy) - { - this.energy = energy; - if (this.energy > this.capacity) { - this.energy = this.capacity; - } else if (this.energy < 0) { - this.energy = 0; - } - } - - public void modifyEnergyStored(int energy) - { - this.energy += energy; - if (this.energy > this.capacity) { - this.energy = this.capacity; - } else if (this.energy < 0) { - this.energy = 0; - } - } - - public int receiveEnergy(int maxReceive, boolean simulate) - { - int energyReceived = Math.min(this.capacity - this.energy, Math.min(this.maxReceive, maxReceive)); - if (!simulate) { - this.energy += energyReceived; - } - return energyReceived; - } - - public int extractEnergy(int maxExtract, boolean simulate) - { - int energyExtracted = Math.min(this.energy, Math.min(this.maxExtract, maxExtract)); - if (!simulate) { - this.energy -= energyExtracted; - } - return energyExtracted; - } - - public int getEnergyStored() - { - return this.energy; - } - - public int getMaxEnergyStored() - { - return this.capacity; - } -} diff --git a/src/Java/api/cofh/energy/IEnergyConnection.java b/src/Java/api/cofh/energy/IEnergyConnection.java deleted file mode 100644 index 6351f7702d..0000000000 --- a/src/Java/api/cofh/energy/IEnergyConnection.java +++ /dev/null @@ -1,8 +0,0 @@ -package api.cofh.energy; - -import net.minecraftforge.common.util.ForgeDirection; - -public abstract interface IEnergyConnection -{ - public abstract boolean canConnectEnergy(ForgeDirection paramForgeDirection); -} diff --git a/src/Java/api/cofh/energy/IEnergyContainerItem.java b/src/Java/api/cofh/energy/IEnergyContainerItem.java deleted file mode 100644 index 1f2b8c3c52..0000000000 --- a/src/Java/api/cofh/energy/IEnergyContainerItem.java +++ /dev/null @@ -1,14 +0,0 @@ -package api.cofh.energy; - -import net.minecraft.item.ItemStack; - -public abstract interface IEnergyContainerItem -{ - public abstract int receiveEnergy(ItemStack paramItemStack, int paramInt, boolean paramBoolean); - - public abstract int extractEnergy(ItemStack paramItemStack, int paramInt, boolean paramBoolean); - - public abstract int getEnergyStored(ItemStack paramItemStack); - - public abstract int getMaxEnergyStored(ItemStack paramItemStack); -} diff --git a/src/Java/api/cofh/energy/IEnergyHandler.java b/src/Java/api/cofh/energy/IEnergyHandler.java deleted file mode 100644 index 9d3385c4c0..0000000000 --- a/src/Java/api/cofh/energy/IEnergyHandler.java +++ /dev/null @@ -1,15 +0,0 @@ -package api.cofh.energy; - -import net.minecraftforge.common.util.ForgeDirection; - -public abstract interface IEnergyHandler - extends IEnergyProvider, IEnergyReceiver -{ - public abstract int receiveEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); - - public abstract int extractEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); - - public abstract int getEnergyStored(ForgeDirection paramForgeDirection); - - public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection); -} diff --git a/src/Java/api/cofh/energy/IEnergyProvider.java b/src/Java/api/cofh/energy/IEnergyProvider.java deleted file mode 100644 index ace09db65e..0000000000 --- a/src/Java/api/cofh/energy/IEnergyProvider.java +++ /dev/null @@ -1,13 +0,0 @@ -package api.cofh.energy; - -import net.minecraftforge.common.util.ForgeDirection; - -public abstract interface IEnergyProvider - extends IEnergyConnection -{ - public abstract int extractEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); - - public abstract int getEnergyStored(ForgeDirection paramForgeDirection); - - public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection); -} diff --git a/src/Java/api/cofh/energy/IEnergyReceiver.java b/src/Java/api/cofh/energy/IEnergyReceiver.java deleted file mode 100644 index 68b071b028..0000000000 --- a/src/Java/api/cofh/energy/IEnergyReceiver.java +++ /dev/null @@ -1,13 +0,0 @@ -package api.cofh.energy; - -import net.minecraftforge.common.util.ForgeDirection; - -public abstract interface IEnergyReceiver - extends IEnergyConnection -{ - public abstract int receiveEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); - - public abstract int getEnergyStored(ForgeDirection paramForgeDirection); - - public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection); -} diff --git a/src/Java/api/cofh/energy/IEnergyStorage.java b/src/Java/api/cofh/energy/IEnergyStorage.java deleted file mode 100644 index bf999f8670..0000000000 --- a/src/Java/api/cofh/energy/IEnergyStorage.java +++ /dev/null @@ -1,12 +0,0 @@ -package api.cofh.energy; - -public abstract interface IEnergyStorage -{ - public abstract int receiveEnergy(int paramInt, boolean paramBoolean); - - public abstract int extractEnergy(int paramInt, boolean paramBoolean); - - public abstract int getEnergyStored(); - - public abstract int getMaxEnergyStored(); -} diff --git a/src/Java/api/cofh/energy/ItemEnergyContainer.java b/src/Java/api/cofh/energy/ItemEnergyContainer.java deleted file mode 100644 index f4da898919..0000000000 --- a/src/Java/api/cofh/energy/ItemEnergyContainer.java +++ /dev/null @@ -1,98 +0,0 @@ -package api.cofh.energy; - -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; - -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; - } - - 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(this.capacity - energy, Math.min(this.maxReceive, maxReceive)); - if (!simulate) - { - energy += energyReceived; - container.stackTagCompound.setInteger("Energy", energy); - } - return energyReceived; - } - - 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; - } - - public int getEnergyStored(ItemStack container) - { - if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) { - return 0; - } - return container.stackTagCompound.getInteger("Energy"); - } - - public int getMaxEnergyStored(ItemStack container) - { - return this.capacity; - } -} diff --git a/src/Java/api/cofh/energy/TileEnergyHandler.java b/src/Java/api/cofh/energy/TileEnergyHandler.java deleted file mode 100644 index 606b0ba44b..0000000000 --- a/src/Java/api/cofh/energy/TileEnergyHandler.java +++ /dev/null @@ -1,49 +0,0 @@ -package api.cofh.energy; - -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.tileentity.TileEntity; -import net.minecraftforge.common.util.ForgeDirection; - -public class TileEnergyHandler - extends TileEntity - implements IEnergyHandler -{ - protected EnergyStorage storage = new EnergyStorage(32000); - - public void readFromNBT(NBTTagCompound nbt) - { - super.readFromNBT(nbt); - this.storage.readFromNBT(nbt); - } - - public void writeToNBT(NBTTagCompound nbt) - { - super.writeToNBT(nbt); - this.storage.writeToNBT(nbt); - } - - public boolean canConnectEnergy(ForgeDirection from) - { - return true; - } - - public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) - { - return this.storage.receiveEnergy(maxReceive, simulate); - } - - public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) - { - return this.storage.extractEnergy(maxExtract, simulate); - } - - public int getEnergyStored(ForgeDirection from) - { - return this.storage.getEnergyStored(); - } - - public int getMaxEnergyStored(ForgeDirection from) - { - return this.storage.getMaxEnergyStored(); - } -} diff --git a/src/Java/cofh/energy/EnergyStorage.java b/src/Java/cofh/energy/EnergyStorage.java new file mode 100644 index 0000000000..e48fc7b8ac --- /dev/null +++ b/src/Java/cofh/energy/EnergyStorage.java @@ -0,0 +1,129 @@ +package cofh.energy; + +import net.minecraft.nbt.NBTTagCompound; + +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 (this.energy > this.capacity) { + this.energy = this.capacity; + } + return this; + } + + public NBTTagCompound writeToNBT(NBTTagCompound nbt) + { + if (this.energy < 0) { + this.energy = 0; + } + nbt.setInteger("Energy", this.energy); + return nbt; + } + + public void setCapacity(int capacity) + { + this.capacity = capacity; + if (this.energy > capacity) { + this.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 this.maxReceive; + } + + public int getMaxExtract() + { + return this.maxExtract; + } + + public void setEnergyStored(int energy) + { + this.energy = energy; + if (this.energy > this.capacity) { + this.energy = this.capacity; + } else if (this.energy < 0) { + this.energy = 0; + } + } + + public void modifyEnergyStored(int energy) + { + this.energy += energy; + if (this.energy > this.capacity) { + this.energy = this.capacity; + } else if (this.energy < 0) { + this.energy = 0; + } + } + + public int receiveEnergy(int maxReceive, boolean simulate) + { + int energyReceived = Math.min(this.capacity - this.energy, Math.min(this.maxReceive, maxReceive)); + if (!simulate) { + this.energy += energyReceived; + } + return energyReceived; + } + + public int extractEnergy(int maxExtract, boolean simulate) + { + int energyExtracted = Math.min(this.energy, Math.min(this.maxExtract, maxExtract)); + if (!simulate) { + this.energy -= energyExtracted; + } + return energyExtracted; + } + + public int getEnergyStored() + { + return this.energy; + } + + public int getMaxEnergyStored() + { + return this.capacity; + } +} diff --git a/src/Java/cofh/energy/IEnergyConnection.java b/src/Java/cofh/energy/IEnergyConnection.java new file mode 100644 index 0000000000..96055c2282 --- /dev/null +++ b/src/Java/cofh/energy/IEnergyConnection.java @@ -0,0 +1,8 @@ +package cofh.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +public abstract interface IEnergyConnection +{ + public abstract boolean canConnectEnergy(ForgeDirection paramForgeDirection); +} diff --git a/src/Java/cofh/energy/IEnergyContainerItem.java b/src/Java/cofh/energy/IEnergyContainerItem.java new file mode 100644 index 0000000000..1cce2619ae --- /dev/null +++ b/src/Java/cofh/energy/IEnergyContainerItem.java @@ -0,0 +1,14 @@ +package cofh.energy; + +import net.minecraft.item.ItemStack; + +public abstract interface IEnergyContainerItem +{ + public abstract int receiveEnergy(ItemStack paramItemStack, int paramInt, boolean paramBoolean); + + public abstract int extractEnergy(ItemStack paramItemStack, int paramInt, boolean paramBoolean); + + public abstract int getEnergyStored(ItemStack paramItemStack); + + public abstract int getMaxEnergyStored(ItemStack paramItemStack); +} diff --git a/src/Java/cofh/energy/IEnergyHandler.java b/src/Java/cofh/energy/IEnergyHandler.java new file mode 100644 index 0000000000..89ea0b4eb7 --- /dev/null +++ b/src/Java/cofh/energy/IEnergyHandler.java @@ -0,0 +1,15 @@ +package cofh.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +public abstract interface IEnergyHandler + extends IEnergyProvider, IEnergyReceiver +{ + public abstract int receiveEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); + + public abstract int extractEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); + + public abstract int getEnergyStored(ForgeDirection paramForgeDirection); + + public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection); +} diff --git a/src/Java/cofh/energy/IEnergyProvider.java b/src/Java/cofh/energy/IEnergyProvider.java new file mode 100644 index 0000000000..1f92549c53 --- /dev/null +++ b/src/Java/cofh/energy/IEnergyProvider.java @@ -0,0 +1,13 @@ +package cofh.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +public abstract interface IEnergyProvider + extends IEnergyConnection +{ + public abstract int extractEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); + + public abstract int getEnergyStored(ForgeDirection paramForgeDirection); + + public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection); +} diff --git a/src/Java/cofh/energy/IEnergyReceiver.java b/src/Java/cofh/energy/IEnergyReceiver.java new file mode 100644 index 0000000000..537b4679d5 --- /dev/null +++ b/src/Java/cofh/energy/IEnergyReceiver.java @@ -0,0 +1,13 @@ +package cofh.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +public abstract interface IEnergyReceiver + extends IEnergyConnection +{ + public abstract int receiveEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean); + + public abstract int getEnergyStored(ForgeDirection paramForgeDirection); + + public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection); +} diff --git a/src/Java/cofh/energy/IEnergyStorage.java b/src/Java/cofh/energy/IEnergyStorage.java new file mode 100644 index 0000000000..d105df55c1 --- /dev/null +++ b/src/Java/cofh/energy/IEnergyStorage.java @@ -0,0 +1,12 @@ +package cofh.energy; + +public abstract interface IEnergyStorage +{ + public abstract int receiveEnergy(int paramInt, boolean paramBoolean); + + public abstract int extractEnergy(int paramInt, boolean paramBoolean); + + public abstract int getEnergyStored(); + + public abstract int getMaxEnergyStored(); +} diff --git a/src/Java/cofh/energy/ItemEnergyContainer.java b/src/Java/cofh/energy/ItemEnergyContainer.java new file mode 100644 index 0000000000..697532abe3 --- /dev/null +++ b/src/Java/cofh/energy/ItemEnergyContainer.java @@ -0,0 +1,98 @@ +package cofh.energy; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +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; + } + + 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(this.capacity - energy, Math.min(this.maxReceive, maxReceive)); + if (!simulate) + { + energy += energyReceived; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyReceived; + } + + 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; + } + + public int getEnergyStored(ItemStack container) + { + if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) { + return 0; + } + return container.stackTagCompound.getInteger("Energy"); + } + + public int getMaxEnergyStored(ItemStack container) + { + return this.capacity; + } +} diff --git a/src/Java/cofh/energy/TileEnergyHandler.java b/src/Java/cofh/energy/TileEnergyHandler.java new file mode 100644 index 0000000000..24cd3c0e34 --- /dev/null +++ b/src/Java/cofh/energy/TileEnergyHandler.java @@ -0,0 +1,49 @@ +package cofh.energy; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +public class TileEnergyHandler + extends TileEntity + implements IEnergyHandler +{ + protected EnergyStorage storage = new EnergyStorage(32000); + + public void readFromNBT(NBTTagCompound nbt) + { + super.readFromNBT(nbt); + this.storage.readFromNBT(nbt); + } + + public void writeToNBT(NBTTagCompound nbt) + { + super.writeToNBT(nbt); + this.storage.writeToNBT(nbt); + } + + public boolean canConnectEnergy(ForgeDirection from) + { + return true; + } + + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) + { + return this.storage.receiveEnergy(maxReceive, simulate); + } + + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) + { + return this.storage.extractEnergy(maxExtract, simulate); + } + + public int getEnergyStored(ForgeDirection from) + { + return this.storage.getEnergyStored(); + } + + public int getMaxEnergyStored(ForgeDirection from) + { + return this.storage.getMaxEnergyStored(); + } +} diff --git a/src/Java/cofh/mod/BaseMod.java b/src/Java/cofh/mod/BaseMod.java new file mode 100644 index 0000000000..7ab858eabd --- /dev/null +++ b/src/Java/cofh/mod/BaseMod.java @@ -0,0 +1,284 @@ +package cofh.mod; + +import cofh.mod.updater.IUpdatableMod; +import cofh.mod.updater.ModRange; +import cofh.mod.updater.ModVersion; +import com.google.common.base.Strings; +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.ICrashCallable; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.ModContainer; +import cpw.mods.fml.common.ObfuscationReflectionHelper; +import cpw.mods.fml.common.network.NetworkCheckHandler; +import cpw.mods.fml.common.registry.LanguageRegistry; +import cpw.mods.fml.common.versioning.InvalidVersionSpecificationException; +import cpw.mods.fml.relauncher.FMLLaunchHandler; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Properties; +import java.util.jar.JarFile; +import java.util.zip.ZipEntry; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.resources.IReloadableResourceManager; +import net.minecraft.client.resources.IResource; +import net.minecraft.client.resources.IResourceManager; +import net.minecraft.client.resources.IResourceManagerReloadListener; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StringTranslate; + +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.core.helpers.Loader; +import org.apache.logging.log4j.spi.AbstractLogger; + +public abstract class BaseMod implements IUpdatableMod { + + protected File _configFolder; + protected final String _modid; + protected final Logger _log; + + protected BaseMod(Logger log) { + + String name = getModId(); + _modid = name.toLowerCase(Locale.US); + _log = log; + init(); + } + + protected BaseMod() { + + String name = getModId(); + _modid = name.toLowerCase(Locale.US); + _log = LogManager.getLogger(name); + init(); + } + + private void init() { + + ModContainer container = cpw.mods.fml.common.Loader.instance().activeModContainer(); + if (container.getSource().isDirectory()) { + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable("Loaded from a directory")); + } else { + try { + JarFile jar = new JarFile(container.getSource()); + ZipEntry file = jar.getEntry("vers.prop"); + if (file != null) { + BufferedReader reader = new BufferedReader(new InputStreamReader(jar.getInputStream(file))); + String data = reader.readLine(); + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable(data)); + } else { + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable("Lacking version information.")); + } + jar.close(); + } catch (IOException e) { + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable("Error reading version information." + e.getMessage())); + } + } + } + + @NetworkCheckHandler + public final boolean networkCheck(Map remoteVersions, Side side) throws InvalidVersionSpecificationException { + + if (!requiresRemoteFrom(side)) { + return true; + } + Mod mod = getClass().getAnnotation(Mod.class); + String _modid = mod.modid(); + if (!remoteVersions.containsKey(_modid)) { + return false; + } + String remotes = mod.acceptableRemoteVersions(); + if (!"*".equals(remotes)) { + + String remote = remoteVersions.get(_modid); + if (Strings.isNullOrEmpty(remotes)) { + return getModVersion().equalsIgnoreCase(remote); + } + return ModRange.createFromVersionSpec(_modid, remotes).containsVersion(new ModVersion(_modid, remote)); + } + return true; + } + + protected boolean requiresRemoteFrom(Side side) { + + return true; + } + + protected String getConfigBaseFolder() { + + String base = getClass().getPackage().getName(); + int i = base.indexOf('.'); + if (i >= 0) { + return base.substring(0, i); + } + return ""; + } + + protected void setConfigFolderBase(File folder) { + + _configFolder = new File(folder, getConfigBaseFolder() + "/" + _modid + "/"); + } + + protected File getConfig(String name) { + + return new File(_configFolder, name + ".cfg"); + } + + protected File getClientConfig() { + + return getConfig("client"); + } + + protected File getCommonConfig() { + + return getConfig("common"); + } + + protected String getAssetDir() { + + return _modid; + } + + @Override + public Logger getLogger() { + + return _log; + } + + private void loadLanguageFile(Properties lang, InputStream stream) throws Throwable { + + InputStreamReader is = new InputStreamReader(stream, "UTF-8"); + + Properties langPack = new Properties(); + langPack.load(is); + + lang.putAll(langPack); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private void loadLanguageFile(String lang, Properties langPack) { + + HashMap parsedLangFile = new HashMap(); + parsedLangFile.putAll((Map) langPack); // lovely casting hack + + LanguageRegistry.instance().injectLanguage(lang.intern(), parsedLangFile); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + protected void loadLang() { + + if (FMLLaunchHandler.side() == Side.CLIENT) { + try { + loadClientLang(); + return; + } catch (Throwable t) { + _log.error(AbstractLogger.CATCHING_MARKER, "???", t); + } + } + + String path = "assets/" + getAssetDir() + "/language/"; + String lang = "en_US"; + try (InputStream is = Loader.getResource(path + lang + ".lang", null).openStream();) { + Properties langPack = new Properties(); + loadLanguageFile(langPack, is); + + StringTranslate i = ObfuscationReflectionHelper.getPrivateValue(StringTranslate.class, null, "instance", "field_74817_a"); + Map m = ObfuscationReflectionHelper.getPrivateValue(StringTranslate.class, i, "field_74816_c", "languageList"); + m.putAll(langPack); + } catch (Throwable t) { + _log.catching(Level.INFO, t); + } + } + + @SideOnly(Side.CLIENT) + private void loadClientLang() { + + IReloadableResourceManager manager = (IReloadableResourceManager) Minecraft.getMinecraft().getResourceManager(); + manager.registerReloadListener(new LangManager(manager)); + } + + @SideOnly(Side.CLIENT) + private class LangManager implements IResourceManagerReloadListener { + + private final String _path; + + public LangManager(IResourceManager manager) { + + _path = getAssetDir() + ":language/"; + onResourceManagerReload(manager); + } + + @Override + public void onResourceManagerReload(IResourceManager manager) { + + String l = null; + try { + l = Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage().getLanguageCode(); + } catch (Throwable t) { + _log.catching(Level.WARN, t); + } + + for (String lang : Arrays.asList("en_US", l)) { + if (lang != null) { + Properties langPack = new Properties(); + try { + List files = manager.getAllResources(new ResourceLocation(_path + lang + ".lang")); + for (IResource file : files) { + if (file.getInputStream() == null) { + _log.warn("A resource pack defines an entry for language '" + lang + "' but the InputStream is null."); + continue; + } + try { + loadLanguageFile(langPack, file.getInputStream()); + } catch (Throwable t) { + _log.warn(AbstractLogger.CATCHING_MARKER, "A resource pack has a file for language '" + lang + "' but the file is invalid.", t); + } + } + } catch (Throwable t) { + _log.info(AbstractLogger.CATCHING_MARKER, "No language data for '" + lang + "'", t); + } + loadLanguageFile(lang, langPack); + } + } + + Minecraft.getMinecraft().getLanguageManager().onResourceManagerReload(manager); + } + } + + private class CrashCallable implements ICrashCallable { + + private final String data; + + private CrashCallable(String data) { + + this.data = data; + } + + @Override + public String call() throws Exception { + + return data; + } + + @Override + public String getLabel() { + + return getModId(); + } + + } + +} diff --git a/src/Java/cofh/mod/ChildMod.java b/src/Java/cofh/mod/ChildMod.java new file mode 100644 index 0000000000..b07c35a8a1 --- /dev/null +++ b/src/Java/cofh/mod/ChildMod.java @@ -0,0 +1,17 @@ +package cofh.mod; + +import cpw.mods.fml.common.Mod; + + +public @interface ChildMod { + + /** + * The {@link Mod} instance defining this ChildMod + */ + Mod[] mod(); + + /** + * The parent {@link Mod} + */ + String parent(); +} diff --git a/src/Java/cofh/mod/ChildModContainer.java b/src/Java/cofh/mod/ChildModContainer.java new file mode 100644 index 0000000000..994fde93a8 --- /dev/null +++ b/src/Java/cofh/mod/ChildModContainer.java @@ -0,0 +1,43 @@ +package cofh.mod; + +import java.util.List; +import java.util.Map; + +import com.google.common.eventbus.EventBus; + +import cpw.mods.fml.common.*; +import cpw.mods.fml.common.discovery.ModCandidate; +import cpw.mods.fml.common.versioning.ArtifactVersion; + +public class ChildModContainer extends FMLModContainer { + + private final String parent; + + @SuppressWarnings("unchecked") + public ChildModContainer(String className, ModCandidate container, Map modDescriptor) { + + super(className, container, (Map)((List)modDescriptor.get("mod")).get(0)); + + parent = (String) modDescriptor.get("parent"); + } + + @Override + public boolean registerBus(EventBus bus, LoadController controller) { + + Map list = Loader.instance().getIndexedModList(); + l: { + if (!list.containsKey(parent)) { + break l; + } + for (ArtifactVersion info : this.getMetadata().dependencies) { + if (!list.containsKey(info.getLabel()) && !ModAPIManager.INSTANCE.hasAPI(info.getLabel())) { + break l; + } + } + return super.registerBus(bus, controller); + } + + return false; + } + +} diff --git a/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java b/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java index 592b41b0e9..146af86302 100644 --- a/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java +++ b/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java @@ -8,7 +8,7 @@ import ic2.api.item.*; import java.util.List; -import api.cofh.energy.ItemEnergyContainer; +import cofh.energy.ItemEnergyContainer; import net.minecraft.client.Minecraft; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; diff --git a/src/Java/gtPlusPlus/xmod/forestry/Forestry.java b/src/Java/gtPlusPlus/xmod/forestry/Forestry.java new file mode 100644 index 0000000000..b21d9a154d --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/forestry/Forestry.java @@ -0,0 +1,127 @@ +package gtPlusPlus.xmod.forestry; + +import static cpw.mods.fml.common.registry.GameRegistry.findBlock; +import static cpw.mods.fml.common.registry.GameRegistry.findItem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.xmod.forestry.trees.ForestryLeaf; +import gtPlusPlus.xmod.forestry.trees.ForestrySapling; +import net.minecraft.block.Block; +import net.minecraft.item.Item; + +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.LogManager; + +import cofh.mod.ChildMod; +import cpw.mods.fml.common.*; +import cpw.mods.fml.common.Mod.CustomProperty; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; + +@ChildMod(parent = CORE.MODID, mod = @Mod(modid = "Gregtech++|CompatForestry", +name = "GT++ Compat: Forestry", +version = CORE.VERSION, +dependencies = "after:Miscutils;after:Forestry", +customProperties = @CustomProperty(k = "cofhversion", v = "true"))) +public class Forestry { + + private static final String name = "Forestry"; + + @EventHandler + public void load(FMLInitializationEvent e) { + + try { + initForestry(); + } catch (Throwable $) { + ModContainer This = FMLCommonHandler.instance().findContainerFor(this); + LogManager.getLogger(This.getModId()).log(Level.ERROR, "There was a problem loading " + This.getName(), $); + } + } + + private static void initForestry() { + + Item item; + + item = findItem(name, "sapling"); + Block block = findBlock(name, "saplingGE"); + if (item != null && block != null) { + ForestrySapling sapling = new ForestrySapling(item, block); + //MFRRegistry.registerPlantable(sapling); + //MFRRegistry.registerFertilizable(sapling); + } else + //Utils.LOG_WARNING("Forestry sapling/block null!"); + + block = findBlock(name, "soil"); + if (block != null) { + //ForestryBogEarth bog = new ForestryBogEarth(block); + //MFRRegistry.registerPlantable(bog); + //MFRRegistry.registerFertilizable(bog); + //MFRRegistry.registerHarvestable(bog); + //MFRRegistry.registerFruit(bog); + } else + //Utils.LOG_WARNING("Forestry bog earth null!"); + + for (int i = 1; true; ++i) { + block = findBlock(name, "log" + i); + l: if (block == null) { + if (i > 1) + Utils.LOG_WARNING("Forestry logs null at " + i + "."); + else { + block = findBlock(name, "logs"); + if (block != null) { + break l; + } + Utils.LOG_WARNING("Forestry logs null!"); + } + break; + } + //MFRRegistry.registerHarvestable(new HarvestableWood(block)); + //MFRRegistry.registerFruitLogBlock(block); + } + + for (int i = 1; true; ++i) { + block = findBlock(name, "fireproofLog" + i); + l: if (block == null) { + if (i > 1) + Utils.LOG_WARNING("Forestry logs null at " + i + "."); + else { + block = findBlock(name, "logsFireproof"); + if (block != null) { + break l; + } + Utils.LOG_WARNING("Forestry logs null!"); + } + break; + } + //MFRRegistry.registerHarvestable(new HarvestableWood(block)); + //MFRRegistry.registerFruitLogBlock(block); + } + + block = findBlock(name, "leaves"); + if (block != null) { + ForestryLeaf leaf = new ForestryLeaf(block); + //MFRRegistry.registerFertilizable(leaf); + //MFRRegistry.registerHarvestable(leaf); + //MFRRegistry.registerFruit(leaf); + } else + Utils.LOG_WARNING("Forestry leaves null!"); + + block = findBlock(name, "pods"); + item = findItem(name, "grafterProven"); + if (block != null) { + //ForestryPod pod = new ForestryPod(block, item); + //MFRRegistry.registerFertilizable(pod); + //MFRRegistry.registerHarvestable(pod); + //MFRRegistry.registerFruit(pod); + } else + Utils.LOG_WARNING("Forestry pods null!"); + } + + @EventHandler + public static void postInit(FMLPostInitializationEvent e) { + //MFRRegistry.registerLiquidDrinkHandler("bioethanol", new DrinkHandlerBiofuel()); + //TileEntityUnifier.updateUnifierLiquids(); + } + +} diff --git a/src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java new file mode 100644 index 0000000000..e2550f4643 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java @@ -0,0 +1,160 @@ +package gtPlusPlus.xmod.forestry.trees; + +import java.util.*; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.*; +import powercrystals.minefactoryreloaded.farmables.harvestables.HarvestableTreeLeaves; +import forestry.api.arboriculture.*; +import forestry.api.genetics.*; + + +public class ForestryLeaf extends HarvestableTreeLeaves implements IFactoryFruit +{ + private ITreeRoot root; + private ReplacementBlock repl; + protected Item _item; + + public ForestryLeaf(Block block) + { + super(block); + root = (ITreeRoot)AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees"); + repl = EmptyReplacement.INSTANCE; + _item = Item.getItemFromBlock(block); + } + + @Override + public boolean canBePicked(World world, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + return fruit.getRipeness() >= 0.99f; + } + return false; + } + + public boolean canFertilize(World world, int x, int y, int z) + { + return !canBePicked(world, x, y, z); + } + + public boolean fertilize(World world, Random rand, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + fruit.addRipeness(1f); + return true; + } + return false; + } + + @Override + public ReplacementBlock getReplacementBlock(World world, int x, int y, int z) + { + return repl; + } + + @Override + public void prePick(World world, int x, int y, int z) + { + } + + @Override // HARVESTER + public List getDrops(World world, Random rand, Map settings, int x, int y, int z) + { + ITree tree = getTree(world, x, y, z); + if (tree == null) + return null; + + ArrayList prod = new ArrayList(); + + float modifier = 1f; + if (settings.get("silkTouch") == Boolean.TRUE) + { + ItemStack item = new ItemStack(_item); + NBTTagCompound tag = new NBTTagCompound(); + tree.writeToNBT(tag); + item.setTagCompound(tag); + prod.add(item); + } + else + { + boolean hasMate = tree.getMate() != null; + for (ITree s : getSaplings(tree, world, x, y, z, modifier)) + if (s != null) { + if ((hasMate && !s.isGeneticEqual(tree)) || rand.nextInt(32) == 0) + if (rand.nextBoolean()) + prod.add(root.getMemberStack(s, EnumGermlingType.POLLEN.ordinal())); + + prod.add(root.getMemberStack(s, EnumGermlingType.SAPLING.ordinal())); + } + + getFruits(world, x, y, z, tree, prod); + } + + return prod; + } + + + private static ITree[] getSaplings(ITree tree, World world, int x, int y, int z, float modifier) { + return tree.getSaplings(world, null, x, y, z, modifier); + } + + @Override // FRUIT PICKER + public List getDrops(World world, Random rand, int x, int y, int z) + { + ITree tree = getTree(world, x, y, z); + if (tree == null) + return null; + + ArrayList prod = new ArrayList(); + getFruits(world, x, y, z, tree, prod); + return prod; + } + + private ITree getTree(World world, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IPollinatable) { + IIndividual t = ((IPollinatable)te).getPollen(); + if (t instanceof ITree) + return (ITree)t; + } + return null; + } + + private void getFruits(World world, int x, int y, int z, ITree tree, ArrayList prod) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + if (fruit.hasFruit()) + { + //int period = tree.getGenome().getFruitProvider().getRipeningPeriod(); + //ItemStack[] o = tree.produceStacks(world, x, y, z, (int)(fruit.getRipeness() * period + 0.1f)); + prod.addAll(fruit.pickFruit(null)); + } + } + } + + @Override + public void postPick(World world, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + fruit.addRipeness(-fruit.getRipeness()); + } + } +} diff --git a/src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java new file mode 100644 index 0000000000..7c81ea0928 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java @@ -0,0 +1,55 @@ +package gtPlusPlus.xmod.forestry.trees; + +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.ReplacementBlock; +import powercrystals.minefactoryreloaded.farmables.plantables.PlantableStandard; +import forestry.api.arboriculture.ITreeRoot; +import forestry.api.genetics.AlleleManager; + +public class ForestrySapling extends PlantableStandard +{ + private ITreeRoot root; + + public ForestrySapling(Item item, Block block) + { + super(item, block, WILDCARD, null); + root = (ITreeRoot)AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees"); + _plantedBlock = new ReplacementBlock((Block)null) { + @Override + public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack) { + return root.plantSapling(world, root.getMember(stack), null, x, y, z); + } + }; + } + + public Block getPlant() + { + return _block; + } + + @Override + public boolean canBePlantedHere(World world, int x, int y, int z, ItemStack stack) + { + if (!world.isAirBlock(x, y, z)) + return false; + + return root.getMember(stack).canStay(world, x, y, z); + } + + public boolean canFertilize(World world, int x, int y, int z) + { + return true; + } + + public boolean fertilize(World world, Random rand, int x, int y, int z) + { + Block block = world.getBlock(x, y, z); + root.getTree(world, x, y, z).getTreeGenerator(world, x, y, z, true).generate(world, rand, x, y, z); + return world.getBlock(x, y, z) != block; + } +} diff --git a/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java b/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java index ba8ffd8284..8fe3f62f23 100644 --- a/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java +++ b/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java @@ -63,7 +63,17 @@ public class TreefarmManager { public static boolean isWoodLog(Block log){ String tTool = log.getHarvestTool(0); - return OrePrefixes.log.contains(new ItemStack(log, 1))&& ((tTool != null) && (tTool.equals("axe"))) || (log.getMaterial() == Material.wood); + + if (log == Blocks.log || log == Blocks.log2){ + return true; + } + + //IC2 Rubber Tree Compat + if (log.getClass().getName().toLowerCase().contains("rubwood")){ + return true; + } + + return OrePrefixes.log.contains(new ItemStack(log, 1))&& ((tTool != null) && (tTool.equals("axe"))) || (log.getMaterial() != Material.wood) ? false : (OrePrefixes.fence.contains(new ItemStack(log, 1)) ? false : true); } public static boolean isLeaves(Block log){ @@ -88,7 +98,7 @@ public class TreefarmManager { } public static boolean isFenceBlock(Block fence){ - return (fence == Blocks.fence ? true : (fence == Blocks.fence_gate ? true : (fence == Blocks.nether_brick_fence ? true : false))); + return (fence == Blocks.fence ? true : (fence == Blocks.fence_gate ? true : (fence == Blocks.nether_brick_fence ? true : (OrePrefixes.fence.contains(new ItemStack(fence, 1)) ? true : false)))); } public static boolean isAirBlock(Block air){ @@ -96,6 +106,12 @@ public class TreefarmManager { if (air.getLocalizedName().toLowerCase().contains("air")){ return true; } + + if (air.getClass().getName().toLowerCase().contains("residual") || air.getClass().getName().toLowerCase().contains("heat")){ + return true; + } + + //Utils.LOG_INFO("Found "+air.getLocalizedName()); return (air == Blocks.air ? true : (air instanceof BlockAir ? true : false)); } diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java index 53865da327..1e88135e94 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java @@ -17,7 +17,7 @@ import ic2.api.energy.tile.IEnergySink; import java.util.ArrayList; import java.util.Arrays; -import api.cofh.energy.IEnergyReceiver; +import cofh.energy.IEnergyReceiver; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; import net.minecraft.tileentity.TileEntity; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java index 8e7cc778bd..23c1f3e47f 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java @@ -18,7 +18,7 @@ import ic2.api.energy.tile.IEnergySink; import java.util.ArrayList; import java.util.Arrays; -import api.cofh.energy.IEnergyReceiver; +import cofh.energy.IEnergyReceiver; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; import net.minecraft.tileentity.TileEntity; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java index 4daa150889..0e7d7f30da 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java @@ -22,7 +22,7 @@ import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Arrays; -import api.cofh.energy.IEnergyReceiver; +import cofh.energy.IEnergyReceiver; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; import net.minecraft.item.ItemStack; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java index a03e4c3952..0587c26b85 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java @@ -11,8 +11,10 @@ import gregtech.api.metatileentity.implementations.*; import gregtech.api.objects.GT_ItemStack; import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; import gtPlusPlus.core.util.Utils; import gtPlusPlus.core.util.item.ItemUtils; +import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.xmod.forestry.trees.TreefarmManager; import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; @@ -35,6 +37,9 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock public ArrayList mCasings = new ArrayList(); /* private */ private int treeCheckTicks = 0; + /* private */ private int plantSaplingTicks = 0; + /* private */ private int cleanupTicks = 0; + /* private */ private boolean canChop = false; public GregtechMetaTileEntityTreeFarm(final int aID, final String aName, final String aNameRegional) { super(aID, aName, aNameRegional); @@ -275,44 +280,83 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock //Tree Manager + private void tickTrees(){ + if (treeCheckTicks > 200){ + treeCheckTicks = 0; + } + else { + treeCheckTicks++; + } + } + + private void tickSaplings(){ + if (plantSaplingTicks > 200){ + plantSaplingTicks = 0; + } + else { + plantSaplingTicks++; + } + } + + private void tickCleanup(){ + if (cleanupTicks > 600){ + cleanupTicks = 0; + } + else { + cleanupTicks++; + } + } + + private void tickHandler(){ + //Count Sapling Timer + tickSaplings(); + //Count Tree Cutting Timer + tickTrees(); + //Tick Cleanup script Timer. + tickCleanup(); + } + + @Override public void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTick) { if (aBaseMetaTileEntity.isServerSide()) { - - //Check Inventory slots [1] + //Check Inventory slots [1] - Find a valid Buzzsaw Blade or a Saw try { Utils.LOG_INFO(mInventory[1].getDisplayName()); } catch (NullPointerException t){} - //Update Tick Timer Last - Do Not move up the call stack - if (treeCheckTicks > 100){ - treeCheckTicks = 0; - } - else { - treeCheckTicks++; - } - - //Set Machine State - if (treeCheckTicks == 100){ - mMachine = checkMachine(aBaseMetaTileEntity, mInventory[1]); - - //If Machine can work and it's only one of two times a second this will tick, tick. - if (mMachine){ + //If Machine can work and it's only once every 5 seconds this will tick. + if (mMachine){ + //Set Machine State + if (treeCheckTicks == 200){ + //mMachine = checkMachine(aBaseMetaTileEntity, mInventory[1]); Utils.LOG_INFO("Looking For Trees - Serverside | "+treeCheckTicks); + //Find wood to Cut findLogs(aBaseMetaTileEntity); - - cleanUp(aBaseMetaTileEntity); - + } + } + else { + if (plantSaplingTicks == 100){ + Utils.LOG_INFO("Looking For space to plant saplings - Serverside | "+plantSaplingTicks); + //Plant Some Saplings plantSaplings(aBaseMetaTileEntity); - + } + else if (plantSaplingTicks == 200){ + Utils.LOG_INFO("Looking For Saplings to grow - Serverside | "+plantSaplingTicks); + //Try Grow some Saplings findSaplings(aBaseMetaTileEntity); + //Set can work state + mMachine = true; } - } - - - - + } + //Call Cleanup Task last, before ticking. + if (cleanupTicks == 600){ + Utils.LOG_INFO("Looking For rubbish to cleanup - Serverside | "+cleanupTicks); + cleanUp(aBaseMetaTileEntity); + } + //Tick TE + tickHandler(); } //Client Side - do nothing @@ -377,6 +421,7 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock } } } + mMachine = false; if (logsCut > 0) cleanUp(aBaseMetaTileEntity); //Utils.LOG_INFO("general failure | maybe there is no logs, not an error. | cut:"+logsCut ); @@ -444,60 +489,98 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock for (int j = -7; j <= 7; j++) { int h = 1; - if (TreefarmManager.isAirBlock(aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j))){ - for (ItemStack n : r){ - if (n != null){ - if (OrePrefixes.sapling.contains(n) || n.getDisplayName().toLowerCase().contains("sapling")){ - Utils.LOG_INFO(""+n.getDisplayName()); - - int posX, posY, posZ; - posX = aBaseMetaTileEntity.getXCoord()+xDir+i; - posY = aBaseMetaTileEntity.getYCoord()+h; - posZ = aBaseMetaTileEntity.getZCoord()+zDir+j; - - //Works for everything but forestry saplings - TODO - Block saplingToPlace = Block.getBlockFromItem(n.getItem()); - - //If sapling block is not null - if (saplingToPlace != null){ - //Plant Sapling - world.setBlock(posX, posY, posZ, saplingToPlace); - world.setBlockMetadataWithNotify(posX, posY, posZ, n.getItemDamage(), 4); - //Deplete Input stack - depleteInput(n); + if ((i != -7 && i != 7) && (j != -7 && j != 7)) { + if (TreefarmManager.isAirBlock(aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j))){ + //Utils.LOG_INFO("Found air"); + if (r.size() > 0){ + Utils.LOG_INFO("r was not null. "+r.size()); + for (ItemStack n : r){ + Utils.LOG_INFO("found "+n.getDisplayName()); + if (OrePrefixes.sapling.contains(n) || n.getDisplayName().toLowerCase().contains("sapling")){ + //Utils.LOG_INFO(""+n.getDisplayName()); + + int posX, posY, posZ; + posX = aBaseMetaTileEntity.getXCoord()+xDir+i; + posY = aBaseMetaTileEntity.getYCoord()+h; + posZ = aBaseMetaTileEntity.getZCoord()+zDir+j; + + //Works for everything but forestry saplings - TODO + Block saplingToPlace; + + if (n.getClass().getName().toLowerCase().contains("forestry")){ + Utils.LOG_INFO("It's a forestry sapling, trying magic."); + saplingToPlace = Block.getBlockFromItem(ItemUtils.getItem("Forestry:saplingGE")); + + } + else { + saplingToPlace = Block.getBlockFromItem(n.getItem()); + } + + + //If sapling block is not null + if (saplingToPlace != null){ + Utils.LOG_INFO("Placing Sapling Block."); + //Plant Sapling + world.setBlock(posX, posY, posZ, saplingToPlace); + world.setBlockMetadataWithNotify(posX, posY, posZ, n.getItemDamage(), 4); + //Deplete Input stack + depleteInput(n); + r = getStoredInputs(); + break; + } + Utils.LOG_INFO(n.getDisplayName()+" did not have a valid block."); + } + else { + Utils.LOG_INFO("item was not a sapling"); } } } + else{ + Utils.LOG_INFO("Input stack empty or null"); + } } - } + else { + Utils.LOG_INFO("No space for sapling, no air."); + } + } + } } Utils.LOG_INFO("Tried to grow saplings: | "+saplings ); return true; } - private Block findAirForSaplingToGrow(){ - return null; - } - private boolean cutLog(final World world, final int x, final int y, final int z){ Utils.LOG_INFO("Cutting Log"); try { //Get Log. final Block block = world.getBlock(x, y, z); //Add the stack to the bus. - addOutput(ItemUtils.getSimpleStack(block)); - //Update bus contents. - updateSlots(); - //Remove drop that was added to the bus. - world.setBlockToAir(x, y, z); - return true; + + ItemStack outputStack = ItemUtils.getSimpleStack(block); + if (outputStack != null){ + Utils.LOG_INFO("Adding 1x "+outputStack.getDisplayName()); + addOutput(outputStack); + //Update bus contents. + updateSlots(); + //Remove drop that was added to the bus. + world.setBlockToAir(x, y, z); + return true; + } + } catch (NullPointerException e){} return false; } public static boolean applyBonemeal(World world, int intX, int intY, int intZ){ Block block = world.getBlock(intX, intY, intZ); + int chance = MathUtils.randInt(0, 10); + + //Random Growth + if (chance < 8){ + return false; + } + EntityPlayer player = FakePlayerFactory.getMinecraft((WorldServer)world); if (!world.isRemote){ if (enableTreeFarmerParticles){ @@ -586,4 +669,27 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock return getSides(aColor); } + + public boolean depleteInputEx(ItemStack aStack) { + if (GT_Utility.isStackInvalid(aStack)) return false; + + Utils.LOG_INFO("Taking one sapling away from in input bus."); + + for (GT_MetaTileEntity_Hatch_InputBus tHatch : this.mInputBusses) { + tHatch.mRecipeMap = getRecipeMap(); + if (isValidMetaTileEntity(tHatch)) { + for (int i = tHatch.getBaseMetaTileEntity().getSizeInventory() - 1; i >= 0; --i) { + if ((!(GT_Utility.areStacksEqual(aStack, tHatch.getBaseMetaTileEntity().getStackInSlot(i)))) || (tHatch.getBaseMetaTileEntity().getStackInSlot(0).stackSize < aStack.stackSize)){ + continue; + } + tHatch.getBaseMetaTileEntity().decrStackSize(0,1); + return true; + } + } + + } + + return false; + } + } \ No newline at end of file diff --git a/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java b/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java new file mode 100644 index 0000000000..ef3fd46bb2 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java @@ -0,0 +1,20 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +public class EmptyReplacement extends ReplacementBlock +{ + public static final EmptyReplacement INSTANCE = new EmptyReplacement(); + + public EmptyReplacement() + { + super((Block)null); + } + + @Override + public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack) { + return true; + } +} diff --git a/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java b/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java new file mode 100644 index 0000000000..85ef23835c --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java @@ -0,0 +1,56 @@ +package powercrystals.minefactoryreloaded.api; + +/** + * Determines what algorithm the Harvester uses when it encounters this + * IFactoryHarvestable in the world. + * + * @author PowerCrystals + */ +public enum HarvestType { + + /** + * Just break the single block - no special action need