Move sources and resources

11 files changed, 2740 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/ChargingHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/ChargingHelper.java
new file mode 100644
index 0000000000..70c7b2da23
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/ChargingHelper.java
@@ -0,0 +1,429 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.common.items.GT_MetaGenerated_Item_01;
+import gregtech.common.items.GT_MetaGenerated_Item_02;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.NBTUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic.GregtechMetaWirelessCharger;
+import ic2.api.info.Info;
+import ic2.api.item.ElectricItem;
+import ic2.api.item.IElectricItem;
+import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent;
+
+public class ChargingHelper {
+
+	private static Map<EntityPlayer, Pair<GregtechMetaWirelessCharger, Byte>> mValidPlayers = new HashMap<EntityPlayer, Pair<GregtechMetaWirelessCharger, Byte>>();
+	protected static Map<BlockPos, GregtechMetaWirelessCharger> mChargerMap = new HashMap<BlockPos, GregtechMetaWirelessCharger>();
+	private int mTickTimer = 0;
+	private final int mTickMultiplier = 20;
+
+	//Called whenever the player is updated or ticked. 
+	@SubscribeEvent(priority = EventPriority.HIGHEST)
+	public void onPlayerTick(LivingUpdateEvent event) {
+		try {
+			if (event.entity != null && event.entityLiving != null){		
+				if (event.entityLiving instanceof EntityPlayer){
+					EntityPlayer mPlayerMan = (EntityPlayer) event.entityLiving;
+
+
+					if (mPlayerMan != null){
+						//Utils.LOG_WARNING("Found Player.");
+
+						if (Utils.isServer()){
+							//Utils.LOG_WARNING("Found Server-Side.");
+
+							mTickTimer++;				
+							if (mTickTimer % mTickMultiplier == 0){					
+
+								long mVoltage = 0;
+								long mEuStored = 0;
+
+								if (!mChargerMap.isEmpty() && mValidPlayers.containsKey(mPlayerMan)){
+									InventoryPlayer mPlayerInventory = mPlayerMan.inventory;
+									ItemStack[] mArmourContents = mPlayerInventory.armorInventory.clone();
+									ItemStack[] mInventoryContents = mPlayerInventory.mainInventory.clone();
+
+									for (GregtechMetaWirelessCharger mEntityTemp : mChargerMap.values()){
+										if (mEntityTemp != null){
+											if (mPlayerMan.getEntityWorld().provider.dimensionId == mEntityTemp.getDimensionID()){										
+												mVoltage = mEntityTemp.maxEUInput();
+												mEuStored = mEntityTemp.getEUVar();
+												if (mVoltage > 0 && mEuStored >= mVoltage){								
+
+													Map<EntityPlayer, UUID> LR = mEntityTemp.getLongRangeMap();
+													Map<UUID, EntityPlayer> LO = mEntityTemp.getLocalMap();
+
+													long mStartingEu = mEntityTemp.getEUVar();
+													long mCurrentEu = mEntityTemp.getEUVar();
+													long mEuUsed = 0;
+													if (mEntityTemp.getMode() == 0){
+														if (!LR.isEmpty() && LR.containsKey(mPlayerMan)){
+															mCurrentEu = chargeItems(mEntityTemp, mArmourContents, mPlayerMan);
+															mCurrentEu = chargeItems(mEntityTemp, mInventoryContents, mPlayerMan);
+														}
+													}
+													else if (mEntityTemp.getMode() == 1){
+														if (!LO.isEmpty() && LO.containsValue(mPlayerMan)){
+															mCurrentEu = chargeItems(mEntityTemp, mArmourContents, mPlayerMan);
+															mCurrentEu = chargeItems(mEntityTemp, mInventoryContents, mPlayerMan);
+														}
+													}
+													else {
+														if (!LR.isEmpty() && LR.containsKey(mPlayerMan)){
+															mCurrentEu = chargeItems(mEntityTemp, mArmourContents, mPlayerMan);
+															mCurrentEu = chargeItems(mEntityTemp, mInventoryContents, mPlayerMan);
+														}
+														if (!LO.isEmpty() && LO.containsValue(mPlayerMan)){
+															mCurrentEu = chargeItems(mEntityTemp, mArmourContents, mPlayerMan);
+															mCurrentEu = chargeItems(mEntityTemp, mInventoryContents, mPlayerMan);
+														}
+													}	
+
+													if ((mEuUsed = (mStartingEu - mCurrentEu)) <= 0 && mEntityTemp != null){
+														long mMaxDistance;
+														if (mEntityTemp.getMode() == 0){
+															mMaxDistance = (4*GT_Values.V[mEntityTemp.getTier()]);
+														}
+														else if (mEntityTemp.getMode() == 1){
+															mMaxDistance = (mEntityTemp.getTier()*10);
+														}
+														else {
+															mMaxDistance = (4*GT_Values.V[mEntityTemp.getTier()]/2);										
+														}
+														double mDistance = calculateDistance(mEntityTemp, mPlayerMan);
+														long mVoltageCost = MathUtils.findPercentageOfInt(mMaxDistance, (float) mDistance);
+
+														if (mVoltageCost > 0){
+															if (mVoltageCost > mEntityTemp.maxEUInput()){
+																mEntityTemp.setEUVar((mEntityTemp.getEUVar()-mEntityTemp.maxEUInput()));
+															}
+															else {
+																mEntityTemp.setEUVar((mEntityTemp.getEUVar()-mVoltageCost));
+															}
+														}
+													}
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		catch (Throwable t){
+			//Utils.LOG_WARNING("State of Wireless Charger changed in an invalid way, this prevented a crash.");
+
+			if (!mChargerMap.isEmpty()){				
+				for (GregtechMetaWirelessCharger r : mChargerMap.values()){
+					if (r == null){
+						mChargerMap.remove(r);
+					}
+				}				
+			}			
+			//t.printStackTrace();
+		}
+
+
+	}
+
+	public static boolean addEntry(BlockPos mPos, GregtechMetaWirelessCharger mEntity){
+		if (mEntity == null){
+			return false;
+		}
+		if (!mChargerMap.containsKey(mPos)){
+			if (mChargerMap.put(mPos, mEntity) == null){
+				return true;
+			}
+			else {
+				return false;
+			}
+		}
+		else {
+			return false;
+		}
+	}
+
+	public static boolean removeEntry(BlockPos mPos, GregtechMetaWirelessCharger mEntity){
+		if (mEntity == null){
+			return false;
+		}
+		if (mChargerMap.containsKey(mPos)){
+			if (mChargerMap.remove(mPos, mEntity)){
+				return true;
+			}
+			else {
+				return false;
+			}
+		}
+		else {
+			return false;
+		}
+	}
+
+	public static boolean addValidPlayer(EntityPlayer mPlayer, GregtechMetaWirelessCharger mEntity){
+		if (mEntity == null){
+			return false;
+		}
+		Logger.WARNING("trying to map new player");
+		if (mValidPlayers.containsKey(mPlayer)){
+			Logger.WARNING("Key contains player already?");
+			return false;
+		}
+		else {
+			Logger.WARNING("key not found, adding");
+			Pair<GregtechMetaWirelessCharger, Byte> mEntry = new Pair<GregtechMetaWirelessCharger, Byte>(mEntity, (byte) mEntity.getMode());
+			if (mValidPlayers.put(mPlayer, mEntry) == null){
+				Logger.WARNING("Added a Player to the Tick Map.");
+				return true;
+			}
+			else {
+				Logger.WARNING("Tried to add player but it was already there?");
+				return false;
+			}
+		}
+	}
+
+	public static boolean removeValidPlayer(EntityPlayer mPlayer, GregtechMetaWirelessCharger mEntity){
+		if (mEntity == null){
+			return false;
+		}
+		Logger.WARNING("trying to remove player from map");
+		if (mValidPlayers.containsKey(mPlayer)){
+			Logger.WARNING("key found, removing");
+			Pair<GregtechMetaWirelessCharger, Byte> mEntry = new Pair<GregtechMetaWirelessCharger, Byte>(mEntity, (byte) mEntity.getMode());
+			if (mValidPlayers.remove(mPlayer, mEntry)){
+				Logger.WARNING("Removed a Player to the Tick Map.");
+				return true;
+			}
+			else {
+				Logger.WARNING("Tried to remove player but it was not there?");
+				return false;
+			}
+		}
+		else {
+			Logger.WARNING("Key does not contain player?");
+			return false;
+		}
+	}
+
+	public double calculateDistance(GregtechMetaWirelessCharger mEntityTemp, EntityPlayer mPlayerMan){
+		if (mEntityTemp == null || mPlayerMan == null){
+			return 0;
+		}
+		return mEntityTemp.getDistanceBetweenTwoPositions(mEntityTemp.getTileEntityPosition(), mEntityTemp.getPositionOfEntity(mPlayerMan));
+	}
+
+	public long chargeItems(GregtechMetaWirelessCharger mEntity, ItemStack[] mItems, EntityPlayer mPlayer){
+		if (mEntity == null){
+			return -100;
+		}
+		if (mItems == null || mItems.length == 0){
+			return mEntity.getEUVar();
+		}
+		long mInitialValue = mEntity.getEUVar();
+		long mReturnValue = chargeItemsEx(mEntity, mItems, mPlayer);		
+		return ((mReturnValue < mInitialValue) ? mReturnValue : mInitialValue);
+	}
+
+	public long chargeItemsEx(GregtechMetaWirelessCharger mEntity, ItemStack[] mItems, EntityPlayer mPlayer){
+
+		//Bad Entity
+		if (mEntity == null){
+			return -100;
+		}
+		//Bad Inventory
+		if (mItems == null || mItems.length == 0){
+			return mEntity.getEUVar();
+		}
+		//Set Variables to Charge
+		int mChargedItems = 0;
+		final int mTier = mEntity.getTier();
+		final long mVoltage = mEntity.maxEUInput();
+		long mEuStored = mEntity.getEUVar();
+		final long mEuStoredOriginal = mEntity.getEUVar();
+		//For Inventory Contents
+
+		int mItemSlot = 0;
+
+		for (ItemStack mTemp : mItems){
+			mItemSlot++;
+			if (mTemp != null){
+				Logger.WARNING("Slot "+mItemSlot+" contains "+mTemp.getDisplayName());
+			}
+			//Is item Electrical
+			if (isItemValid(mTemp)){
+				Logger.WARNING("1");
+
+				//Transfer Limit
+				double mItemEuTLimit = ((IElectricItem) mTemp.getItem()).getTransferLimit(mTemp);
+				//Check if Tile has more or equal EU to what can be transferred into the item.
+				if (mEuStored >= mItemEuTLimit){
+					Logger.WARNING("2");
+
+					double mItemMaxCharge = ((IElectricItem) mTemp.getItem()).getMaxCharge(mTemp);
+					double mitemCurrentCharge = ElectricItem.manager.getCharge(mTemp);
+
+					if (mitemCurrentCharge >= mItemMaxCharge){
+						continue;
+					}
+
+					//Try get charge direct from NBT for GT and IC2 stacks
+						Logger.WARNING("3");						
+						if (mTemp.getItem() instanceof GT_MetaGenerated_Tool_01 
+								|| mTemp.getItem() instanceof GT_MetaGenerated_Item_01 
+								|| mTemp.getItem() instanceof GT_MetaGenerated_Item_02 
+								|| ReflectionUtils.getClass("gregtech.common.items.GT_MetaGenerated_Item_03").isInstance(mTemp.getItem()) 
+								|| mTemp.getItem().getClass().getName().toLowerCase().equals(("gregtech.common.items.GT_MetaGenerated_Tool_01").toLowerCase())){
+							if (!NBTUtils.hasKey(mTemp, "GT.ItemCharge")){
+								if (!mTemp.getDisplayName().toLowerCase().contains("battery")){
+									if (!GT_ModHandler.isElectricItem(mTemp)){
+										continue;
+									}
+								}
+								else {
+									mitemCurrentCharge = 0;
+								}
+							}
+							else {
+								mitemCurrentCharge = NBTUtils.getLong(mTemp, "GT.ItemCharge");
+							}
+						}
+						else if (mTemp.getItem() instanceof IElectricItem){
+							mitemCurrentCharge = NBTUtils.getLong(mTemp, "charge");
+						}			
+
+					double mVoltageIncrease;
+					if (mItemEuTLimit >= mVoltage){
+						mVoltageIncrease = mVoltage;
+					}
+					else if (mItemEuTLimit < mVoltage){
+						mVoltageIncrease = mItemEuTLimit;						
+					}
+					else {
+						mVoltageIncrease = mItemEuTLimit;
+					}
+
+					Logger.WARNING("4");
+
+					int mMulti;
+					if ((mitemCurrentCharge + (mVoltageIncrease*20)) <= (mItemMaxCharge - (mVoltageIncrease*20))){
+						mMulti = 20;
+					}
+					else if ((mitemCurrentCharge + (mVoltageIncrease*10)) <= (mItemMaxCharge - (mVoltageIncrease*10))){
+						mMulti = 10;
+					}
+					else if ((mitemCurrentCharge + (mVoltageIncrease*5)) <= (mItemMaxCharge - (mVoltageIncrease*5))){
+						mMulti = 5;
+					}
+					else {
+						mMulti = 1;
+					}
+					Logger.WARNING("5");
+
+
+					int mMultiVoltage = (int) (mMulti*mVoltageIncrease);
+
+					if ((mitemCurrentCharge + mMultiVoltage) <= mItemMaxCharge){
+						Logger.WARNING("6");
+						int g = 0;
+						if ((g = GT_ModHandler.chargeElectricItem(mTemp, mMultiVoltage, Integer.MAX_VALUE, true, false)) > 0){
+							Logger.WARNING("6.5 - "+g+" - "+mMulti);
+							for (int i=0; i<mMulti;i++){
+								if (ElectricItem.manager.charge(mTemp, mVoltageIncrease, Integer.MAX_VALUE, false, false) > 0){
+									continue;
+								}
+							}
+						}
+						if (ElectricItem.manager.getCharge(mTemp) > mitemCurrentCharge){
+							Logger.WARNING("7");
+							mEntity.setEUVar(mEuStored-(mVoltage*mMulti));
+							mEuStored = mEntity.getEUVar();
+							Logger.WARNING("Charged "+mTemp.getDisplayName()+" | Slot: "+mItemSlot+" | EU Multiplier: "+mMulti+" | EU/t input: "+mVoltageIncrease+" | EU/t consumed by Tile: "+mVoltage+" | Item Max Charge: "+mItemMaxCharge+" | Item Start Charge: "+mitemCurrentCharge+" | Item New Charge"+ElectricItem.manager.getCharge(mTemp));
+							mChargedItems++;
+						}
+					}
+					
+					//Try top up Item Chrage
+					mitemCurrentCharge = ElectricItem.manager.getCharge(mTemp);
+					if (mitemCurrentCharge < mItemMaxCharge && mitemCurrentCharge >= (mItemMaxCharge-mVoltage)){						
+						int xDif = (int) (mItemMaxCharge - mitemCurrentCharge);						
+						Logger.WARNING("8 - "+xDif);
+						int g = 0;
+						if ((g = GT_ModHandler.chargeElectricItem(mTemp, xDif, Integer.MAX_VALUE, true, false)) >= 0){
+							Logger.WARNING("8.5 - "+g);
+							if (ElectricItem.manager.getCharge(mTemp) >= mItemMaxCharge){
+								Logger.WARNING("9");
+								mEntity.setEUVar(mEntity.getEUVar()-(xDif));
+								mEuStored = mEntity.getEUVar();
+								Logger.WARNING("Charged "+mTemp.getDisplayName()+" | Slot: "+mItemSlot+" | EU Multiplier: "+mMulti+" | EU/t input: "+mVoltageIncrease+" | EU/t consumed by Tile: "+mVoltage+" | Item Max Charge: "+mItemMaxCharge+" | Item Start Charge: "+mitemCurrentCharge+" | Item New Charge"+ElectricItem.manager.getCharge(mTemp));
+								mChargedItems++;
+							}						
+						}						
+					}
+
+
+				}
+			}
+			else {
+				if (mTemp != null){
+					Logger.WARNING("Found Non-Valid item. "+mTemp.getDisplayName());
+				}
+			}
+		}
+
+		//Return Values
+		if (mChargedItems < 1){
+			return mEuStoredOriginal;
+		}
+
+		return mEntity.getEUVar();
+	}
+
+	public static boolean isItemValid(final ItemStack itemstack) {
+		if (itemstack == null){
+			return false;
+		}
+		if (GT_ModHandler.isElectricItem(itemstack)){
+			return true;
+		}
+		if ((accepts(itemstack)) || (itemstack.getItem() instanceof IElectricItem)) {
+			return true;
+		}
+		return false;
+	}
+
+	public static boolean accepts(final ItemStack stack) {
+		if (stack == null) {
+			return false;
+		}
+		else {
+			return false;
+		}
+		//return (Info.itemEnergy.getEnergyValue(stack) > 0.0D) || (ElectricItem.manager.discharge(stack, (1.0D / 0.0D), 4, true, true, true) > 0.0D);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/CraftingHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/CraftingHelper.java
new file mode 100644
index 0000000000..e06636e168
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/CraftingHelper.java
@@ -0,0 +1,42 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldServer;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.xmod.gregtech.common.helpers.autocrafter.AC_Helper_Container;
+import gtPlusPlus.xmod.gregtech.common.helpers.autocrafter.AC_Helper_Utils;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.GT4Entity_AutoCrafter;
+import net.minecraftforge.common.util.FakePlayerFactory;
+
+public class CraftingHelper{
+
+	public final String mInventoryName;
+	public final int mPosX;
+	public final int mPosY;
+	public final int mPosZ;
+	public final GT4Entity_AutoCrafter crafter;
+	public final World world;
+	public final EntityPlayerMP player;
+	public final AC_Helper_Container inventory;
+
+	public CraftingHelper(GT4Entity_AutoCrafter AC){
+		Logger.INFO("[A-C] Created a crafting helper.");
+		crafter = AC;
+		AC_Helper_Utils.addCrafter(AC);
+		//Get some variables.
+		world = AC.getBaseMetaTileEntity().getWorld();
+		mPosX = AC.getBaseMetaTileEntity().getXCoord();
+		mPosY = AC.getBaseMetaTileEntity().getYCoord();
+		mPosZ = AC.getBaseMetaTileEntity().getZCoord();
+		//Create Fake player to handle crating.
+		
+		player = CORE.getFakePlayer(world);
+		//Set storage container
+		inventory = new AC_Helper_Container(player.inventory, world, mPosX, mPosY, mPosZ);
+		mInventoryName = inventory.getMatrix().getInventoryName();
+
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/FlotationRecipeHandler.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/FlotationRecipeHandler.java
new file mode 100644
index 0000000000..333939d800
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/FlotationRecipeHandler.java
@@ -0,0 +1,79 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import java.util.HashMap;
+
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.util.data.AES;
+import gtPlusPlus.xmod.gregtech.api.enums.CustomOrePrefix;
+import net.minecraft.item.ItemStack;
+
+public class FlotationRecipeHandler {
+
+	private static HashMap<String, Material> sMaterialMap = new HashMap<String, Material>();
+	private static HashMap<String, ItemStack> sMilledMap = new HashMap<String, ItemStack>();
+	private static final AES sEncodingHandler = new AES();
+	
+	public static boolean registerOreType(Material aMaterial) {	
+		String aMaterialKey = sEncodingHandler.encode(aMaterial.getUnlocalizedName());
+		if (sMaterialMap.containsKey(aMaterialKey)) {
+			CORE.crash("Tried to register a Flotation material to an ID already in use. ID: "+aMaterialKey);
+			return false;
+		}
+		else {
+			sMaterialMap.put(aMaterialKey, aMaterial);
+			sMilledMap.put(aMaterialKey, aMaterial.getMilled(1));
+		}		
+		return true;
+	}
+	
+	public static int getHashForMaterial(Material aMaterial) {
+		return getMaterialsID(aMaterial).hashCode();
+	}
+	
+	public static String getMaterialsID(Material aMaterial) {
+		for (String aKey : sMaterialMap.keySet()) {
+			if (sMaterialMap.get(aKey).equals(aMaterial)) {
+				return aKey;
+			}
+		}		
+		return "BAD_MATERIAL_ID";
+	}
+	
+	public static Material getMaterialOfMilledProduct(ItemStack aMilled) {
+		for (String aKey : sMilledMap.keySet()) {
+			ItemStack aTempMilledStack = sMilledMap.get(aKey);
+			if (GT_Utility.areStacksEqual(aTempMilledStack, aMilled, true)) {
+				return sMaterialMap.get(aKey);
+			}
+		}		
+		return null;
+	}
+	
+	public static ItemStack findMilledStack(GT_Recipe aRecipe) {
+		if (aRecipe == null || aRecipe.mInputs == null || aRecipe.mInputs.length <= 0) {
+			return null;
+		}
+		return findMilledStack(aRecipe.mInputs);
+	}
+	
+	public static ItemStack findMilledStack(ItemStack[] aInputs) {
+		if (aInputs == null || aInputs.length <= 0) {
+			return null;
+		}
+		for (ItemStack aStack : aInputs) {
+			if (CustomOrePrefix.milled.get().contains(aStack)) {
+				return aStack;
+			}
+		}		
+		return null;
+	}
+	
+	public static AES getEncoder() {
+		return sEncodingHandler;
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/GT_MethodHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/GT_MethodHelper.java
new file mode 100644
index 0000000000..d51107bbf0
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/GT_MethodHelper.java
@@ -0,0 +1,80 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.metatileentity.BaseMetaTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+
+public class GT_MethodHelper {
+
+	private static final Method mGetTexture;
+	private static final Class mITexturedTileEntity;
+
+	static {
+		Class clazz = null;
+		Method aMeth = null;
+		if (ReflectionUtils.doesClassExist("gregtech.api.interfaces.tileentity.ITexturedTileEntity")) {
+			clazz = ReflectionUtils.getClass("gregtech.api.interfaces.tileentity.ITexturedTileEntity");
+			aMeth = ReflectionUtils.getMethod(clazz, "getTexture", Block.class, byte.class);
+		}
+		mITexturedTileEntity = clazz;
+		mGetTexture = aMeth;
+	}
+
+
+	public static ITexture[] getTexture(TileEntity tTileEntity, Block aBlock, byte aSide) {
+
+		if (mITexturedTileEntity.isInstance(tTileEntity)) {
+
+			if (mGetTexture != null) {
+				try {
+					mGetTexture.invoke(tTileEntity, aBlock, aSide);
+				}
+				catch (IllegalAccessException | IllegalArgumentException
+						| InvocationTargetException e) {
+					e.printStackTrace();
+				}
+			}
+			else {
+				if (tTileEntity instanceof BaseMetaTileEntity) {
+					try {
+						BaseMetaTileEntity aTile = (BaseMetaTileEntity) tTileEntity;					
+						ITexture rIcon = aTile.getCoverTexture(aSide);
+						Field aFacing = ReflectionUtils.getField(BaseMetaTileEntity.class, "mFacing");
+						Field aColor = ReflectionUtils.getField(BaseMetaTileEntity.class, "mColor");
+						Field aActive = ReflectionUtils.getField(BaseMetaTileEntity.class, "mActive");
+						Field aMetaTile = ReflectionUtils.getField(BaseMetaTileEntity.class, "mMetaTileEntity");
+						Method aHasValidTile = ReflectionUtils.getMethod(BaseMetaTileEntity.class, "hasValidMetaTileEntity", new Class[] {});
+
+						boolean hasValidTileObj = (boolean) aHasValidTile.invoke(aTile, new Object[] {});
+						boolean aActiveObj = aActive.getBoolean(aTile);
+						byte aFacingObj = aFacing.getByte(aTile);
+						byte aColorObj = aColor.getByte(aTile);;
+						MetaTileEntity aMetaTileObj = (MetaTileEntity) aMetaTile.get(aTile);
+
+						if (rIcon != null) {
+							return new ITexture[]{rIcon};
+						} else {
+							return hasValidTileObj
+									? aMetaTileObj.getTexture(aTile, aSide, aFacingObj, (byte) (aColorObj - 1), aActiveObj,
+											aTile.getOutputRedstoneSignal(aSide) > 0)
+											: BlockIcons.ERROR_RENDERING;
+						}
+					}
+					catch (Throwable t) {
+						t.printStackTrace();
+					}
+				}
+			}
+		}
+		return BlockIcons.ERROR_RENDERING;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/MachineUpdateHandler.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/MachineUpdateHandler.java
new file mode 100644
index 0000000000..0b52560e0d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/MachineUpdateHandler.java
@@ -0,0 +1,42 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import java.util.HashMap;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gregtech.api.GregTech_API;
+import net.minecraft.block.Block;
+import net.minecraftforge.event.world.BlockEvent;
+
+public class MachineUpdateHandler {
+
+	private static final HashMap<String, Block> mBlockCache = new HashMap<String, Block>();
+	
+	public static void registerBlockToCauseMachineUpdate(String aUnlocalName, Block aBlock) {
+		mBlockCache.put(aUnlocalName, aBlock);
+	}
+	
+    @SubscribeEvent
+    public void onBlockEvent(BlockEvent event) {
+    	Block aBlock = event.block;
+    	String aUnlocalName = aBlock != null ? aBlock.getUnlocalizedName() : "NULL";
+    	boolean aDoUpdate = false;
+    	if (aBlock != null && aUnlocalName != null && !aUnlocalName.equals("NULL")) {
+    		for (String aCachedName : mBlockCache.keySet()) {
+    			if (aCachedName.equals(aUnlocalName)) {
+					aDoUpdate = true;
+					break;    				
+    			}
+    			else {
+    				if (aBlock == mBlockCache.get(aCachedName)) {
+    					aDoUpdate = true;
+    					break;
+    				}
+    			}
+    		}
+    		if (aDoUpdate) {
+        		GregTech_API.causeMachineUpdate(event.world, event.x, event.y, event.z);    			
+    		}
+    	}
+    }
+	
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java
new file mode 100644
index 0000000000..2ff2712952
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java
@@ -0,0 +1,1033 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableTreeFarmerParticles;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.google.common.collect.Lists;
+
+import gnu.trove.set.hash.THashSet;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Optional;
+import cpw.mods.fml.common.eventhandler.Event.Result;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
+
+import gregtech.api.enums.*;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockAir;
+import net.minecraft.block.IGrowable;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.ChunkPosition;
+import net.minecraft.world.World;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.common.items.GT_MetaGenerated_Item_02;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.players.FakeFarmer;
+import gtPlusPlus.core.slots.SlotBuzzSaw.SAWTOOL;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.particles.BlockBreakParticles;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechItems;
+import net.minecraftforge.common.ForgeHooks;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.BonemealEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class TreeFarmHelper {
+
+	public static final FluidStack fertT1 = FluidUtils.getFluidStack("fluid.fertiliser", 3);
+	public static final FluidStack fertT2 = FluidUtils.getFluidStack("fluid.un18fertiliser", 2);
+	public static final FluidStack fertT3 = FluidUtils.getFluidStack("fluid.un32fertiliser", 1);
+	private static final int sawOreId = OreDictionary.getOreID(ToolDictNames.craftingToolSaw.name());
+
+	public static ITexture[][][] getTextureSet() {
+		final ITexture[][][] rTextures = new ITexture[10][17][];
+		for (byte i = -1; i < 16; i++) {
+			rTextures[0][i + 1] = TreeFarmHelper.getFront(i);
+			rTextures[1][i + 1] = TreeFarmHelper.getBack(i);
+			rTextures[2][i + 1] = TreeFarmHelper.getBottom(i);
+			rTextures[3][i + 1] = TreeFarmHelper.getTop(i);
+			rTextures[4][i + 1] = TreeFarmHelper.getSides(i);
+			rTextures[5][i + 1] = TreeFarmHelper.getFrontActive(i);
+			rTextures[6][i + 1] = TreeFarmHelper.getBackActive(i);
+			rTextures[7][i + 1] = TreeFarmHelper.getBottomActive(i);
+			rTextures[8][i + 1] = TreeFarmHelper.getTopActive(i);
+			rTextures[9][i + 1] = TreeFarmHelper.getSidesActive(i);
+		}
+		return rTextures;
+	}
+
+	public static ITexture[] getFront(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[2][aColor + 1]};
+	}
+
+	public static ITexture[] getBack(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[2][aColor + 1]};
+	}
+
+	public static ITexture[] getBottom(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[2][aColor + 1]};
+	}
+
+	public static ITexture[] getTop(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[2][aColor + 1]};
+	}
+
+	public static ITexture[] getSides(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[2][aColor + 1]};
+	}
+
+	public static ITexture[] getFrontActive(final byte aColor) {
+		return getFront(aColor);
+	}
+
+	public static ITexture[] getBackActive(final byte aColor) {
+		return getBack(aColor);
+	}
+
+	public static ITexture[] getBottomActive(final byte aColor) {
+		return getBottom(aColor);
+	}
+
+	public static ITexture[] getTopActive(final byte aColor) {
+		return getTop(aColor);
+	}
+
+	public static ITexture[] getSidesActive(final byte aColor) {
+		return getSides(aColor);
+	}
+
+	public static boolean applyBonemeal(final EntityPlayer player, final World world, final int intX, final int intY, final int intZ, final short multiplier){
+		final Block block = world.getBlock(intX, intY, intZ);
+
+
+		int roll;
+		int rollNeeded;
+
+		if (multiplier==1){
+			roll = MathUtils.randInt(1, 15);
+			rollNeeded = 15;
+		}
+		else if (multiplier==2){
+			roll = MathUtils.randInt(1, 10);
+			rollNeeded = 10;
+		}
+		else {
+			roll = MathUtils.randInt(1, 5);
+			rollNeeded = 5;
+		}
+
+		if (roll != rollNeeded){
+			return false;
+		}
+
+		//EntityPlayer player = FakePlayerFactory.getMinecraft((WorldServer)world);
+		if (!world.isRemote){
+			if (enableTreeFarmerParticles){
+				world.playAuxSFX(2005, intX, intY, intZ, 0);
+			}
+		}
+		final BonemealEvent event = new BonemealEvent(player, world, block, intX, intY, intZ);
+		if (MinecraftForge.EVENT_BUS.post(event)){
+			Logger.MACHINE_INFO("Not sure why this returned false");
+			return false;
+		}
+		if (event.getResult() == Result.ALLOW){
+			if (!world.isRemote){
+				world.playAuxSFX(2005, intX, intY, intZ, 0);
+			}
+			return true;
+		}
+		if (block instanceof IGrowable){
+			final IGrowable igrowable = (IGrowable)block;
+			if (igrowable.func_149851_a(world, intX, intY, intZ, world.isRemote)){
+				if (!world.isRemote){
+					if (igrowable.func_149852_a(world, CORE.RANDOM, intX, intY, intZ)){
+						igrowable.func_149853_b(world, CORE.RANDOM, intX, intY, intZ);
+					}
+				}
+				return true;
+			}
+		}
+		return false;