From 61acdc7d3e77d9d3375078acd311fd1968a61b2e Mon Sep 17 00:00:00 2001 From: Progwml6 Date: Wed, 2 Oct 2013 00:39:00 -0400 Subject: [PATCH 01/26] add most of AE api, uncomment code for AE charging --- src/appeng/api/Blocks.java | 67 +++++ src/appeng/api/DimentionalCoord.java | 58 +++++ src/appeng/api/IAEItemStack.java | 175 +++++++++++++ src/appeng/api/IAETagCompound.java | 33 +++ src/appeng/api/IAppEngApi.java | 161 ++++++++++++ src/appeng/api/IAppEngGrinderRecipe.java | 45 ++++ src/appeng/api/ICellHandler.java | 25 ++ src/appeng/api/ICellRegistry.java | 31 +++ src/appeng/api/IExternalStorageHandler.java | 27 ++ src/appeng/api/IExternalStorageRegistry.java | 22 ++ src/appeng/api/IGridCacheRegistry.java | 24 ++ src/appeng/api/IGrinderRecipeManager.java | 32 +++ src/appeng/api/IItemComparisionProvider.java | 25 ++ src/appeng/api/IItemComparison.java | 10 + src/appeng/api/IItemList.java | 32 +++ src/appeng/api/ILocateableRegistry.java | 15 ++ .../api/ISpecialComparisonRegistry.java | 24 ++ src/appeng/api/IWirelessTermHandler.java | 49 ++++ src/appeng/api/IWirelessTermRegistery.java | 38 +++ src/appeng/api/Items.java | 36 +++ src/appeng/api/Materials.java | 58 +++++ src/appeng/api/README.txt | 46 ++++ src/appeng/api/TileRef.java | 60 +++++ src/appeng/api/Util.java | 230 ++++++++++++++++++ src/appeng/api/WorldCoord.java | 132 ++++++++++ src/appeng/api/config/ActionItems.java | 17 ++ src/appeng/api/config/CondenserOuput.java | 19 ++ src/appeng/api/config/EnableDisable.java | 18 ++ src/appeng/api/config/FullnessMode.java | 19 ++ src/appeng/api/config/FuzzyMode.java | 27 ++ src/appeng/api/config/IConfigEnum.java | 11 + .../api/config/InterfaceBlockingMode.java | 17 ++ .../api/config/InterfaceCraftingMode.java | 17 ++ src/appeng/api/config/ItemFlow.java | 18 ++ src/appeng/api/config/ListMode.java | 18 ++ src/appeng/api/config/MatchingMode.java | 17 ++ src/appeng/api/config/OperationMode.java | 18 ++ src/appeng/api/config/PowerUnits.java | 19 ++ src/appeng/api/config/RedstoneModeInput.java | 20 ++ .../api/config/RedstoneModeInputOnOff.java | 19 ++ src/appeng/api/config/RedstoneModeOutput.java | 18 ++ src/appeng/api/config/SearchBoxMode.java | 22 ++ src/appeng/api/config/SortDir.java | 18 ++ src/appeng/api/config/SortOrder.java | 20 ++ src/appeng/api/config/StackModeInput.java | 18 ++ src/appeng/api/config/StackModeOutput.java | 20 ++ src/appeng/api/config/TransferDir.java | 18 ++ src/appeng/api/config/ViewItems.java | 19 ++ src/appeng/api/events/AEWorldEvent.java | 17 ++ src/appeng/api/events/GridErrorEvent.java | 18 ++ .../api/events/GridPatternUpdateEvent.java | 22 ++ .../api/events/GridStorageUpdateEvent.java | 22 ++ .../api/events/GridTileConnectivityEvent.java | 22 ++ src/appeng/api/events/GridTileLoadEvent.java | 22 ++ .../api/events/GridTileUnloadEvent.java | 22 ++ .../api/events/LocateableEventAnnounce.java | 25 ++ .../api/events/MultiBlockUpdateEvent.java | 22 ++ .../api/exceptions/AppEngException.java | 12 + .../AppEngTileMissingException.java | 30 +++ .../api/me/items/IAEChargeableItem.java | 25 ++ src/appeng/api/me/items/IAEWrench.java | 9 + .../api/me/items/IAssemblerPatternItem.java | 8 + .../api/me/items/ILocationPatternItem.java | 7 + src/appeng/api/me/items/IMEPatternItem.java | 9 + src/appeng/api/me/items/IMemoryCard.java | 40 +++ src/appeng/api/me/items/IStorageCell.java | 48 ++++ .../api/me/items/IStorageComponent.java | 21 ++ src/appeng/api/me/tiles/IAssemblerMB.java | 20 ++ .../me/tiles/IAssemblerPatternProvider.java | 11 + src/appeng/api/me/tiles/ICellContainer.java | 24 ++ src/appeng/api/me/tiles/ICellProvider.java | 23 ++ src/appeng/api/me/tiles/IColoredMETile.java | 36 +++ .../api/me/tiles/IConfigureableTile.java | 28 +++ .../api/me/tiles/IConnectionSensitive.java | 11 + .../api/me/tiles/IDirectionalMETile.java | 20 ++ .../api/me/tiles/IExtendedCellProvider.java | 13 + .../api/me/tiles/IFulllyOptionalMETile.java | 11 + src/appeng/api/me/tiles/IGridMachine.java | 13 + src/appeng/api/me/tiles/IGridTeleport.java | 11 + src/appeng/api/me/tiles/IGridTileEntity.java | 49 ++++ src/appeng/api/me/tiles/ILocateable.java | 10 + src/appeng/api/me/tiles/IMEPowerStorage.java | 34 +++ src/appeng/api/me/tiles/INonSignalBlock.java | 9 + src/appeng/api/me/tiles/IOptionalMETile.java | 14 ++ src/appeng/api/me/tiles/IOrientableTile.java | 26 ++ src/appeng/api/me/tiles/IPriorityTile.java | 17 ++ src/appeng/api/me/tiles/IPushable.java | 30 +++ src/appeng/api/me/tiles/IStorageAware.java | 13 + src/appeng/api/me/tiles/IStorageMonitor.java | 20 ++ src/appeng/api/me/tiles/ITileCable.java | 7 + src/appeng/api/me/tiles/ITileIOCable.java | 30 +++ .../api/me/tiles/ITileInterfaceApi.java | 78 ++++++ .../me/tiles/InterfaceCraftingPattern.java | 19 ++ src/appeng/api/me/util/Grid.java | 84 +++++++ src/appeng/api/me/util/IAssemblerCluster.java | 37 +++ src/appeng/api/me/util/IAssemblerPattern.java | 78 ++++++ src/appeng/api/me/util/IConfigManager.java | 10 + src/appeng/api/me/util/ICraftRequest.java | 9 + src/appeng/api/me/util/ICraftWatcher.java | 12 + src/appeng/api/me/util/IGridCache.java | 46 ++++ src/appeng/api/me/util/IGridInterface.java | 219 +++++++++++++++++ src/appeng/api/me/util/ILocationPattern.java | 12 + src/appeng/api/me/util/IMEInventory.java | 77 ++++++ .../api/me/util/IMEInventoryHandler.java | 76 ++++++ src/appeng/api/me/util/IMEInventoryUtil.java | 19 ++ .../me/util/InterfaceCraftingResponse.java | 13 + src/tconstruct/library/tools/ToolCore.java | 13 +- 107 files changed, 3560 insertions(+), 5 deletions(-) create mode 100644 src/appeng/api/Blocks.java create mode 100644 src/appeng/api/DimentionalCoord.java create mode 100644 src/appeng/api/IAEItemStack.java create mode 100644 src/appeng/api/IAETagCompound.java create mode 100644 src/appeng/api/IAppEngApi.java create mode 100644 src/appeng/api/IAppEngGrinderRecipe.java create mode 100644 src/appeng/api/ICellHandler.java create mode 100644 src/appeng/api/ICellRegistry.java create mode 100644 src/appeng/api/IExternalStorageHandler.java create mode 100644 src/appeng/api/IExternalStorageRegistry.java create mode 100644 src/appeng/api/IGridCacheRegistry.java create mode 100644 src/appeng/api/IGrinderRecipeManager.java create mode 100644 src/appeng/api/IItemComparisionProvider.java create mode 100644 src/appeng/api/IItemComparison.java create mode 100644 src/appeng/api/IItemList.java create mode 100644 src/appeng/api/ILocateableRegistry.java create mode 100644 src/appeng/api/ISpecialComparisonRegistry.java create mode 100644 src/appeng/api/IWirelessTermHandler.java create mode 100644 src/appeng/api/IWirelessTermRegistery.java create mode 100644 src/appeng/api/Items.java create mode 100644 src/appeng/api/Materials.java create mode 100644 src/appeng/api/README.txt create mode 100644 src/appeng/api/TileRef.java create mode 100644 src/appeng/api/Util.java create mode 100644 src/appeng/api/WorldCoord.java create mode 100644 src/appeng/api/config/ActionItems.java create mode 100644 src/appeng/api/config/CondenserOuput.java create mode 100644 src/appeng/api/config/EnableDisable.java create mode 100644 src/appeng/api/config/FullnessMode.java create mode 100644 src/appeng/api/config/FuzzyMode.java create mode 100644 src/appeng/api/config/IConfigEnum.java create mode 100644 src/appeng/api/config/InterfaceBlockingMode.java create mode 100644 src/appeng/api/config/InterfaceCraftingMode.java create mode 100644 src/appeng/api/config/ItemFlow.java create mode 100644 src/appeng/api/config/ListMode.java create mode 100644 src/appeng/api/config/MatchingMode.java create mode 100644 src/appeng/api/config/OperationMode.java create mode 100644 src/appeng/api/config/PowerUnits.java create mode 100644 src/appeng/api/config/RedstoneModeInput.java create mode 100644 src/appeng/api/config/RedstoneModeInputOnOff.java create mode 100644 src/appeng/api/config/RedstoneModeOutput.java create mode 100644 src/appeng/api/config/SearchBoxMode.java create mode 100644 src/appeng/api/config/SortDir.java create mode 100644 src/appeng/api/config/SortOrder.java create mode 100644 src/appeng/api/config/StackModeInput.java create mode 100644 src/appeng/api/config/StackModeOutput.java create mode 100644 src/appeng/api/config/TransferDir.java create mode 100644 src/appeng/api/config/ViewItems.java create mode 100644 src/appeng/api/events/AEWorldEvent.java create mode 100644 src/appeng/api/events/GridErrorEvent.java create mode 100644 src/appeng/api/events/GridPatternUpdateEvent.java create mode 100644 src/appeng/api/events/GridStorageUpdateEvent.java create mode 100644 src/appeng/api/events/GridTileConnectivityEvent.java create mode 100644 src/appeng/api/events/GridTileLoadEvent.java create mode 100644 src/appeng/api/events/GridTileUnloadEvent.java create mode 100644 src/appeng/api/events/LocateableEventAnnounce.java create mode 100644 src/appeng/api/events/MultiBlockUpdateEvent.java create mode 100644 src/appeng/api/exceptions/AppEngException.java create mode 100644 src/appeng/api/exceptions/AppEngTileMissingException.java create mode 100644 src/appeng/api/me/items/IAEChargeableItem.java create mode 100644 src/appeng/api/me/items/IAEWrench.java create mode 100644 src/appeng/api/me/items/IAssemblerPatternItem.java create mode 100644 src/appeng/api/me/items/ILocationPatternItem.java create mode 100644 src/appeng/api/me/items/IMEPatternItem.java create mode 100644 src/appeng/api/me/items/IMemoryCard.java create mode 100644 src/appeng/api/me/items/IStorageCell.java create mode 100644 src/appeng/api/me/items/IStorageComponent.java create mode 100644 src/appeng/api/me/tiles/IAssemblerMB.java create mode 100644 src/appeng/api/me/tiles/IAssemblerPatternProvider.java create mode 100644 src/appeng/api/me/tiles/ICellContainer.java create mode 100644 src/appeng/api/me/tiles/ICellProvider.java create mode 100644 src/appeng/api/me/tiles/IColoredMETile.java create mode 100644 src/appeng/api/me/tiles/IConfigureableTile.java create mode 100644 src/appeng/api/me/tiles/IConnectionSensitive.java create mode 100644 src/appeng/api/me/tiles/IDirectionalMETile.java create mode 100644 src/appeng/api/me/tiles/IExtendedCellProvider.java create mode 100644 src/appeng/api/me/tiles/IFulllyOptionalMETile.java create mode 100644 src/appeng/api/me/tiles/IGridMachine.java create mode 100644 src/appeng/api/me/tiles/IGridTeleport.java create mode 100644 src/appeng/api/me/tiles/IGridTileEntity.java create mode 100644 src/appeng/api/me/tiles/ILocateable.java create mode 100644 src/appeng/api/me/tiles/IMEPowerStorage.java create mode 100644 src/appeng/api/me/tiles/INonSignalBlock.java create mode 100644 src/appeng/api/me/tiles/IOptionalMETile.java create mode 100644 src/appeng/api/me/tiles/IOrientableTile.java create mode 100644 src/appeng/api/me/tiles/IPriorityTile.java create mode 100644 src/appeng/api/me/tiles/IPushable.java create mode 100644 src/appeng/api/me/tiles/IStorageAware.java create mode 100644 src/appeng/api/me/tiles/IStorageMonitor.java create mode 100644 src/appeng/api/me/tiles/ITileCable.java create mode 100644 src/appeng/api/me/tiles/ITileIOCable.java create mode 100644 src/appeng/api/me/tiles/ITileInterfaceApi.java create mode 100644 src/appeng/api/me/tiles/InterfaceCraftingPattern.java create mode 100644 src/appeng/api/me/util/Grid.java create mode 100644 src/appeng/api/me/util/IAssemblerCluster.java create mode 100644 src/appeng/api/me/util/IAssemblerPattern.java create mode 100644 src/appeng/api/me/util/IConfigManager.java create mode 100644 src/appeng/api/me/util/ICraftRequest.java create mode 100644 src/appeng/api/me/util/ICraftWatcher.java create mode 100644 src/appeng/api/me/util/IGridCache.java create mode 100644 src/appeng/api/me/util/IGridInterface.java create mode 100644 src/appeng/api/me/util/ILocationPattern.java create mode 100644 src/appeng/api/me/util/IMEInventory.java create mode 100644 src/appeng/api/me/util/IMEInventoryHandler.java create mode 100644 src/appeng/api/me/util/IMEInventoryUtil.java create mode 100644 src/appeng/api/me/util/InterfaceCraftingResponse.java diff --git a/src/appeng/api/Blocks.java b/src/appeng/api/Blocks.java new file mode 100644 index 00000000..50ab002b --- /dev/null +++ b/src/appeng/api/Blocks.java @@ -0,0 +1,67 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; + +/** + * Blocks, all of the Blocks in AE. + * DO NOT USE THESE WITHOUT COPYING THEM : ItemStack.copy() - is your friend. + */ + +public class Blocks +{ + // World Gen + public static ItemStack blkQuartzOre; + public static ItemStack blkQuartz; + + // Tech 1 ( non-ME ) + public static ItemStack blkGrinder; + + // Tech 4? ( ME Storage ) + public static ItemStack blkCable_Colored[]; + + public static ItemStack blkAssembler; + public static ItemStack blkController; + public static ItemStack blkDrive; + public static ItemStack blkPatternEncoder; + public static ItemStack blkWireless; + public static ItemStack blkTerminal; + public static ItemStack blkChest; + public static ItemStack blkInterface; + public static ItemStack blkPartitioner; + public static ItemStack blkCraftingTerminal; + public static ItemStack blkStorageBus; + + public static ItemStack blkAssemblerFieldWall; + public static ItemStack blkHeatVent; + public static ItemStack blkCraftingAccelerator; + + public static ItemStack blkInputCablePrecision; + public static ItemStack blkInputCableFuzzy; + public static ItemStack blkInputCableBasic; + + public static ItemStack blkOutputCablePrecision; + public static ItemStack blkOutputCableFuzzy; + public static ItemStack blkOutputCableBasic; + public static ItemStack blkStorageBusFuzzy; + + public static ItemStack blkLevelEmitter; + public static ItemStack blkDarkCable; + public static ItemStack blkIOPort; + public static ItemStack blkCraftingMonitor; + public static ItemStack blkStorageMonitor; + public static ItemStack blkColorlessCable; + public static ItemStack blkColorlessCableCovered; + + public static ItemStack blkTransitionPlane; + public static ItemStack blkCondenser; + public static ItemStack blkEnergyCell; + public static ItemStack blkPowerRelay; + public static ItemStack blkQuantumRing; + public static ItemStack blkQuantumLink; + public static ItemStack blkQuartzGlass; + public static ItemStack blkQuartzLamp; + + // Used internally, best not to mess with this one... + public static ItemStack blkPhantom; + +} diff --git a/src/appeng/api/DimentionalCoord.java b/src/appeng/api/DimentionalCoord.java new file mode 100644 index 00000000..acf17c2b --- /dev/null +++ b/src/appeng/api/DimentionalCoord.java @@ -0,0 +1,58 @@ +package appeng.api; + +import net.minecraft.world.World; + +public class DimentionalCoord extends WorldCoord +{ + private World w; + private int dimId; + + public DimentionalCoord( DimentionalCoord s ) + { + super( s.x, s.y, s.z ); + w = s.w; + dimId = s.dimId; + } + + public DimentionalCoord( World _w, int _x, int _y, int _z ) + { + super(_x, _y, _z); + w = _w; + dimId = _w.provider.dimensionId; + } + + @Override + public DimentionalCoord copy() + { + return new DimentionalCoord( this ); + } + + public boolean isEqual( DimentionalCoord c ) + { + return x == c.x && y == c.y && z == c.z && c.w == this.w; + } + + @Override + public boolean equals(Object obj) + { + if ( obj instanceof DimentionalCoord ) + return isEqual( (DimentionalCoord)obj ); + return false; + } + + @Override + public int hashCode() + { + return super.hashCode() ^ dimId; + } + + public boolean isInWorld(World world) + { + return w == world; + } + + public World getWorld() + { + return w; + } +} diff --git a/src/appeng/api/IAEItemStack.java b/src/appeng/api/IAEItemStack.java new file mode 100644 index 00000000..4b55ab5e --- /dev/null +++ b/src/appeng/api/IAEItemStack.java @@ -0,0 +1,175 @@ +package appeng.api; + +import java.io.DataOutputStream; +import java.io.IOException; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +/** + * An alternate version of ItemStack for AE to keep tabs on things easier, and to support larger storage. + * stackSizes of getItemStack will be capped. + * + * You may hold on to these if you want, just make sure you let go of them when your not using them. + * + * Don't Implement. + * + * Construct with Util.createItemStack( ItemStack ) + * + */ +public interface IAEItemStack +{ + /** + * seriously? + * @return the item id of the requested item. + */ + public int getItemID(); + + /** + * the item's damage. + * @return + */ + public int getItemDamage(); + + /** + * obtain the NBT Data for the item. + * @return + */ + public IAETagCompound getTagCompound(); + + /** + * creates a standard MC ItemStack for the item. + * @return new itemstack + */ + public ItemStack getItemStack(); + + /** + * create a AE Item clone. + * @return the copy. + */ + public IAEItemStack copy(); + + /** + * number of items in the stack. + * @return basically ItemStack.stackSize + */ + public long getStackSize(); + + /** + * changes the number of items in the stack. + * @param basically, ItemStack.stackSize = N + */ + public void setStackSize( long stackSize ); + + /** + * Same as getStackSize, but for requestable items. ( LP ) + * @return basically itemStack.stackSize but for requestable items. + */ + long getCountRequestable(); + + /** + * Same as setStackSize, but for requestable items. ( LP ) + * @return basically itemStack.stackSize = N but for setStackSize items. + */ + void setCountRequestable(long countRequestable); + + /** + * true, if the item can be crafted. + * @return true, if it can be crafted. + */ + boolean isCraftable(); + + /** + * change weather the item can be crafted. + * @param isCraftable + */ + void setCraftable(boolean isCraftable); + + /** + * basically itemid and damage in one number.. + * @return + */ + int getDef(); + + /** + * clears, requsetable, craftable, and stack sizes. + */ + public void reset(); + + /** + * returns true, if the item can be crafted, requested, or extracted. + * @return isThisRecordMeaningful + */ + boolean isMeaninful(); + + /** + * is there NBT Data for this item? + * @return if there is. + */ + boolean hasTagCompound(); + + /** + * Combines two IAEItemStacks via addition. + * @param option, to add to the current one. + */ + void add(IAEItemStack option); + + /** + * Adds more to the stack size... + * @param i + */ + void incStackSize(long i); + + /** + * removes some from the stack size. + */ + void decStackSize(long i); + + /** + * adds items to the requestable + * @param i + */ + void incCountRequestable(long i); + + /** + * removes items from the requsetable + * @param i + */ + void decCountRequestable(long i); + + /** + * quick way to get access to the MC Item Definition. + * @return + */ + Item getItem(); + + /** + * write to a NBTTagCompound. + * @param i + */ + void writeToNBT(NBTTagCompound i); + + /** + * Compare a IAEItemStack to another AEItemStack or a ItemStack. + * @param obj + * @return true if they are the same. + */ + @Override + public boolean equals(Object obj); + + /** + * Compare the Ore Dictionary ID for this to another item. + * @param oreID + * @return + */ + public boolean sameOre( Object oreID ); + + /** + * Slower for disk saving, but smaller/more efficient for packets. + * @param data + * @throws IOException + */ + public void writeToPacket(DataOutputStream data) throws IOException; + +} diff --git a/src/appeng/api/IAETagCompound.java b/src/appeng/api/IAETagCompound.java new file mode 100644 index 00000000..c7c48c7c --- /dev/null +++ b/src/appeng/api/IAETagCompound.java @@ -0,0 +1,33 @@ +package appeng.api; + +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; + +/** + * Don't cast this... either compare with it, or copy it. + * + * Don't Implement. + */ +public interface IAETagCompound { + + /** + * Create a copy ( the copy will not be a IAETagCompount, it will be a NBTTagCompound. ) + * @return + */ + NBTTagCompound clone(); + + /** + * compare to other NBTTagCompounds or IAETagCompounds + * @param a + * @return true, if they are the same. + */ + @Override + boolean equals( Object a ); + + /** + * returns the special comparison for this tag. + * @return + */ + IItemComparison getSpecialComparison(); + +} diff --git a/src/appeng/api/IAppEngApi.java b/src/appeng/api/IAppEngApi.java new file mode 100644 index 00000000..b65d2659 --- /dev/null +++ b/src/appeng/api/IAppEngApi.java @@ -0,0 +1,161 @@ +package appeng.api; + +import appeng.api.me.items.IMemoryCard; +import appeng.api.me.tiles.IColoredMETile; +import appeng.api.me.util.IAssemblerPattern; +import appeng.api.me.util.IMEInventory; +import appeng.api.me.util.IMEInventoryUtil; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.world.World; + +public interface IAppEngApi { + + /** + * Attempts to paint the block at the specified coords, the specified color, colors are based off of IColoredMETile.Colors + * @param world + * @param x + * @param y + * @param z + * @param color + * @return if the block was painted, or not you can use this to damage your item if you want. + */ + boolean paintBlock(World world, int x, int y, int z, int color); + + /** + * Add new Grid Caches for use during run time, only use during loading phase. + * @return + */ + IGridCacheRegistry getGridCacheRegistry(); + + /** + * Add additional storage bus handlers to improve interplay with mod blocks that contains special inventories that function unlike vanilla chests. + * AE uses this internally for barrels, dsu's, quantum chests, AE Networks and more. * + * @return IExternalStorageRegistry + */ + IExternalStorageRegistry getExternalStorageRegistry(); + + /** + * Add additional special comparison functionality, AE Uses this internally for Bees. + * @return ISpecialComparisonRegistry + */ + ISpecialComparisonRegistry getSpecialComparsonRegistry(); + + /** + * gives you access to extractItemsByRecipe, other then this theres not much use for this. + * @param mei + * @return + */ + IMEInventoryUtil getIMEInventoryUtil(IMEInventory mei); + + /** + * Lets you register your items as wireless terminals + * @return + */ + IWirelessTermRegistery getWirelessRegistry(); + + /** + * return an locateable object by its serial + * used internally by AE for QNBs / Network Controllers + * @param serial + * @return + */ + Object getLocateableBySerial(Long serial); + + /** + * creates a new instance of IAEItemStack from a MC ItemStack + * @param is + * @return + */ + IAEItemStack createItemStack(ItemStack is); + + /** + * Creates a new instance of IItemList + * @return + */ + IItemList createItemList(); + + /** + * Allows you to register new cell types, these will function in drives + * @return + */ + ICellRegistry getCellRegistry(); + + /** + * Manage grinder recipes via API + * @return + */ + IGrinderRecipeManager getGrinderRecipeManage(); + + /** + * get access to the locatable registry + * @return + */ + ILocateableRegistry getLocateableRegistry(); + + /** + * a simple wrapper around the AEItemStack version on IMEInventory + * @param inv + * @param is + * @return + */ + ItemStack addItemsToInv(IMEInventory inv, ItemStack is); + + /** + * a simple wrapper around the AEItemStack version on IMEInventory + * @param inv + * @param is + * @return + */ + ItemStack extractItems(IMEInventory inv, ItemStack is); + + /** + * Blacklist this item from vanilla AE Terminals / IStorageCell + * @param itemID + * @param meta - if you use OreDictionary.WILDCARD_VALUE it will blacklist the entire itemID. + */ + void addBasicBlackList(int itemID, int meta); + + /** + * Acquire the inventory for a IStorageCell + * @param i + * @return + */ + IMEInventory getBasicCell(ItemStack i); + + /** + * checks if the item is a basic storage cell. + * @param i + * @return + */ + Boolean isBasicCell(ItemStack i); + + /** + * gives you access to assembler pattern inventories. + * @param i + * @return + */ + IAssemblerPattern getAssemblerPattern(ItemStack i); + + /** + * allows you to check if an item is an assembler pattern. + * @param i + * @return + */ + Boolean isAssemblerPattern(ItemStack i); + + /** + * allows you to check if a pattern is blank. + * @param i + * @return + */ + Boolean isBlankPattern(ItemStack i); + + /** + * gives you the ability to interface with AE Memory Cards. + * @return + */ + IMemoryCard getMemoryCardHandler(); + +} diff --git a/src/appeng/api/IAppEngGrinderRecipe.java b/src/appeng/api/IAppEngGrinderRecipe.java new file mode 100644 index 00000000..b8a3f058 --- /dev/null +++ b/src/appeng/api/IAppEngGrinderRecipe.java @@ -0,0 +1,45 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; + +/** + * Lets you manipulate existing recipes. + */ +public interface IAppEngGrinderRecipe { + + /** + * the current input + * @return input that the grinder will accept. + */ + public ItemStack getInput(); + + /** + * lets you change the grinder recipe by changing its input. + * @param input + */ + public void setInput( ItemStack input ); + + /** + * gets the current output + * @return output that the grinder will produce + */ + public ItemStack getOutput(); + + /** + * allows you to change the output. + * @param output + */ + public void setOutput( ItemStack output ); + + /** + * Energy cost, in turns. + * @return number of turns it takes to produce the output from the input. + */ + public int getEnergyCost(); + + /** + * Allows you to adjust the number of turns + * @param new number of turns to produce output. + */ + public void setEnergyCost(int c); +} diff --git a/src/appeng/api/ICellHandler.java b/src/appeng/api/ICellHandler.java new file mode 100644 index 00000000..e0070b1e --- /dev/null +++ b/src/appeng/api/ICellHandler.java @@ -0,0 +1,25 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; +import appeng.api.me.util.IMEInventoryHandler; + +/** + * Registratio record for a Custom Cell handler. + */ +public interface ICellHandler { + + /** + * return true if the provided item is handled by your cell handler. ( AE May choose to skip this method, and just request a handler ) + * @param is + * @return return true, if getCellHandler will not return null. + */ + boolean isCell( ItemStack is ); + + /** + * return a new IMEHandler for the provided item. + * @param is + * @return if you cannot handle the provided item, return null. + */ + IMEInventoryHandler getCellHandler( ItemStack is ); + +} diff --git a/src/appeng/api/ICellRegistry.java b/src/appeng/api/ICellRegistry.java new file mode 100644 index 00000000..2e609301 --- /dev/null +++ b/src/appeng/api/ICellRegistry.java @@ -0,0 +1,31 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; +import appeng.api.me.util.IMEInventoryHandler; + +/** + * Storage Cell Registry, used for specially implemented cells, if you just want to make a item act like a cell, or new cell with diffrent bytes, then you should probobly consider IStorageCell instead its consideriablly simpler. + */ +public interface ICellRegistry { + + /** + * Register a new handler. + * @param h + */ + void addCellHandler( ICellHandler h ); + + /** + * returns true if the provided item, can be handled by a handler in AE, ( AE May choose to skip this and just get the handler instead. ) + * @param is + * @return returns true, if you can get a InventoryHandler for the item passed. + */ + boolean isCellHandled( ItemStack is ); + + /** + * returns an IMEInventoryHandler for the provided item. + * @param is + * @return new IMEInventoryHandler, or null if there isn't one. + */ + IMEInventoryHandler getHandlerForCell( ItemStack is ); + +} diff --git a/src/appeng/api/IExternalStorageHandler.java b/src/appeng/api/IExternalStorageHandler.java new file mode 100644 index 00000000..be14dcc6 --- /dev/null +++ b/src/appeng/api/IExternalStorageHandler.java @@ -0,0 +1,27 @@ +package appeng.api; + +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.ForgeDirection; +import appeng.api.me.util.IMEInventory; + +/** + * A Registration for a special storage handler. + * + */ +public interface IExternalStorageHandler { + + /** + * if this can handle the provided inventory, return true. ( Generally skipped by AE, and it just calls getInventory ) + * @param te + * @return true, if it can get a handler via getInventory + */ + boolean canHandle( TileEntity te, ForgeDirection d ); + + /** + * if this can handle the given inventory, return the a IMEInventory implemnting class for it, if not return null + * @param te + * @return HandlerFor Inventory. + */ + IMEInventory getInventory( TileEntity te, ForgeDirection d ); + +} diff --git a/src/appeng/api/IExternalStorageRegistry.java b/src/appeng/api/IExternalStorageRegistry.java new file mode 100644 index 00000000..0f4c6352 --- /dev/null +++ b/src/appeng/api/IExternalStorageRegistry.java @@ -0,0 +1,22 @@ +package appeng.api; + +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.ForgeDirection; + +public interface IExternalStorageRegistry { + + /** + * A registry for StorageBus interactions + * @param ei + */ + void addExternalStorageInterface( IExternalStorageHandler ei ); + + /** + * returns the handler for a given tile / forge direction. + * @param te + * @param opposite + * @return + */ + IExternalStorageHandler getHandler(TileEntity te, ForgeDirection opposite); + +} diff --git a/src/appeng/api/IGridCacheRegistry.java b/src/appeng/api/IGridCacheRegistry.java new file mode 100644 index 00000000..13e188f5 --- /dev/null +++ b/src/appeng/api/IGridCacheRegistry.java @@ -0,0 +1,24 @@ +package appeng.api; + +import appeng.api.me.util.IGridCache; + +/** + * A registry of grid caches to extend grid functionality. + */ +public interface IGridCacheRegistry { + + /** + * Register a new grid cache for use during operation, must be called during the loading phase. + * @param cl + * @return cache id ( can be used later to ask the grid for you cache. ) + */ + int registerGridCache( Class cl ); + + /** + * requests a new instance of a grid cache for use, used internally + * @param id + * @return + */ + IGridCache[] createCacheInstance(); + +} diff --git a/src/appeng/api/IGrinderRecipeManager.java b/src/appeng/api/IGrinderRecipeManager.java new file mode 100644 index 00000000..16b60830 --- /dev/null +++ b/src/appeng/api/IGrinderRecipeManager.java @@ -0,0 +1,32 @@ +package appeng.api; + +import java.util.List; + +import net.minecraft.item.ItemStack; + +/** + * Lets you manipulate Grinder Recipes, by adding or editing existing ones. + */ +public interface IGrinderRecipeManager { + + /** + * Current list of registered recipes, you can modify this if you want too. + * @return currentlyRegistredRecipes + */ + public List getRecipes(); + + /** + * add a new recipe the easy way, in -> out, how many turns. + * @param in + * @param out + * @param cost + */ + public void addRecipe( ItemStack in, ItemStack out, int cost ); + + /** + * Searches for a recipe for a given input, and returns it. + * @param input + * @return identified recipe, or null + */ + public IAppEngGrinderRecipe getRecipeForInput(ItemStack input); +} diff --git a/src/appeng/api/IItemComparisionProvider.java b/src/appeng/api/IItemComparisionProvider.java new file mode 100644 index 00000000..b93194e0 --- /dev/null +++ b/src/appeng/api/IItemComparisionProvider.java @@ -0,0 +1,25 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; + +/** + * Provider for special comparisons. + * when an item is encountered AE Will request if the comparison function handles the item, by trying to request a IItemComparison class. + */ +public interface IItemComparisionProvider { + + /** + * should return a new IItemComparison, or return null if it dosn't handle the supplied item. + * @param is + * @return IItemComparison, or null + */ + IItemComparison getComparison( ItemStack is ); + + /** + * Simple test for support ( AE generally skips this and calls the above function. ) + * @param stack + * @return true, if getComparison will return a valid IItemComparison Object. + */ + public boolean canHandle( ItemStack stack); + +} diff --git a/src/appeng/api/IItemComparison.java b/src/appeng/api/IItemComparison.java new file mode 100644 index 00000000..4bfc35f9 --- /dev/null +++ b/src/appeng/api/IItemComparison.java @@ -0,0 +1,10 @@ +package appeng.api; + + +public interface IItemComparison { + + public boolean sameAsPrecise( IItemComparison comp); + + public boolean sameAsFuzzy(IItemComparison comp); + +} diff --git a/src/appeng/api/IItemList.java b/src/appeng/api/IItemList.java new file mode 100644 index 00000000..9f722000 --- /dev/null +++ b/src/appeng/api/IItemList.java @@ -0,0 +1,32 @@ +package appeng.api; + +import java.util.Iterator; +import java.util.List; + +import net.minecraft.item.ItemStack; + +/** + * Represents a list of items in AE. + * + * Don't Implement. + * + * Construct with Util.createItemList() + * + */ +public interface IItemList extends Iterable +{ + public void addStorage( IAEItemStack option ); // adds a stack as stored. + public void addCrafting( IAEItemStack option ); // adds a stack as craftable. + public void addRequestable( IAEItemStack option ); // adds a stack as requestable. + public void add( IAEItemStack option ); // adds stack as is. + + IAEItemStack getFirstItem(); + + public List getItems(); + IAEItemStack findItem(IAEItemStack i); + int size(); + + @Override + public Iterator iterator(); + public void setCurrentPriority(int priority); +} diff --git a/src/appeng/api/ILocateableRegistry.java b/src/appeng/api/ILocateableRegistry.java new file mode 100644 index 00000000..8e75cbef --- /dev/null +++ b/src/appeng/api/ILocateableRegistry.java @@ -0,0 +1,15 @@ +package appeng.api; + +/** + * A Registry for locatable items, works based on serial numbers. + */ +public interface ILocateableRegistry { + + /** + * Attempts to find the object with the serial specifed, if it can it returns the object. + * @param ser + * @return requestedObject, or null + */ + public abstract Object findLocateableBySerial(long ser); + +} \ No newline at end of file diff --git a/src/appeng/api/ISpecialComparisonRegistry.java b/src/appeng/api/ISpecialComparisonRegistry.java new file mode 100644 index 00000000..0a30baec --- /dev/null +++ b/src/appeng/api/ISpecialComparisonRegistry.java @@ -0,0 +1,24 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; + +/** + * A Registry of any special comparison handlers for AE To use. + * + */ +public interface ISpecialComparisonRegistry { + + /** + * returns a handler it found for a specific item. + * @param stack + * @return TheHandler or null + */ + IItemComparison getSpecialComparion( ItemStack stack ); + + /** + * Register a new cpecial comparison function with AE. + * @param prov + */ + public void addComparisonProvider( IItemComparisionProvider prov ); + +} diff --git a/src/appeng/api/IWirelessTermHandler.java b/src/appeng/api/IWirelessTermHandler.java new file mode 100644 index 00000000..c38c7ee0 --- /dev/null +++ b/src/appeng/api/IWirelessTermHandler.java @@ -0,0 +1,49 @@ +package appeng.api; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import cpw.mods.fml.common.network.Player; + +/** + * A handler for a wireless terminal. + */ +public interface IWirelessTermHandler { + + /** + * return true, if usePower, hasPower, ect... can be called for the provided item. + * @param is + * @return + */ + boolean canHandle( ItemStack is ); + + /** + * use an amount of power, in AE units + * @param amount is in AE units ( 5 per MJ ), if you return false, the item should be dead and return false for hasPower + * @param is + * @return + */ + boolean usePower( Player player, float amount, ItemStack is ); + + /** + * gets the power status of the item. + * @param is + * @return returns true if there is any power left. + */ + boolean hasPower( Player player, ItemStack is ); + + /** + * Used to get the current key from the item. + * @param player + * @param item + * @return + */ + String getEncryptionKey( ItemStack item ); + + /** + * Encode the wireless frequency via the Controller. + * @param item - the wireless terminal. + * @param encKey - the wireless encryption key. + * @param name - null for now. + */ + void setEncryptionKey( ItemStack item, String encKey, String name ); +} diff --git a/src/appeng/api/IWirelessTermRegistery.java b/src/appeng/api/IWirelessTermRegistery.java new file mode 100644 index 00000000..b9b0a483 --- /dev/null +++ b/src/appeng/api/IWirelessTermRegistery.java @@ -0,0 +1,38 @@ +package appeng.api; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import appeng.api.me.util.IMEInventoryHandler; + +/** + * Registratio record for a Custom Cell handler. + */ +public interface IWirelessTermRegistery { + + /** + * add thsi handler to the list of other wireless handler. + * @param handler + */ + void registerWirelessHandler( IWirelessTermHandler handler ); + + /** + * returns true if theres a handler for this item. + * @param is + * @return + */ + boolean isWirelessTerminal( ItemStack is ); + + /** + * returns a register handler for the item in question, or null if there isn't one. + * @param is + * @return + */ + IWirelessTermHandler getWirelessTerminalHandler( ItemStack is ); + + /** + * opens the wireless terminal gui, the wireless terminal item, must be in the active slot on the tool bar. + */ + void OpenWirelessTermainlGui( ItemStack item, World w, EntityPlayer player ); + +} diff --git a/src/appeng/api/Items.java b/src/appeng/api/Items.java new file mode 100644 index 00000000..0c75f82a --- /dev/null +++ b/src/appeng/api/Items.java @@ -0,0 +1,36 @@ +package appeng.api; + +import net.minecraft.item.ItemStack; + +/** + * Items that have data, actions, or other interesting properties... + * DO NOT USE THESE WITHOUT COPYING THEM : ItemStack.copy() - is your friend. + */ +public class Items +{ + public static ItemStack toolQuartzAxe; + public static ItemStack toolQuartzHoe; + public static ItemStack toolQuartzShovel; + public static ItemStack toolQuartzPick; + public static ItemStack toolQuartzSword; + public static ItemStack toolQuartzWrench; + + public static ItemStack toolEntropyAccelerator; + public static ItemStack toolVibrationCatalyst; + public static ItemStack toolMassCannon; + + public static ItemStack toolQuartzKnife; + + public static ItemStack itemMemoryCard; + + public static ItemStack itemCell1k; + public static ItemStack itemCell4k; + public static ItemStack itemCell16k; + public static ItemStack itemCell64k; + + public static ItemStack itemEncodedAsemblerPattern; + public static ItemStack toolWirelessTerminal; + + @Deprecated + public static ItemStack itemWirelessTerminal; +} diff --git a/src/appeng/api/Materials.java b/src/appeng/api/Materials.java new file mode 100644 index 00000000..c6d8e90c --- /dev/null +++ b/src/appeng/api/Materials.java @@ -0,0 +1,58 @@ +package appeng.api; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +/** + * Access to stack-able simple items, these include resources... + * Craftable ingredients, and a few simple items that don't have log of their own... + * DO NOT USE THESE WITHOUT COPYING THEM : ItemStack.copy() - is your friend. + */ +public class Materials +{ + // Tech 1 + public static ItemStack matWoodenGear; + public static ItemStack matIronNugget; + public static ItemStack matCrank; + + // Grinder... + public static ItemStack matQuartzDustNether; + public static ItemStack matQuartzDust; + public static ItemStack matIronDust; + public static ItemStack matGoldDust; + public static ItemStack matFlour; + + // Tech 3 + public static ItemStack matSilicon; + public static ItemStack matProcessorBasicUncooked; + public static ItemStack matProcessorAdvancedUncooked; + public static ItemStack matProcessorBasic; + public static ItemStack matProcessorAdvanced; + + // ME Construction... + public static ItemStack matConversionMatrix; + public static ItemStack matStorageCell; + public static ItemStack matStorageBlock; + public static ItemStack matStorageCluster; + public static ItemStack matWireless; + public static ItemStack matStorageCellHouseing; + public static ItemStack matStorageCellHouseingFuzzy; + public static ItemStack matBlankPattern; + public static ItemStack matStorageSegment; + public static ItemStack matFluxDust; + public static ItemStack matFluxCrystal; + public static ItemStack matFluxPearl; + + // World gen... + public static ItemStack matQuartz; + + // Other items, such as upgrades. + public static ItemStack matWirelessBooster; + public static ItemStack matMatterBall; + public static ItemStack matSingularity; + public static ItemStack matEnderPearlDust; + public static ItemStack matQuantumEntangledSingularity; + + // TEST ITEMS! + public static ItemStack testItem; +} diff --git a/src/appeng/api/README.txt b/src/appeng/api/README.txt new file mode 100644 index 00000000..bcd69c4e --- /dev/null +++ b/src/appeng/api/README.txt @@ -0,0 +1,46 @@ +If your considering using the AE API, please take a moment to read though the following. + +Before we begin, + AE's API will change as new features are added to the mod, I try to keep + the changes to a minimum and try to prevent breaking changes, however it will + probably happen at some point, and it can't truly be avoided in some cases. + +The Grid + AE refers to the "ME Network" internally as "The Grid" you will see methods such + as getGrid(), setGrid() commonly, most interaction with networks, and creating new + network blocks will involve the grid. + +Network Enumeration + If your trying to add a new ME Network Block, you must at minimum implement + IGridTileEntity, and post the GridTileLoadEvent, and GridTileUnloadEvent when your + tile is added / removed respectfully, if you fail to do this correctly, your tile, + may ghost in the network, or cause invalid behaviour. You must inform AE that your + tiles is joining and exiting the Network, with these events or you will not get notified + of any network related features. + +Thread Safety + AE is not thread safe, do not attempt to use the API from other threads, this will + result in crashes, and CME exceptions - and will not end well. + +Blocks / Items / Materials + AE Exposes its Original Item stacks via the Blocks, Items, Materials classes for easy access, + don't change these, if you need to use an item make sure you .copy() it and use the copy, if + failing to do so can result in dupe bugs irregular crafting patterns, and other issues. + +AE and ItemStacks / Item Lists + AE's API commonly refers to IAEItemStacks, and IItemLists this are internally implemented + classes in AE, Do not Implement IAEItemstack, or IItemList, use the util methods to + construct new instances them. + +API Conflicts / Inclusion + Refrain from including portions of the API as class files in your mod, unless required + because your implementing an interface, even then its greatly appreciated if you put in + the effort to get around this. + + If you are not sure how to do this and plan on releasing your mod, I will be happy to explain + what steps you can take to improve compatibility, and prevent conflicts no one likes crashes, + and these cause crashes. + +I've been trying to improve the documentation included in the API java files however things can be +confusing or misleading, if you have questions after trying to figure something out I'm usually +available on IRC. \ No newline at end of file diff --git a/src/appeng/api/TileRef.java b/src/appeng/api/TileRef.java new file mode 100644 index 00000000..db6fe3e6 --- /dev/null +++ b/src/appeng/api/TileRef.java @@ -0,0 +1,60 @@ +package appeng.api; + +import net.minecraft.client.Minecraft; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import appeng.api.events.GridTileUnloadEvent; +import appeng.api.exceptions.AppEngTileMissingException; +import appeng.api.me.tiles.IGridTileEntity; + +public class TileRef extends WorldCoord { + + //private int dimension; + private World w; + boolean wasGrid; + + public TileRef( TileEntity gte ) { + super( gte.xCoord, gte.yCoord, gte.zCoord ); + TileEntity te = gte; + wasGrid = te instanceof IGridTileEntity; + w = te.worldObj; + if ( te.worldObj == null ) + throw new RuntimeException("Tile has no world."); + } + + @SuppressWarnings("unchecked") + public T getTile() throws AppEngTileMissingException + { + // there might be a possible tick where we have TileRefs for unloaded tiles? + if ( w.getChunkProvider().chunkExists(x >> 4, z >> 4) ) + { + TileEntity te = w.getBlockTileEntity( x, y, z ); + if ( te != null ) + { + try + { + T ttt = (T) te; // I have no idea if this causes the exception or not... + return ttt; + } + catch( ClassCastException err ) + { + + } + } + } + + /** + * was this a grid tile? if so inform the grid enum that something has derped. + */ + if ( wasGrid ) + MinecraftForge.EVENT_BUS.post( new GridTileUnloadEvent( null, w, this ) ); + + throw new AppEngTileMissingException( w, x,y,z); + } + + public DimentionalCoord getCoord() { + return new DimentionalCoord( w, x, y, z ); + } + +}; diff --git a/src/appeng/api/Util.java b/src/appeng/api/Util.java new file mode 100644 index 00000000..207d339d --- /dev/null +++ b/src/appeng/api/Util.java @@ -0,0 +1,230 @@ +package appeng.api; + +import java.lang.reflect.InvocationTargetException; + +import cpw.mods.fml.relauncher.ReflectionHelper; +import net.minecraft.item.ItemStack; +import appeng.api.me.util.IAssemblerPattern; +import appeng.api.me.util.IMEInventory; +import appeng.api.me.util.IMEInventoryHandler; +import appeng.api.me.util.IMEInventoryUtil; + +/** + * Returns useful stuff of various sorts to access internal features and stuff, the meat of the important stuff is accessed here... + * + * Available IMCs: + * "AppliedEnergistics", "add-grindable", "itemid,meta,itemid,meta,effort" + * "AppliedEnergistics", "blacklist-cell" "itemid[,meta]" + * "AppliedEnergistics", "blacklist-transitionplane" "itemid[,meta]" + * "AppliedEnergistics", "whitelist-transitionplane" "itemid[,meta]" + * + */ +public class Util +{ + static private IAppEngApi api = null; + + /** + * All future API calls should be made via this method. + * @return + */ + public static IAppEngApi getAppEngApi() + { + try { + Class c = ReflectionHelper.getClass( Util.class.getClassLoader(), "appeng.common.AppEngApi" ); + api = (IAppEngApi) c.getMethod( "getInstance" ).invoke( c ); + } catch ( Throwable e) { + return null; + } + return api; + } + + /** + * returns the wireless terminal registry. + * @return + */ + public static IWirelessTermRegistery getWirelessTermRegistery() + { + if ( api == null ) return null; + return api.getWirelessRegistry(); + } + + /** + * Find an object by its serial. + * @param ser + * @return LocatedObject or null + */ + public static Object getLocateableBySerial( long ser ) + { + if ( api == null ) return null; + return api.getLocateableBySerial( ser ); + } + + /** + * Creates a new AEItemstack. + * @param is + * @return newly generated AE Itemstack + */ + public static IAEItemStack createItemStack( ItemStack is ) + { + if ( api == null ) return null; + return api.createItemStack( is ); + } + + /** + * Simple Wrapper of the insertion process.. + * @param inv + * @param is + * @return ItemsNotInserted or null + */ + public static ItemStack addItemsToInv( IMEInventory inv, ItemStack is ) + { + if ( api == null ) return null; + return api.addItemsToInv( inv, is ); + } + + /** + * Simple Wrapper of the extraction process + * @param inv + * @param is + * @return ItemsExtracted or null + */ + public static ItemStack extractItemsFromInv( IMEInventory inv, ItemStack is ) + { + if ( api == null ) return null; + return api.extractItems( inv, is ); + } + + /** + * Create a new Blank ItemList + * @return new itemlist. + */ + public static IItemList createItemList() + { + if ( api == null ) return null; + return api.createItemList(); + } + + /** + * creates a new IMEInventoryUtil, only useful if you want to use the fancy get items by recipe functionaility. + * @param ime + * @return created InvUtil + */ + public static IMEInventoryUtil getIMEInventoryUtil( IMEInventory ime ) + { + if ( api == null ) return null; + return api.getIMEInventoryUtil( ime ); + } + + /** + * Gets the instance of the special comparison registry ( Bees / Trees ) that sort of stuff + * @return specialComparisonRegistry + */ + public static ISpecialComparisonRegistry getSpecialComparisonRegistry() + { + if ( api == null ) return null; + return api.getSpecialComparsonRegistry(); + } + + /** + * Gets the instance of the external storage registry - Storage Bus + * @return externStorgeRegitry + */ + public static IExternalStorageRegistry getExternalStorageRegistry() + { + if ( api == null ) return null; + return api.getExternalStorageRegistry(); + } + + /** + * Gets the instance of the Cell Registry + * @return returns the cell registry + */ + public static ICellRegistry getCellRegistry() + { + if ( api == null ) return null; + return api.getCellRegistry(); + } + + /** + * Gets instance for the grinder recipe manager. + * @return the grinder manager instance. + */ + public static IGrinderRecipeManager getGrinderRecipeManage() + { + if ( api == null ) return null; + return api.getGrinderRecipeManage(); + } + + /** Is it a Blank Pattern? */ + public static Boolean isBlankPattern(ItemStack i) + { + if ( api == null ) return null; + return api.isBlankPattern( i ); + } + + /** Is it an IAssemblerPattern? */ + public static Boolean isAssemblerPattern(ItemStack i) + { + if ( api == null ) return null; + return api.isAssemblerPattern( i ); + } + + /** Gets the IAssemblerPattern of the Assembly Pattern. */ + public static IAssemblerPattern getAssemblerPattern(ItemStack i) + { + if ( api == null ) return null; + return api.getAssemblerPattern( i ); + } + + /** Is it a IStorageCell, this will only return true for IStoreCells and not custom cells, you should probobly not use it unless you have a specific case. */ + public static Boolean isBasicCell(ItemStack i) + { + if ( api == null ) return null; + return api.isBasicCell( i ); + } + + /** + * if the item is a ME Compatible Storage Cell of any type. + * @param i + * @return true, if it is a storage call. + */ + public static Boolean isCell(ItemStack i) + { + if ( api == null ) return null; + return getCellRegistry().isCellHandled( i ); + } + + /** + * Gets the Interface to insert/extract from the Storage Cell for the item. + * @param i + * @return newly procured cell handler. + */ + public static IMEInventoryHandler getCell(ItemStack i) + { + if ( api == null ) return null; + return getCellRegistry().getHandlerForCell( i ); + } + + /** + * Lets you access internal storage of IStorageCell's + * @param i + * @return only works with Basic Cells, not custom ones, suggested not to use. + */ + public static IMEInventory getBasicCell(ItemStack i) + { + if ( api == null ) return null; + return api.getBasicCell( i ); + } + + /** + * Lets you blast list a specific item from being stored in basic cells, this works on any mod cells that use IStorageCell as well. + * @param ItemID + * @param Meta + */ + public static void addBasicBlackList( int ItemID, int Meta ) + { + if ( api == null ) return; + api.addBasicBlackList( ItemID, Meta ); + } + +} diff --git a/src/appeng/api/WorldCoord.java b/src/appeng/api/WorldCoord.java new file mode 100644 index 00000000..4e525647 --- /dev/null +++ b/src/appeng/api/WorldCoord.java @@ -0,0 +1,132 @@ +package appeng.api; + +import net.minecraftforge.common.ForgeDirection; + +/** + * This is used internally to return a location, in a few places, just use as is... + */ +public class WorldCoord +{ + public int x; + public int y; + public int z; + + public WorldCoord add(ForgeDirection direction, int length) + { + x += direction.offsetX * length; + y += direction.offsetY * length; + z += direction.offsetZ * length; + return this; + } + + public WorldCoord subtract(ForgeDirection direction, int length) + { + x -= direction.offsetX * length; + y -= direction.offsetY * length; + z -= direction.offsetZ * length; + return this; + } + + public WorldCoord add(int _x, int _y, int _z) + { + x += _x; + y += _y; + z += _z; + return this; + } + + public WorldCoord subtract(int _x, int _y, int _z) + { + x -= _x; + y -= _y; + z -= _z; + return this; + } + + public WorldCoord multiple(int _x, int _y, int _z) + { + x *= _x; + y *= _y; + z *= _z; + return this; + } + + public WorldCoord divide(int _x, int _y, int _z) + { + x /= _x; + y /= _y; + z /= _z; + return this; + } + + public WorldCoord(int _x, int _y, int _z) + { + x = _x; + y = _y; + z = _z; + } + + /** + * Will Return NULL if it's at some diagonal! + */ + public ForgeDirection DirectionTo(WorldCoord loc) + { + int ox = x - loc.x; + int oy = y - loc.y; + int oz = z - loc.z; + + int xlen = Math.abs( ox ); + int ylen = Math.abs( oy ); + int zlen = Math.abs( oz ); + + if ( loc.isEqual( this.copy().add( ForgeDirection.EAST, xlen ) ) ) + return ForgeDirection.EAST; + + if ( loc.isEqual( this.copy().add( ForgeDirection.WEST, xlen ) ) ) + return ForgeDirection.WEST; + + if ( loc.isEqual( this.copy().add( ForgeDirection.NORTH, zlen ) ) ) + return ForgeDirection.NORTH; + + if ( loc.isEqual( this.copy().add( ForgeDirection.SOUTH, zlen ) ) ) + return ForgeDirection.SOUTH; + + if ( loc.isEqual( this.copy().add( ForgeDirection.UP, ylen ) ) ) + return ForgeDirection.UP; + + if ( loc.isEqual( this.copy().add( ForgeDirection.DOWN, ylen ) ) ) + return ForgeDirection.DOWN; + + return null; + } + + public boolean isEqual( WorldCoord c ) + { + return x == c.x && y == c.y && z == c.z; + } + + public WorldCoord copy() + { + return new WorldCoord( x, y, z ); + } + + @Override + public boolean equals(Object obj) + { + if ( obj instanceof WorldCoord ) + return isEqual( (WorldCoord)obj ); + return false; + } + + @Override + public String toString() + { + return "" + x + "," + y + "," + z; + } + + @Override + public int hashCode() + { + return (y << 24) ^ x ^ z; + } +} diff --git a/src/appeng/api/config/ActionItems.java b/src/appeng/api/config/ActionItems.java new file mode 100644 index 00000000..ff4559de --- /dev/null +++ b/src/appeng/api/config/ActionItems.java @@ -0,0 +1,17 @@ +package appeng.api.config; + + +public enum ActionItems implements IConfigEnum { + Wrench, + Close; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "FuzzyMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/CondenserOuput.java b/src/appeng/api/config/CondenserOuput.java new file mode 100644 index 00000000..2c187dae --- /dev/null +++ b/src/appeng/api/config/CondenserOuput.java @@ -0,0 +1,19 @@ +package appeng.api.config; + + +public enum CondenserOuput implements IConfigEnum { + Trash, + MatterBalls, + Singularity; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "CondenserOutput"; + } + +} \ No newline at end of file diff --git a/src/appeng/api/config/EnableDisable.java b/src/appeng/api/config/EnableDisable.java new file mode 100644 index 00000000..20c195bb --- /dev/null +++ b/src/appeng/api/config/EnableDisable.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +public enum EnableDisable implements IConfigEnum { + Enabled, + Disabled; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "CondenserOutput"; + } + +} \ No newline at end of file diff --git a/src/appeng/api/config/FullnessMode.java b/src/appeng/api/config/FullnessMode.java new file mode 100644 index 00000000..a3f79f4b --- /dev/null +++ b/src/appeng/api/config/FullnessMode.java @@ -0,0 +1,19 @@ +package appeng.api.config; + + +// do not change names.. +public enum FullnessMode implements IConfigEnum { + Empty, + Half, + Full; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "FullnessMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/FuzzyMode.java b/src/appeng/api/config/FuzzyMode.java new file mode 100644 index 00000000..40d57127 --- /dev/null +++ b/src/appeng/api/config/FuzzyMode.java @@ -0,0 +1,27 @@ +package appeng.api.config; + + +public enum FuzzyMode implements IConfigEnum { + IgnoreAll(-1.0F), + Percent_99(1.0F), + Percent_75(0.75F), + Percent_50(0.5F), + Percent_25(0.25F); + + public float breakPoint; + + private FuzzyMode( float p ) + { + breakPoint = p; + } + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "FuzzyMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/IConfigEnum.java b/src/appeng/api/config/IConfigEnum.java new file mode 100644 index 00000000..18bafec7 --- /dev/null +++ b/src/appeng/api/config/IConfigEnum.java @@ -0,0 +1,11 @@ +package appeng.api.config; + +public interface IConfigEnum { + + IConfigEnum[] getValues(); + + int ordinal(); + + String getName(); + +} diff --git a/src/appeng/api/config/InterfaceBlockingMode.java b/src/appeng/api/config/InterfaceBlockingMode.java new file mode 100644 index 00000000..08978d20 --- /dev/null +++ b/src/appeng/api/config/InterfaceBlockingMode.java @@ -0,0 +1,17 @@ +package appeng.api.config; + +public enum InterfaceBlockingMode implements IConfigEnum { + NonBlocking, + Blocking; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "InterfaceBlockingMode"; + } + +} \ No newline at end of file diff --git a/src/appeng/api/config/InterfaceCraftingMode.java b/src/appeng/api/config/InterfaceCraftingMode.java new file mode 100644 index 00000000..ce783b42 --- /dev/null +++ b/src/appeng/api/config/InterfaceCraftingMode.java @@ -0,0 +1,17 @@ +package appeng.api.config; + +public enum InterfaceCraftingMode implements IConfigEnum { + Craft, + DontCraft; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "InterfaceCraftingMode"; + } + +} diff --git a/src/appeng/api/config/ItemFlow.java b/src/appeng/api/config/ItemFlow.java new file mode 100644 index 00000000..b7d60cd6 --- /dev/null +++ b/src/appeng/api/config/ItemFlow.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +public enum ItemFlow implements IConfigEnum { + + READ, WRITE, READ_WRITE; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "ItemFlow"; + } + +} \ No newline at end of file diff --git a/src/appeng/api/config/ListMode.java b/src/appeng/api/config/ListMode.java new file mode 100644 index 00000000..71bf9377 --- /dev/null +++ b/src/appeng/api/config/ListMode.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +public enum ListMode implements IConfigEnum { + + WHITELIST, BLACKLIST; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "ListMode"; + } + +} \ No newline at end of file diff --git a/src/appeng/api/config/MatchingMode.java b/src/appeng/api/config/MatchingMode.java new file mode 100644 index 00000000..8ce433a8 --- /dev/null +++ b/src/appeng/api/config/MatchingMode.java @@ -0,0 +1,17 @@ +package appeng.api.config; + + +public enum MatchingMode implements IConfigEnum { + Fuzzy, + Precision; + + @Override + public IConfigEnum[] getValues() { + return MatchingMode.values(); + } + + @Override + public String getName() { + return "MatchingMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/OperationMode.java b/src/appeng/api/config/OperationMode.java new file mode 100644 index 00000000..6a3f94e1 --- /dev/null +++ b/src/appeng/api/config/OperationMode.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +// do not change names.. +public enum OperationMode implements IConfigEnum { + Fill, + Empty; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "OperationMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/PowerUnits.java b/src/appeng/api/config/PowerUnits.java new file mode 100644 index 00000000..7917050a --- /dev/null +++ b/src/appeng/api/config/PowerUnits.java @@ -0,0 +1,19 @@ +package appeng.api.config; + + +public enum PowerUnits implements IConfigEnum { + AE, + MJ, + EU, + UE; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "PowerUnits"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/RedstoneModeInput.java b/src/appeng/api/config/RedstoneModeInput.java new file mode 100644 index 00000000..edbc51f9 --- /dev/null +++ b/src/appeng/api/config/RedstoneModeInput.java @@ -0,0 +1,20 @@ +package appeng.api.config; + + +// do not change names.. +public enum RedstoneModeInput implements IConfigEnum { + Ignore, + WhenOff, + WhenOn, + OnPulse; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "RedstoneMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/RedstoneModeInputOnOff.java b/src/appeng/api/config/RedstoneModeInputOnOff.java new file mode 100644 index 00000000..e01cad66 --- /dev/null +++ b/src/appeng/api/config/RedstoneModeInputOnOff.java @@ -0,0 +1,19 @@ +package appeng.api.config; + + +// do not change names.. +public enum RedstoneModeInputOnOff implements IConfigEnum { + Ignore, + WhenOff, + WhenOn; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "RedstoneMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/RedstoneModeOutput.java b/src/appeng/api/config/RedstoneModeOutput.java new file mode 100644 index 00000000..b94b116f --- /dev/null +++ b/src/appeng/api/config/RedstoneModeOutput.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +// do not change names.. +public enum RedstoneModeOutput implements IConfigEnum { + WhenOff, + WhenOn; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "RedstoneMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/SearchBoxMode.java b/src/appeng/api/config/SearchBoxMode.java new file mode 100644 index 00000000..7a99d1ed --- /dev/null +++ b/src/appeng/api/config/SearchBoxMode.java @@ -0,0 +1,22 @@ +package appeng.api.config; + +import net.minecraft.src.ModLoader; + +public enum SearchBoxMode implements IConfigEnum { + Autosearch, + Standard, + NEIAutoSearch, + NEIStandard; + + @Override + public IConfigEnum[] getValues() { + if ( ModLoader.isModLoaded( "NotEnoughItems" ) ) + return values(); + return new SearchBoxMode[]{ Autosearch, Standard }; + } + + @Override + public String getName() { + return "SearchBoxMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/SortDir.java b/src/appeng/api/config/SortDir.java new file mode 100644 index 00000000..d09904e5 --- /dev/null +++ b/src/appeng/api/config/SortDir.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +public enum SortDir implements IConfigEnum +{ + ASC, + DESC; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "SortDir"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/SortOrder.java b/src/appeng/api/config/SortOrder.java new file mode 100644 index 00000000..fc18c4a4 --- /dev/null +++ b/src/appeng/api/config/SortOrder.java @@ -0,0 +1,20 @@ +package appeng.api.config; + + +public enum SortOrder implements IConfigEnum +{ + Name, + Size, + Priority, + ItemID; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "SortOrder"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/StackModeInput.java b/src/appeng/api/config/StackModeInput.java new file mode 100644 index 00000000..d99dda19 --- /dev/null +++ b/src/appeng/api/config/StackModeInput.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +// do not change names.. +public enum StackModeInput implements IConfigEnum { + Single, + Stack; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "StackMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/StackModeOutput.java b/src/appeng/api/config/StackModeOutput.java new file mode 100644 index 00000000..546b283a --- /dev/null +++ b/src/appeng/api/config/StackModeOutput.java @@ -0,0 +1,20 @@ +package appeng.api.config; + + +// do not change names.. +public enum StackModeOutput implements IConfigEnum { + Single, + Stack, + Craft, + CraftOnly; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "StackMode"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/TransferDir.java b/src/appeng/api/config/TransferDir.java new file mode 100644 index 00000000..ed8cd4e1 --- /dev/null +++ b/src/appeng/api/config/TransferDir.java @@ -0,0 +1,18 @@ +package appeng.api.config; + + +public enum TransferDir implements IConfigEnum +{ + LEFT, + RIGHT; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "TransferDir"; + } +} \ No newline at end of file diff --git a/src/appeng/api/config/ViewItems.java b/src/appeng/api/config/ViewItems.java new file mode 100644 index 00000000..ec5c2d0f --- /dev/null +++ b/src/appeng/api/config/ViewItems.java @@ -0,0 +1,19 @@ +package appeng.api.config; + + +public enum ViewItems implements IConfigEnum +{ + ALL, + STORED, + CRAFTABLE; + + @Override + public IConfigEnum[] getValues() { + return values(); + } + + @Override + public String getName() { + return "ViewItems"; + } +} \ No newline at end of file diff --git a/src/appeng/api/events/AEWorldEvent.java b/src/appeng/api/events/AEWorldEvent.java new file mode 100644 index 00000000..d4cb74b0 --- /dev/null +++ b/src/appeng/api/events/AEWorldEvent.java @@ -0,0 +1,17 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.Event; + +/** + * Simple Alternative to WorldEvent, thanks to a certain mod that wants to crash on WorldEvents + */ +public class AEWorldEvent extends Event +{ + final public World world; + + public AEWorldEvent( World w ) + { + world = w; + } +} diff --git a/src/appeng/api/events/GridErrorEvent.java b/src/appeng/api/events/GridErrorEvent.java new file mode 100644 index 00000000..748f1a6e --- /dev/null +++ b/src/appeng/api/events/GridErrorEvent.java @@ -0,0 +1,18 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; + +/** + * an error, basically just causes an update, use it if there is really an error, other wise just ignore it. + */ +public class GridErrorEvent extends AEWorldEvent { + + public WorldCoord coord; + public GridErrorEvent(World world, WorldCoord wc ) { + super(world); + coord = wc; + } + +} diff --git a/src/appeng/api/events/GridPatternUpdateEvent.java b/src/appeng/api/events/GridPatternUpdateEvent.java new file mode 100644 index 00000000..413b13e9 --- /dev/null +++ b/src/appeng/api/events/GridPatternUpdateEvent.java @@ -0,0 +1,22 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; +import appeng.api.me.util.IGridInterface; + +/** + * Posted when crafting options in a AE Network update, you can watch for them if you want to. + */ +public class GridPatternUpdateEvent extends AEWorldEvent { + + final public WorldCoord coord; + final public IGridInterface grid; + + public GridPatternUpdateEvent(World world, WorldCoord wc, IGridInterface gi ) { + super(world); + grid = gi; + coord = wc; + } + +} diff --git a/src/appeng/api/events/GridStorageUpdateEvent.java b/src/appeng/api/events/GridStorageUpdateEvent.java new file mode 100644 index 00000000..aab73c42 --- /dev/null +++ b/src/appeng/api/events/GridStorageUpdateEvent.java @@ -0,0 +1,22 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; +import appeng.api.me.util.IGridInterface; + +/** + * Posted when storage options in a AE Network update, such as a new Storage Bus or Cell is added, or removed. + */ +public class GridStorageUpdateEvent extends AEWorldEvent { + + final public WorldCoord coord; + final public IGridInterface grid; + + public GridStorageUpdateEvent(World world, WorldCoord wc, IGridInterface gi ) { + super(world); + grid = gi; + coord = wc; + } + +} diff --git a/src/appeng/api/events/GridTileConnectivityEvent.java b/src/appeng/api/events/GridTileConnectivityEvent.java new file mode 100644 index 00000000..9d793899 --- /dev/null +++ b/src/appeng/api/events/GridTileConnectivityEvent.java @@ -0,0 +1,22 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; +import appeng.api.me.tiles.IGridTileEntity; + +/** + * The network has changed, and must be updated. + */ +public class GridTileConnectivityEvent extends AEWorldEvent { + + public WorldCoord coord; + public IGridTileEntity te; + + public GridTileConnectivityEvent( IGridTileEntity _te, World world, WorldCoord wc ) { + super(world); + te = _te; + coord = wc; + } + +} diff --git a/src/appeng/api/events/GridTileLoadEvent.java b/src/appeng/api/events/GridTileLoadEvent.java new file mode 100644 index 00000000..2293f56a --- /dev/null +++ b/src/appeng/api/events/GridTileLoadEvent.java @@ -0,0 +1,22 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; +import appeng.api.me.tiles.IGridTileEntity; + +/** + * A Tile has been added to the world, and should be evaluated for Network Connectivity. + */ +public class GridTileLoadEvent extends AEWorldEvent { + + public WorldCoord coord; + public IGridTileEntity te; + + public GridTileLoadEvent(IGridTileEntity _te, World world, WorldCoord wc ) { + super(world); + te = _te; + coord = wc; + } + +} diff --git a/src/appeng/api/events/GridTileUnloadEvent.java b/src/appeng/api/events/GridTileUnloadEvent.java new file mode 100644 index 00000000..d96ccefb --- /dev/null +++ b/src/appeng/api/events/GridTileUnloadEvent.java @@ -0,0 +1,22 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; +import appeng.api.me.tiles.IGridTileEntity; + +/** + * A Tile has been removed from the world, and should no longer be considered for connectivity. + */ +public class GridTileUnloadEvent extends AEWorldEvent { + + public WorldCoord coord; + public IGridTileEntity te; + + public GridTileUnloadEvent(IGridTileEntity _te,World world, WorldCoord wc ) { + super(world); + te = _te; + coord = wc; + } + +} diff --git a/src/appeng/api/events/LocateableEventAnnounce.java b/src/appeng/api/events/LocateableEventAnnounce.java new file mode 100644 index 00000000..2605629e --- /dev/null +++ b/src/appeng/api/events/LocateableEventAnnounce.java @@ -0,0 +1,25 @@ +package appeng.api.events; + +import net.minecraftforge.event.Event; +import appeng.api.me.tiles.ILocateable; + +/** + * Used to Notify the Location Registry of objects, and their availability. + */ +public class LocateableEventAnnounce extends Event { + + public enum LocateableEvent { + Register, // Adds the locateable to the registry + Unregister // Removes the Locatable from the registry + }; + + final public ILocateable target; + final public LocateableEvent change; + + public LocateableEventAnnounce( ILocateable o, LocateableEvent ev ) + { + target = o; + change = ev; + } + +} diff --git a/src/appeng/api/events/MultiBlockUpdateEvent.java b/src/appeng/api/events/MultiBlockUpdateEvent.java new file mode 100644 index 00000000..280abddd --- /dev/null +++ b/src/appeng/api/events/MultiBlockUpdateEvent.java @@ -0,0 +1,22 @@ +package appeng.api.events; + +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import appeng.api.WorldCoord; +import appeng.api.me.tiles.IGridTileEntity; + +/** + * Used by the MAC to trigger updates in its structure. + */ +public class MultiBlockUpdateEvent extends AEWorldEvent { + + public WorldCoord coord; + public IGridTileEntity te; + + public MultiBlockUpdateEvent( IGridTileEntity _te, World world, WorldCoord wc ) { + super(world); + coord = wc; + te = _te; + } + +} diff --git a/src/appeng/api/exceptions/AppEngException.java b/src/appeng/api/exceptions/AppEngException.java new file mode 100644 index 00000000..940e7bee --- /dev/null +++ b/src/appeng/api/exceptions/AppEngException.java @@ -0,0 +1,12 @@ +package appeng.api.exceptions; + +public class AppEngException extends Exception +{ + + private static final long serialVersionUID = -9051434206368465494L; + + public AppEngException(String t) + { + super(t); + } +} diff --git a/src/appeng/api/exceptions/AppEngTileMissingException.java b/src/appeng/api/exceptions/AppEngTileMissingException.java new file mode 100644 index 00000000..067e47f1 --- /dev/null +++ b/src/appeng/api/exceptions/AppEngTileMissingException.java @@ -0,0 +1,30 @@ +package appeng.api.exceptions; + +import cpw.mods.fml.common.FMLLog; +import net.minecraft.world.World; +import appeng.api.DimentionalCoord; + +public class AppEngTileMissingException extends Exception { + + private static final long serialVersionUID = -3502227742711078681L; + public DimentionalCoord dc; + + @Override + public void printStackTrace() { + try + { + FMLLog.info( "[AppEng] Missing Tile at "+dc.x+", "+dc.y+", "+dc.z+" in +"+dc.getWorld().getWorldInfo().getVanillaDimension() ); + } + catch( Throwable _ ) + { + FMLLog.info( "[AppEng] Missing Tile at "+dc.x+", "+dc.y+", "+dc.z ); + } + super.printStackTrace(); + } + + public AppEngTileMissingException(World w, int x, int y, int z) + { + dc = new DimentionalCoord( w, x, y, z ); + } + +} diff --git a/src/appeng/api/me/items/IAEChargeableItem.java b/src/appeng/api/me/items/IAEChargeableItem.java new file mode 100644 index 00000000..8619a8b7 --- /dev/null +++ b/src/appeng/api/me/items/IAEChargeableItem.java @@ -0,0 +1,25 @@ + +package appeng.api.me.items; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +/* + * A simple AE interface used internally for PowerRelay charging. + */ +public interface IAEChargeableItem { + + /* + * Return the amount of energy not used. + * + * if you return the same amount out, as was passed in, then it will consider charging done. + * + */ + public float addEnergy( ItemStack target, float energy ); + + /* + * Must return true for the target item for it to be considered a charageable item. + */ + public boolean isChargeable( ItemStack it ); + +} diff --git a/src/appeng/api/me/items/IAEWrench.java b/src/appeng/api/me/items/IAEWrench.java new file mode 100644 index 00000000..6abead7b --- /dev/null +++ b/src/appeng/api/me/items/IAEWrench.java @@ -0,0 +1,9 @@ +package appeng.api.me.items; + +import net.minecraft.entity.player.EntityPlayer; + +public interface IAEWrench { + + boolean canWrench(EntityPlayer player, int x, int y, int z); + +} diff --git a/src/appeng/api/me/items/IAssemblerPatternItem.java b/src/appeng/api/me/items/IAssemblerPatternItem.java new file mode 100644 index 00000000..42532da9 --- /dev/null +++ b/src/appeng/api/me/items/IAssemblerPatternItem.java @@ -0,0 +1,8 @@ +package appeng.api.me.items; + +/** + * Like ILocationPatternItem, not really useful... + */ +public interface IAssemblerPatternItem +{ +} diff --git a/src/appeng/api/me/items/ILocationPatternItem.java b/src/appeng/api/me/items/ILocationPatternItem.java new file mode 100644 index 00000000..58a0bd4a --- /dev/null +++ b/src/appeng/api/me/items/ILocationPatternItem.java @@ -0,0 +1,7 @@ +package appeng.api.me.items; + +/** + * Like IAssemblerPatternItem, not really useful... + */ +public interface ILocationPatternItem { +} diff --git a/src/appeng/api/me/items/IMEPatternItem.java b/src/appeng/api/me/items/IMEPatternItem.java new file mode 100644 index 00000000..d9458709 --- /dev/null +++ b/src/appeng/api/me/items/IMEPatternItem.java @@ -0,0 +1,9 @@ +package appeng.api.me.items; + +/** + * Some basic actions you can perform on Patterns. + */ +public interface IMEPatternItem { + boolean isEncoded(); + String Type(); +} diff --git a/src/appeng/api/me/items/IMemoryCard.java b/src/appeng/api/me/items/IMemoryCard.java new file mode 100644 index 00000000..f9c1df53 --- /dev/null +++ b/src/appeng/api/me/items/IMemoryCard.java @@ -0,0 +1,40 @@ +package appeng.api.me.items; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +/** + * used to interact with memory card items. + */ +public interface IMemoryCard { + + /** + * returns true if the item is in fact a memory card. + * @param is + * @return + */ + boolean isMemoryCard( ItemStack is ); + + /** + * Configures the data stored on the memory card, the SettingsName, will be localized when displayed. + * @param is + * @param SettingsName + * @param data + */ + void setMemoryCardContents( ItemStack is, String SettingsName, NBTTagCompound data ); + + /** + * returns the settings name provided previously by setMemoryCardContents, or "AppEng.GuiITooltip.Blank" if there is no settings. + * @param is + * @return + */ + String getSettingsName( ItemStack is ); + + /** + * returns the NBT Data previously saved by setMemoryCardContents, or an empty NBTCompound + * @param is + * @return + */ + NBTTagCompound getData( ItemStack is ); + +} diff --git a/src/appeng/api/me/items/IStorageCell.java b/src/appeng/api/me/items/IStorageCell.java new file mode 100644 index 00000000..d77580d8 --- /dev/null +++ b/src/appeng/api/me/items/IStorageCell.java @@ -0,0 +1,48 @@ +package appeng.api.me.items; + +import appeng.api.IAEItemStack; +import net.minecraft.item.ItemStack; + +/** + * Any item which implements this can be treated as an IMEInventory via Util.getCell / Util.isCell + * It automatically handles the internals and NBT data, which is both nice, and bad for you! + */ +public interface IStorageCell +{ + /** + * rv0 - If this returns something where N % 8 != 0 Then you will be shot on sight, or your car will explode, something like that least... + * @param cellItem + * @return numberofBytes + */ + int getBytes( ItemStack cellItem ); + + /** + * rv0 - Determines the number of bytes used for any type included on the cell. + * @param cellItem + * @return numberOfBytes + */ + int BytePerType( ItemStack iscellItem ); + + /** + * rv11 - Must be between 1 and 63, indicates how many types you want to store on the item. + * @param cellItem + * @return numberOfTypes + */ + int getTotalTypes( ItemStack cellItem ); + + /** + * rv11 - allows you to fine tune which items are allowed on a given cell, + * if you don't care, just return false; + * As the handler for this type of cell is still the default cells, the normal AE black list is also applied. + * @param cellItem + * @param requsetedAddition + * @return preventAdditionOfItem + */ + boolean isBlackListed( ItemStack cellItem, IAEItemStack requsetedAddition ); + + /** + * rv11 - allows you to specify if this storage cell can be stored inside other storage cells, only set this for special items like the matter cannon that are not general purpose storage. + * @return + */ + boolean storableInStorageCell(); +} diff --git a/src/appeng/api/me/items/IStorageComponent.java b/src/appeng/api/me/items/IStorageComponent.java new file mode 100644 index 00000000..f905373f --- /dev/null +++ b/src/appeng/api/me/items/IStorageComponent.java @@ -0,0 +1,21 @@ +package appeng.api.me.items; + +import net.minecraft.item.ItemStack; + +public interface IStorageComponent { + + /** + * rv11 - This isn't necessarily the same as if you make a storage cell out of it, but all of AE's default cells do it that way, its currently only used for the condenser. + * @param cellItem + * @return numberofBytes + */ + int getBytes( ItemStack is ); + + /** + * rv11 - just true or false for the item stack. + * @param is + * @return + */ + boolean isStorageComponent( ItemStack is ); + +} diff --git a/src/appeng/api/me/tiles/IAssemblerMB.java b/src/appeng/api/me/tiles/IAssemblerMB.java new file mode 100644 index 00000000..9b7cf72a --- /dev/null +++ b/src/appeng/api/me/tiles/IAssemblerMB.java @@ -0,0 +1,20 @@ +package appeng.api.me.tiles; + +import appeng.api.WorldCoord; +import appeng.api.me.util.IAssemblerCluster; + +public interface IAssemblerMB { + + /** + * Do this: + * return new WorldCoord( TileEntity.xCoord, TileEntity.yCoord, TileEntity.zCoord ); + */ + public WorldCoord getLocation(); + public IAssemblerCluster getCluster(); + public void updateStatus( IAssemblerCluster ac ); + public boolean isComplete(); + + void calculateMultiblock( long instanceCalc ); + public long markViewed(long inst); + +} diff --git a/src/appeng/api/me/tiles/IAssemblerPatternProvider.java b/src/appeng/api/me/tiles/IAssemblerPatternProvider.java new file mode 100644 index 00000000..b59f0b23 --- /dev/null +++ b/src/appeng/api/me/tiles/IAssemblerPatternProvider.java @@ -0,0 +1,11 @@ +package appeng.api.me.tiles; + +import appeng.api.me.util.IAssemblerPattern; + +/** + * Both useless and incredibly useful, maybe... + */ +public interface IAssemblerPatternProvider +{ + public IAssemblerPattern provideAssemblerPattern(); +} diff --git a/src/appeng/api/me/tiles/ICellContainer.java b/src/appeng/api/me/tiles/ICellContainer.java new file mode 100644 index 00000000..40481a5e --- /dev/null +++ b/src/appeng/api/me/tiles/ICellContainer.java @@ -0,0 +1,24 @@ +package appeng.api.me.tiles; + +import java.util.List; + +import appeng.api.me.util.IMEInventoryHandler; + +/** + * Represents a tile that contributes to storage, such as a ME Chest, or ME Drive. + * + * Remember to trigger the appropriate storage update vents, when your getCellArray Changes. * + */ +public interface ICellContainer { + + /** + * Inventory of the tile for use with ME, should always return an valid list, never NULL. + */ + List getCellArray(); + + /** + * the storage's priority. + */ + int getPriority(); + +} diff --git a/src/appeng/api/me/tiles/ICellProvider.java b/src/appeng/api/me/tiles/ICellProvider.java new file mode 100644 index 00000000..e65d09ad --- /dev/null +++ b/src/appeng/api/me/tiles/ICellProvider.java @@ -0,0 +1,23 @@ +package appeng.api.me.tiles; + +import appeng.api.me.util.IMEInventoryHandler; + +/** + * Both useless and incredibly useful, maybe... + */ +public interface ICellProvider +{ + /** + * consume power to add an item to the storage system. + * @param items + * @param multiplier + * @return + */ + public int usePowerForAddition( int items, int multiplier ); + + /** + * returns a ME Inventory for interaction. + */ + public IMEInventoryHandler provideCell(); + +} diff --git a/src/appeng/api/me/tiles/IColoredMETile.java b/src/appeng/api/me/tiles/IColoredMETile.java new file mode 100644 index 00000000..70a61cf9 --- /dev/null +++ b/src/appeng/api/me/tiles/IColoredMETile.java @@ -0,0 +1,36 @@ +package appeng.api.me.tiles; + +/** + * Used to signify which color a particular IGridTileEntity or IGridMachine is, you must implement both, if you wish to have color bias. + */ +public interface IColoredMETile +{ + public static String[] Colors = { + "Blue", + "Black", + "White", + "Brown", + "Red", + "Yellow", + "Green" + }; + + /** + * return true, if your block has a color, or false, if it dosn't. + * this allows you to have a colored block that can pretend to be colorless. + * @return true, if colored, false if not. + */ + boolean isColored(); + + /** + * Change the color, AE dosn't call this except for its own blocks, its simply included for completeness. + * @param offset + */ + void setColor( int offset ); + + /** + * which color is this tile? + * @return index into the above ColorsList. + */ + int getColor(); +} diff --git a/src/appeng/api/me/tiles/IConfigureableTile.java b/src/appeng/api/me/tiles/IConfigureableTile.java new file mode 100644 index 00000000..fbaa38de --- /dev/null +++ b/src/appeng/api/me/tiles/IConfigureableTile.java @@ -0,0 +1,28 @@ +package appeng.api.me.tiles; + +import java.util.List; + +/** + * Some ME Tiles can be configured, generally via interface, but these let you do this programatically. + */ +public interface IConfigureableTile { + + /** Switches configuration to next option... ( returns new configuration. ) */ + String prevConfiguration(String name); + + /** Switches configuration to next option... ( returns new configuration. ) */ + String nextConfiguration(String name); + + /** Gets a list off all the configurations... */ + List getConfigurations(); + + /** Gets the options of a particular configuration. */ + List getConfiguationOptions( String name ); + + /** Set a configuration to a specific option... ( returns the old one. ) */ + String setConfiguration(String name, String value); + + /** The the current value for a configuration. */ + String getConfiguration(String name); + +} diff --git a/src/appeng/api/me/tiles/IConnectionSensitive.java b/src/appeng/api/me/tiles/IConnectionSensitive.java new file mode 100644 index 00000000..723401c1 --- /dev/null +++ b/src/appeng/api/me/tiles/IConnectionSensitive.java @@ -0,0 +1,11 @@ +package appeng.api.me.tiles; + +import java.util.Set; + +import net.minecraftforge.common.ForgeDirection; + +public interface IConnectionSensitive { + + void onMEConnectionsChanged( Set connections, Set visualConnections ); + +} diff --git a/src/appeng/api/me/tiles/IDirectionalMETile.java b/src/appeng/api/me/tiles/IDirectionalMETile.java new file mode 100644 index 00000000..1cccdc63 --- /dev/null +++ b/src/appeng/api/me/tiles/IDirectionalMETile.java @@ -0,0 +1,20 @@ +package appeng.api.me.tiles; + +import net.minecraftforge.common.ForgeDirection; + +/** + * Used to signify which directions a particular IGridTileEntity or IGridMachine can connect to/from, + * you must implement both, if you wish to have this functionality. + * + * Example Buses, that do not conenct in the direction of the bus. + */ +public interface IDirectionalMETile +{ + + /** + * return true if this tile can connect in a specific direction. + * @param dir + * @return true, if it can connect. + */ + boolean canConnect( ForgeDirection dir ); +} diff --git a/src/appeng/api/me/tiles/IExtendedCellProvider.java b/src/appeng/api/me/tiles/IExtendedCellProvider.java new file mode 100644 index 00000000..5df4532b --- /dev/null +++ b/src/appeng/api/me/tiles/IExtendedCellProvider.java @@ -0,0 +1,13 @@ +package appeng.api.me.tiles; + +import appeng.api.me.util.IMEInventoryHandler; + +/** + * Both useless and incredibly useful, maybe... + */ +public interface IExtendedCellProvider extends ICellProvider +{ + + public IMEInventoryHandler provideCell( String Filter ); + +} diff --git a/src/appeng/api/me/tiles/IFulllyOptionalMETile.java b/src/appeng/api/me/tiles/IFulllyOptionalMETile.java new file mode 100644 index 00000000..664bd228 --- /dev/null +++ b/src/appeng/api/me/tiles/IFulllyOptionalMETile.java @@ -0,0 +1,11 @@ +package appeng.api.me.tiles; + +/** + * Cables will disconnect if its not enabled, + * this means that they will fail to appear connected, example - MAC + */ +public interface IFulllyOptionalMETile extends IOptionalMETile { + + boolean isSeperated(); + +} diff --git a/src/appeng/api/me/tiles/IGridMachine.java b/src/appeng/api/me/tiles/IGridMachine.java new file mode 100644 index 00000000..c62d3a69 --- /dev/null +++ b/src/appeng/api/me/tiles/IGridMachine.java @@ -0,0 +1,13 @@ +package appeng.api.me.tiles; + +/** + * Allows you to drain energy via ME Cables, if you only care if the grid is powered you only need IGridTileEntity. + */ +public abstract interface IGridMachine extends IGridTileEntity +{ + /** + * how much power this entity drains to run constantly. + */ + public abstract float getPowerDrainPerTick(); + +} diff --git a/src/appeng/api/me/tiles/IGridTeleport.java b/src/appeng/api/me/tiles/IGridTeleport.java new file mode 100644 index 00000000..6703b4e1 --- /dev/null +++ b/src/appeng/api/me/tiles/IGridTeleport.java @@ -0,0 +1,11 @@ +package appeng.api.me.tiles; + +import appeng.api.DimentionalCoord; + +/** + * Create a connection to a normally not connected tile + */ +public interface IGridTeleport +{ + DimentionalCoord[] findRemoteSide(); +} diff --git a/src/appeng/api/me/tiles/IGridTileEntity.java b/src/appeng/api/me/tiles/IGridTileEntity.java new file mode 100644 index 00000000..7b956302 --- /dev/null +++ b/src/appeng/api/me/tiles/IGridTileEntity.java @@ -0,0 +1,49 @@ +package appeng.api.me.tiles; + +import net.minecraft.world.World; +import appeng.api.WorldCoord; +import appeng.api.me.util.IGridInterface; + +/** + * Basic ME Grid Interface, informs you of the Grid power status, and other details. + */ +public abstract interface IGridTileEntity +{ + /** + * Do this: + * return new WorldCoord( TileEntity.xCoord, TileEntity.yCoord, TileEntity.zCoord ); + */ + public abstract WorldCoord getLocation(); + + /** + * If your tile entity is valid return true. + */ + public boolean isValid(); + + /** + * Informs you of either true or false. + * if the power feed has stopped, or been continued, only called when changes happens, or when grid updates happen. + */ + public abstract void setPowerStatus(boolean hasPower); + + /** + * Yes if the device has a powered status. + */ + public abstract boolean isPowered(); + + /** + * Return your last grid you got via setGrid. + */ + public IGridInterface getGrid(); + + /** + * Informs you of your new grid, YOU MUST return this via getGrid. + * Store for later. + */ + public void setGrid(IGridInterface gi); + + /** + * Return worldObj + */ + public World getWorld(); +} diff --git a/src/appeng/api/me/tiles/ILocateable.java b/src/appeng/api/me/tiles/ILocateable.java new file mode 100644 index 00000000..18417876 --- /dev/null +++ b/src/appeng/api/me/tiles/ILocateable.java @@ -0,0 +1,10 @@ +package appeng.api.me.tiles; + +public interface ILocateable +{ + /** + * returns the serial for a locateable object. + * @return + */ + long getLocatableSerial(); +} diff --git a/src/appeng/api/me/tiles/IMEPowerStorage.java b/src/appeng/api/me/tiles/IMEPowerStorage.java new file mode 100644 index 00000000..5a118407 --- /dev/null +++ b/src/appeng/api/me/tiles/IMEPowerStorage.java @@ -0,0 +1,34 @@ +package appeng.api.me.tiles; + +/** + * Used to access information about AE's various power accepting blocks for monitoring purposes. + * + */ +public interface IMEPowerStorage { + + /** + * ME power storage asset, pass the amount you want to use, and what you want to use it for. + * @param use + * @param for_what + * @return if you can use it. + */ + boolean useMEEnergy( float use, String for_what ); + + /** + * Add energy to an ME Power storage. + * @param amt that was not added to storage myEnergy = addMEPower( myEnergy ); // pushes your power into the network. + * @return + */ + public double addMEPower( double amt ); + + /** + * returns the current maximum power ( this can change :P ) + */ + public double getMEMaxPower(); + + /** + * returns the current AE Power Level, this may exceed getMEMaxPower() + */ + public double getMECurrentPower(); + +} diff --git a/src/appeng/api/me/tiles/INonSignalBlock.java b/src/appeng/api/me/tiles/INonSignalBlock.java new file mode 100644 index 00000000..eb0fb801 --- /dev/null +++ b/src/appeng/api/me/tiles/INonSignalBlock.java @@ -0,0 +1,9 @@ +package appeng.api.me.tiles; + +/** + * By simply implenting this, the networks can be become aware of a block they touch, but they don't propogate signal or really belong to a network. + * Not sure what it would be used for to be honest beyond the power relay. + */ +public interface INonSignalBlock { + +} diff --git a/src/appeng/api/me/tiles/IOptionalMETile.java b/src/appeng/api/me/tiles/IOptionalMETile.java new file mode 100644 index 00000000..ff0d525d --- /dev/null +++ b/src/appeng/api/me/tiles/IOptionalMETile.java @@ -0,0 +1,14 @@ +package appeng.api.me.tiles; + +/** + * Cables will connect, but signal will not propagate. ( IFulllyOptionalMETile disconnects ) + */ +public interface IOptionalMETile { + + /** + * if false, the signal will not propigate via this tile, remember to use connectivity events. + * @return + */ + public boolean isEnabled(); + +} diff --git a/src/appeng/api/me/tiles/IOrientableTile.java b/src/appeng/api/me/tiles/IOrientableTile.java new file mode 100644 index 00000000..26336736 --- /dev/null +++ b/src/appeng/api/me/tiles/IOrientableTile.java @@ -0,0 +1,26 @@ +package appeng.api.me.tiles; + +import net.minecraftforge.common.ForgeDirection; + +/** + * Please note that none of these methods will cause a block update, + * if you use set ori/spin/cycle, must mark the block for update if it was already sent to the client. + */ +public interface IOrientableTile { + + // returns the main direction for rotation. + ForgeDirection getPrimaryOrientation(); + + // used for up or down orientation to spin the tile around, 0 - 3 clockwise ( probobly ) + int getSpin(); + + // returns the main direction for rotation. + void setPrimaryOrientation( ForgeDirection s ); + + // used for up or down orientation. + void setSpin( int spin ); + + // acts like a wrench was used on it, if a wrench does nothing, this does nothing. + void cycleOrientation(); + +} diff --git a/src/appeng/api/me/tiles/IPriorityTile.java b/src/appeng/api/me/tiles/IPriorityTile.java new file mode 100644 index 00000000..b4243a3f --- /dev/null +++ b/src/appeng/api/me/tiles/IPriorityTile.java @@ -0,0 +1,17 @@ +package appeng.api.me.tiles; + +public interface IPriorityTile +{ + /** + * gets the current priroity, can be negitive or positive. + * implemented by storage systems, and is used for sorting. + * @return + */ + int getPriority(); + + /** + * change the priority. + * @param p + */ + void setPriority( int p ); +} diff --git a/src/appeng/api/me/tiles/IPushable.java b/src/appeng/api/me/tiles/IPushable.java new file mode 100644 index 00000000..f96b6205 --- /dev/null +++ b/src/appeng/api/me/tiles/IPushable.java @@ -0,0 +1,30 @@ +package appeng.api.me.tiles; + +import net.minecraft.item.ItemStack; + +/** + * An IPushable should return what dosn't fit, so that the crafting request cannot complete, + * stalling the action and saving your resources. + */ +public interface IPushable +{ + /** + * is this pushable busy? + * @return + */ + boolean isBusy(); + + /** + * Attempt to send an item. + * @param out + * @return + */ + ItemStack pushItem( ItemStack out ); + + /** + * Test if a push is possible. + * @param out + * @return + */ + boolean canPushItem(ItemStack out); +} diff --git a/src/appeng/api/me/tiles/IStorageAware.java b/src/appeng/api/me/tiles/IStorageAware.java new file mode 100644 index 00000000..c064da5e --- /dev/null +++ b/src/appeng/api/me/tiles/IStorageAware.java @@ -0,0 +1,13 @@ +package appeng.api.me.tiles; + +import appeng.api.IItemList; + +public interface IStorageAware { + + /** + * if your GridTile Implements this interface, the Network will notify it of changes, and send you a list of the contents so you can updates statues, WAY BETTER then polling. + * @param iss + */ + void onNetworkInventoryChange( IItemList iss ); + +} diff --git a/src/appeng/api/me/tiles/IStorageMonitor.java b/src/appeng/api/me/tiles/IStorageMonitor.java new file mode 100644 index 00000000..f8886b10 --- /dev/null +++ b/src/appeng/api/me/tiles/IStorageMonitor.java @@ -0,0 +1,20 @@ +package appeng.api.me.tiles; + +import appeng.api.IAEItemStack; + +public interface IStorageMonitor { + + /** + * Get the item being displayed on the storage monitor, in AEItemstack Form, you can use that to get the equivalent MC ItemStack, if you need it. + * If the quantity is important remember to use getStackSize() on the IAEItemStack,and not ItemStack.stackSize + * @return + */ + IAEItemStack getItem(); + + /** + * Get the current locked state of the access terminal. + * @return + */ + boolean isLocked(); + +} diff --git a/src/appeng/api/me/tiles/ITileCable.java b/src/appeng/api/me/tiles/ITileCable.java new file mode 100644 index 00000000..ed64d54d --- /dev/null +++ b/src/appeng/api/me/tiles/ITileCable.java @@ -0,0 +1,7 @@ +package appeng.api.me.tiles; + +public interface ITileCable { + + public boolean coveredConnections(); + +} diff --git a/src/appeng/api/me/tiles/ITileIOCable.java b/src/appeng/api/me/tiles/ITileIOCable.java new file mode 100644 index 00000000..d63dd2be --- /dev/null +++ b/src/appeng/api/me/tiles/ITileIOCable.java @@ -0,0 +1,30 @@ +package appeng.api.me.tiles; + +import net.minecraft.inventory.IInventory; + +/** + * used to allow you to inspect, and configure a Export / Import / Storage Bus + * Export and Import buses also implement IConfigureableTile, which may be of interest. + */ +public interface ITileIOCable { + + public enum Version { + Basic, Precision, Fuzzy + }; + + /** + * returns one of the above, to indicate which version of the bus it is. + */ + Version getVersion(); + + /** + * Returns an IInventory that represents the configuration. + */ + IInventory getConfiguration(); + + /** + * Returns the name of the bus.. + */ + String getName(); + +} diff --git a/src/appeng/api/me/tiles/ITileInterfaceApi.java b/src/appeng/api/me/tiles/ITileInterfaceApi.java new file mode 100644 index 00000000..f4a2855b --- /dev/null +++ b/src/appeng/api/me/tiles/ITileInterfaceApi.java @@ -0,0 +1,78 @@ +package appeng.api.me.tiles; + +import java.util.List; + +import net.minecraft.item.ItemStack; +import appeng.api.me.util.IMEInventory; +import appeng.api.me.util.InterfaceCraftingResponse; + +/** + * Implemented by the ME Interface + * give direct access to some more complicated logic, in a simpler way, was used for earily LP integration. + */ +public interface ITileInterfaceApi { + + /** + * how much space is available. + * @param i + * @param MaxNeeded, a cut off where you stop caring + * @return totalAmountNeeded + */ + int apiCurrentAvailableSpace(ItemStack i, int MaxNeeded); + + /** + * Attempt to extract an item from the network. + * @param i, item to extract. + * @param doExtract, if you don't its just a simulation. + * @return anyExtracted Items, or null + */ + ItemStack apiExtractNetworkItem(ItemStack i, boolean doExtract); + + /** + * Adds an item to the network + * @param i + * @param doAdd, or simulate + * @return any items that couldn't be added, or nul + */ + ItemStack apiAddNetworkItem(ItemStack i, boolean doAdd); + + /** + * returns a list of ItemStacks that are contined in the network. + * @return + */ + List apiGetNetworkContents(); + + /** + * get access to the networks IMEInventory. + * @return + */ + IMEInventory getApiArray(); + + /** + * get a list of items that can be crafted by the network. + * @return + */ + List getCraftingOptions(); + + /** + * get access to the crafting patterns. + * @param req + * @return + */ + List findCraftingPatterns( ItemStack req ); + + /** + * issue a new crafting request. + * @param req + * @param enableRecursive + * @return + */ + InterfaceCraftingResponse requestCrafting( ItemStack req, boolean enableRecursive ); + + /** + * if there is anything at all available it returns true. + * @return + */ + boolean containsItems(); + +} diff --git a/src/appeng/api/me/tiles/InterfaceCraftingPattern.java b/src/appeng/api/me/tiles/InterfaceCraftingPattern.java new file mode 100644 index 00000000..3ba69b43 --- /dev/null +++ b/src/appeng/api/me/tiles/InterfaceCraftingPattern.java @@ -0,0 +1,19 @@ +package appeng.api.me.tiles; + +import java.util.List; + +import net.minecraft.item.ItemStack; + +public class InterfaceCraftingPattern { + + /** + * list of all the inputs. + */ + public List Inputs; + + /** + * the output of the pattern. + */ + public ItemStack Output; + +} diff --git a/src/appeng/api/me/util/Grid.java b/src/appeng/api/me/util/Grid.java new file mode 100644 index 00000000..74a81349 --- /dev/null +++ b/src/appeng/api/me/util/Grid.java @@ -0,0 +1,84 @@ +package appeng.api.me.util; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import appeng.api.me.tiles.IGridTileEntity; + +/** + * ME Network, aka Grid related features and functionality. + */ +public class Grid +{ + /** + * Attempts to find a grid interface for the specified location. + * @param w + * @param x + * @param y + * @param z + * @return interfaceForGrid + */ + public static IGridInterface getGridInterface(World w, int x, int y, int z) + { + IGridTileEntity te = getGridEntity(w, x, y, z); + + if (te != null) + { + return te.getGrid(); + } + + return null; + } + + /** + * Simple test to see if the tile at the specified location is in fact a grid entity. + * @param w + * @param x + * @param y + * @param z + * @return isTileGridEntity + */ + public static boolean isGridEntity(World w, int x, int y, int z) + { + return getGridEntity(w, x, y, z) != null; + } + + /** + * Returns the grid entity at the given location, or null if its not a grid entity. + * @param w + * @param x + * @param y + * @param z + * @return gridEntity + */ + public static IGridTileEntity getGridEntity(World w, int x, int y, int z) + { + TileEntity te = w.getBlockTileEntity(x, y, z); + + if (te instanceof IGridTileEntity) + { + return (IGridTileEntity)te; + } + + return null; + } + + /** + * Tests if the given grid entity is on a Network. + * @param w + * @param x + * @param y + * @param z + * @return isOnNetwork + */ + public static boolean isOnGrid(World w, int x, int y, int z) + { + IGridTileEntity te = getGridEntity(w, x, y, z); + + if (te != null) + { + return te.getGrid() != null; + } + + return false; + } +} diff --git a/src/appeng/api/me/util/IAssemblerCluster.java b/src/appeng/api/me/util/IAssemblerCluster.java new file mode 100644 index 00000000..39902290 --- /dev/null +++ b/src/appeng/api/me/util/IAssemblerCluster.java @@ -0,0 +1,37 @@ +package appeng.api.me.util; + +import net.minecraft.tileentity.TileEntity; + +/** + * Definition for a MAC + * + */ +public interface IAssemblerCluster { + + /** + * cycles the cpus, should be called once a tick, if called more, crafting will accelerate. + */ + public void cycleCpus(); + + /** + * Tells the MAC one of the cpus was used. + */ + void addCraft(); + + /** + * is there a CPU available for Crafting? + * @return hasCPUReady + */ + boolean canCraft(); + + /** + * Gets a TileAssembler from the MAC + * @param assemblerOffset + * @return TileEntity for that Assembler or Null + */ + TileEntity getAssembler( int assemblerOffset ); + + public int getLastOffset(); + + public void setLastOffset( int x ); +} diff --git a/src/appeng/api/me/util/IAssemblerPattern.java b/src/appeng/api/me/util/IAssemblerPattern.java new file mode 100644 index 00000000..56e1a098 --- /dev/null +++ b/src/appeng/api/me/util/IAssemblerPattern.java @@ -0,0 +1,78 @@ +package appeng.api.me.util; + +import java.util.List; + +import appeng.api.IItemList; +import appeng.api.me.tiles.IPushable; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +/** + * Interact with the internals of assembler patterns, get this via Util.getAssemblerPattern(...) + */ +public interface IAssemblerPattern +{ + + IAssemblerCluster getCluster(); + + /** Returns a 3x3 matrix of nulls or ItemStacks, or null if it is not included. */ + ItemStack[] getCraftingMatrix(); + + /** + * Same as getCraftingMatrix(), but gets a crafting inventory for real crafting. + * + * Item pool is optional, null will work, but it won't be able to edit items... + */ + InventoryCrafting getCraftingInv( World w, IMEInventory itemPool, List missing, List used, IItemList all ); + + /** Returns a ItemStack, if the pattern is encoded, this will ALWAYS have a value. */ + ItemStack getOutput(); + + /** Returns true if there is a pattern encoded. */ + boolean isEncoded(); + + /** + * Encode a pattern. + * craftingMatrix - accepts a 3x3 grid of ItemStacks and Nulls. + * output - accepts a single ItemStack, NEVER SEND NULL + */ + void encodePattern(ItemStack[] craftingMatrix, ItemStack output); + + /** + * I have no idea what the World is for, its just part of IRecipe... + */ + boolean isCraftable(World w); + + /** + * Returns a condensed list of requirements. + * + * Example: sticks, will return a single stack of 2, rather then two stacks of 1. + * The same Item will not show more than one stack. + */ + public List condensedRequirements(); + + /** Returns the Tile Entity for the interface... */ + List getInterface(); + + /** Sets the Tile Entity for the interface... */ + void setInterface(IPushable a); + + /** returns the output of the pattern */ + ItemStack getRecipeOutput( InventoryCrafting ic, World w ); + + /** returns the recipe for the patterns */ + IRecipe getMatchingRecipe( InventoryCrafting ic, World w ); + + /** + * Compare to Patterns + * @param obj + * @return + */ + @Override + public boolean equals(Object obj); + +} + diff --git a/src/appeng/api/me/util/IConfigManager.java b/src/appeng/api/me/util/IConfigManager.java new file mode 100644 index 00000000..42f3ae4c --- /dev/null +++ b/src/appeng/api/me/util/IConfigManager.java @@ -0,0 +1,10 @@ +package appeng.api.me.util; + +import appeng.api.config.IConfigEnum; +import appeng.api.me.tiles.IConfigureableTile; + +public interface IConfigManager extends IConfigureableTile +{ + + IConfigEnum getSetting( String sName ); +} diff --git a/src/appeng/api/me/util/ICraftRequest.java b/src/appeng/api/me/util/ICraftRequest.java new file mode 100644 index 00000000..2812e514 --- /dev/null +++ b/src/appeng/api/me/util/ICraftRequest.java @@ -0,0 +1,9 @@ +package appeng.api.me.util; + +/** + * Pretty much just a place holder right now + * + */ +public interface ICraftRequest { + +} diff --git a/src/appeng/api/me/util/ICraftWatcher.java b/src/appeng/api/me/util/ICraftWatcher.java new file mode 100644 index 00000000..2ba84108 --- /dev/null +++ b/src/appeng/api/me/util/ICraftWatcher.java @@ -0,0 +1,12 @@ +package appeng.api.me.util; + +/** + * Not used. + * + */ +public interface ICraftWatcher { + + void markChainCrafted(); + void markComplete( ICraftRequest cr ); + +} diff --git a/src/appeng/api/me/util/IGridCache.java b/src/appeng/api/me/util/IGridCache.java new file mode 100644 index 00000000..3dce582b --- /dev/null +++ b/src/appeng/api/me/util/IGridCache.java @@ -0,0 +1,46 @@ +package appeng.api.me.util; + +import net.minecraft.nbt.NBTTagCompound; + +/** + * + * Allows you to cache information on the grid, for usage later, its up to you how you want to deal with saving/loading/resetting. + * + * Any Class that implements this, should have a default constructor that takes no arguments. + * + * Register this with Util.getAppEngApi().registerGridCache( MyGridCache.class ); + * + */ +public interface IGridCache { + + /** + * Called each time a network is reset ( changed ), the grid will persist your classes instance, but call this method. + * @param grid + */ + void reset( IGridInterface grid ); + + /** + * Called each tick for the controller, allows you to have active network wide behaviors. + * @param grid + */ + void onUpdateTick( IGridInterface grid ); + + /** + * used to uniquely identify your cache when saving/loading + * @return + */ + String getCacheName(); + + /** + * Save your caches state if necessary, if no saving is required, return null. + * @return + */ + NBTTagCompound savetoNBTData(); + + /** + * Load save cache data, this is called when a controller is loaded with previously saved data if there was no data, data will be an empty tag. + * @param data + */ + void loadfromNBTData( NBTTagCompound data ); + +} diff --git a/src/appeng/api/me/util/IGridInterface.java b/src/appeng/api/me/util/IGridInterface.java new file mode 100644 index 00000000..441984f1 --- /dev/null +++ b/src/appeng/api/me/util/IGridInterface.java @@ -0,0 +1,219 @@ +package appeng.api.me.util; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import appeng.api.IAEItemStack; +import appeng.api.TileRef; +import appeng.api.exceptions.AppEngTileMissingException; +import appeng.api.me.tiles.IGridMachine; +import appeng.api.me.tiles.IGridTileEntity; +import appeng.api.me.tiles.IPushable; + +/** + * Lets you access network related features. You will mostly care about "getCellArray()" which returns the IMEInventory for the entire network... + */ +public interface IGridInterface +{ + /** + * Issue a new crafting request. + * @param whatToCraft + * @param showInMonitor + * @param enableRecursion + * @return the ICraftRequest + * @throws AppEngTileMissingException + */ + public ICraftRequest craftingRequest( ItemStack whatToCraft, boolean showInMonitor, boolean enableRecursion ) throws AppEngTileMissingException; + + /** + * deprecated version of creaftingRequest. + * @param what + * @return + * @throws AppEngTileMissingException + */ + public ICraftRequest craftingRequest( ItemStack what ) throws AppEngTileMissingException; + + /** + * opens the crafting gui. + * @param pmp + * @param gte + * @param s + * @throws AppEngTileMissingException + */ + public void craftGui( EntityPlayerMP pmp, IGridTileEntity gte, ItemStack s ) throws AppEngTileMissingException; + + /** + * Updates the interface requested, used internally + * @param te + */ + public void requestUpdate( IGridTileEntity te ); + + /** + * returns a list of all machines on the grid. + * @return + */ + List< TileRef > getMachines(); + + /** + * Labeled version for debugging... + */ + boolean useMEEnergy(float use, String for_what); + + /** + * returns energy to the system to prevent endless energy sinks. + */ + void refundMEEnergy( float use, String for_what ); + + /** + * Reports previous 20 ticks avg of energy usage. + * @return + */ + public float getPowerUsageAvg(); + + /** + * this is used for standard items, anything else just use useMEEnergy. + * @param items + * @param multipler + * @return + */ + int usePowerForAddition(int items, int multipler); + + /** + * returns a single IMEInventory that represents the entire networks. + * @return + */ + public IMEInventoryHandler getCellArray(); + + /** + * returns a single IMEInventory that represents the entire network, and all crafting available. + * @return + */ + public IMEInventoryHandler getFullCellArray(); + + /** + * add which users should be notified of terminal updates. + * @param p + */ + void addViewingPlayer(EntityPlayer p); + + /** + * remove which users should be notified of terminal updates. + * @param p + */ + void rmvViewingPlayer(EntityPlayer p); + + /** + * add which users should be notified of crafting queue updates. + * @param p + */ + void addCraftingPlayer(EntityPlayer p); + + /** + * remove which users should be notified of crafting queue updates. + * @param p + */ + void rmvCraftingPlayer(EntityPlayer p); + + /** + * aquire the controller tile entity. + * @return + */ + public TileEntity getController(); + + /** + * create a waiting job. + * @param what + * @return + */ + ICraftRequest waitingRequest(ItemStack what); + + /** + * creates a crafting job to push the item out of IPushable, and to enable crafting to acocomplish this goal. + * @param willAdd + * @param out + * @param allowCrafting + * @return + */ + ICraftRequest pushRequest( ItemStack willAdd, IPushable out, boolean allowCrafting ); + + /** + * is the grid valid? + * @return + */ + public boolean isValid(); + + /** + * tell AE to re-examin items in the waiting list. + */ + void resetWaitingQueue(); + + /** + * craftable items + * @return + */ + IMEInventoryHandler getCraftableArray(); + + /** + * get a numeric id for this grid, used internally for cable animations, and not much else. + * @return + */ + public int getGridIndex(); + + /** + * Try to find the pattern for the item in question. + * @param req + * @return + */ + public IAssemblerPattern getPatternFor(ItemStack req); + + /** + * Inform the network that power costs have changed. + */ + public void triggerPowerUpdate(); + + /** + * Inform the netowrk that these items were removed from storage ( don't do this for items remove though the grid, it already knows about those. ) + * @param removed + */ + public void notifyExtractItems(IAEItemStack removed); + + /** + * Inform the network that these items were added to storage ( don't do this for items added via the grid, it already knows about those. ) + * @param vo + */ + public void notifyAddItems(IAEItemStack vo); + + /** + * return a cache by its identifier ( the number you get when you register your cache with AE ) + * @param id + * @return + */ + public IGridCache getCacheByID( int id ); + + /** + * Potential future use, for now just returns the network encryption key. + * @return + */ + public String getName(); + + /** + * inform the network that energy was transfered between two nodes on the network, + * this will be used to calculates future information, but also causes the network + * to flash presently. + * + * this will automatically be handled by the standard extractItem / addItem API in the future, only + * Processes that skip the vanilla AE storage system should use this. + * + * @param a + * @param b + * @param amt + */ + void signalEnergyTransfer(IGridTileEntity a, IGridTileEntity b, float amt); + + @Override + public boolean equals(Object obj); + +} diff --git a/src/appeng/api/me/util/ILocationPattern.java b/src/appeng/api/me/util/ILocationPattern.java new file mode 100644 index 00000000..49b62cf3 --- /dev/null +++ b/src/appeng/api/me/util/ILocationPattern.java @@ -0,0 +1,12 @@ +package appeng.api.me.util; + +import appeng.api.WorldCoord; + +/** + * Lets you Access Internal Location Pattern data. + */ +public interface ILocationPattern { + WorldCoord getLocation(); + + void setLocation(int x, int y, int z); +} diff --git a/src/appeng/api/me/util/IMEInventory.java b/src/appeng/api/me/util/IMEInventory.java new file mode 100644 index 00000000..3e369149 --- /dev/null +++ b/src/appeng/api/me/util/IMEInventory.java @@ -0,0 +1,77 @@ +package appeng.api.me.util; + +import appeng.api.IAEItemStack; +import appeng.api.IItemList; + +/** + * Lets you access Internal Cell Inventories. + */ +public interface IMEInventory +{ + /** + * The number of different item types stored in inventory. + */ + public long storedItemTypes(); + + /** + * The number of stored items total, regardless of type. + */ + public long storedItemCount(); + + /** + * The estimated number of additional items this inventory can hold, regardless of type. + */ + public long remainingItemCount(); + + /** + * The estimated number of additional types the inventory could hold. + */ + public long remainingItemTypes(); + + /** + * True or False if this item is inside this inventory. + */ + public boolean containsItemType(IAEItemStack i); + + /** + * The total number of types holdable in this inventory. + */ + public long getTotalItemTypes(); + + /** + * Returns how many of this item are in the inventory, regardless of a how many stacks / cells or anything else. + */ + public long countOfItemType(IAEItemStack i); + + /** + * Adds input, to the inventory, and returns items not added, complete failure yields a copy of the stack that was passed. + */ + public IAEItemStack addItems( IAEItemStack input ); + + /** + * Attempts to extract the requested item, in the count specified by the request, returns items extracted, complete failure yields NULL. + */ + public IAEItemStack extractItems( IAEItemStack request ); + + // DO NOT USE ItemStack.split, these are for information purpose ONLY! + // I you wan to remove items from the cell, use extractItemss + + /** + * Returns a list of all available items, with stackSize set to the real amount, without stack limits. + */ + public IItemList getAvailableItems( IItemList out ); + + /** + * Returns a list of all available items, with stackSize set to the real amount, without stack limits. + */ + public IItemList getAvailableItems(); + + /** + * Identical to addItems(...) but it don't change anything, its just a simulation. + * this is used when dealing with pipes/tubes, and routing. + */ + public IAEItemStack calculateItemAddition(IAEItemStack stack); + + // calculates available space for a specific item. + public long getAvailableSpaceByItem( IAEItemStack i, long maxNeeded ); +} diff --git a/src/appeng/api/me/util/IMEInventoryHandler.java b/src/appeng/api/me/util/IMEInventoryHandler.java new file mode 100644 index 00000000..947f5178 --- /dev/null +++ b/src/appeng/api/me/util/IMEInventoryHandler.java @@ -0,0 +1,76 @@ +package appeng.api.me.util; + +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import appeng.api.IAEItemStack; +import appeng.api.IItemList; +import appeng.api.config.FuzzyMode; +import appeng.api.config.IConfigEnum; +import appeng.api.config.ItemFlow; +import appeng.api.config.ListMode; + +public interface IMEInventoryHandler extends IMEInventory { + + public ItemFlow getFlow(); + public void setFlow( ItemFlow p ); + + public int getPriority(); + public void setPriority( int p ); + + /** + * Returns estimated number of total bytes represented by the inventory, used mainly for display. + */ + public long totalBytes(); + + /** + * Returns estimated number of free bytes represented by inventory, used mainly for display. + */ + public long freeBytes(); + + /** + * Returns number of used bytes represented by the inventory, used mainly for display. + */ + public long usedBytes(); + + /** + * The number of items you could add before the freeBytes() decreases. + */ + public long unusedItemCount(); + + /** + * True of False, if you could add a new item type. + */ + public boolean canHoldNewItem(); + + /** + * This tells you where it found your cell, so if your cell changes, you should update this block... + */ + void setUpdateTarget(TileEntity e); + + List getPreformattedItems(); + void setPreformattedItems(IItemList in, FuzzyMode mode, ListMode m); + + boolean isPreformatted(); + boolean isFuzzyPreformatted(); + + ListMode getListMode(); + FuzzyMode getFuzzyModePreformatted(); + + void setFuzzyPreformatted( boolean nf ); + + public void setName(String name); + String getName(); + + void setGrid( IGridInterface grid ); + IGridInterface getGrid(); + + void setParent( IMEInventoryHandler p ); + IMEInventoryHandler getParent(); + + void removeGrid(IGridInterface grid, IMEInventoryHandler ignore, List duplicates ); + public void validate( List duplicates ); + public boolean canAccept(IAEItemStack input); + +} diff --git a/src/appeng/api/me/util/IMEInventoryUtil.java b/src/appeng/api/me/util/IMEInventoryUtil.java new file mode 100644 index 00000000..e43bce07 --- /dev/null +++ b/src/appeng/api/me/util/IMEInventoryUtil.java @@ -0,0 +1,19 @@ +package appeng.api.me.util; + +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.world.World; +import appeng.api.IAEItemStack; +import appeng.api.IItemList; + +public interface IMEInventoryUtil { + + // ignores meta data - is always Fuzzy... + // will only remove single items, this ignores your stack size... + public ItemStack extractItemsByRecipe(World w, IRecipe r, ItemStack output, InventoryCrafting ci, ItemStack providedTemplate, int slot, IItemList all ); + + // ignores meta data - is always Fuzzy... + //public ItemStack extractItemsByType( ItemStack is ); // will only remove single items, this ignores your stack size... + +} diff --git a/src/appeng/api/me/util/InterfaceCraftingResponse.java b/src/appeng/api/me/util/InterfaceCraftingResponse.java new file mode 100644 index 00000000..6a50915e --- /dev/null +++ b/src/appeng/api/me/util/InterfaceCraftingResponse.java @@ -0,0 +1,13 @@ +package appeng.api.me.util; + +import java.util.List; + +import net.minecraft.item.ItemStack; + +public class InterfaceCraftingResponse { + + public ItemStack Request; + + public List UsedMaterials; + +} diff --git a/src/tconstruct/library/tools/ToolCore.java b/src/tconstruct/library/tools/ToolCore.java index 3a5bfa32..5ef30c6f 100644 --- a/src/tconstruct/library/tools/ToolCore.java +++ b/src/tconstruct/library/tools/ToolCore.java @@ -9,6 +9,9 @@ import java.util.List; import java.util.Map; import java.util.Random; +import appeng.api.IAEItemStack; +import appeng.api.me.items.IAEChargeableItem; +import appeng.api.me.items.IStorageCell; import mods.battlegear2.api.weapons.IBattlegearWeapon; import mods.battlegear2.api.weapons.OffhandAttackEvent; import net.minecraft.block.Block; @@ -56,7 +59,7 @@ import cpw.mods.fml.relauncher.SideOnly; * @see ToolMod */ -public abstract class ToolCore extends Item implements ICustomElectricItem, IBoxable, IBattlegearWeapon//, IStorageCell, IAEChargeableItem +public abstract class ToolCore extends Item implements ICustomElectricItem, IBoxable, IBattlegearWeapon, IStorageCell, IAEChargeableItem { protected Random random = new Random(); protected int damageVsEntity; @@ -989,7 +992,7 @@ public abstract class ToolCore extends Item implements ICustomElectricItem, IBox } /* Applied Energistics support, IAEChargableItem */ - /*@Override + @Override public float addEnergy (ItemStack target, float energy) { // TODO Auto-generated method stub @@ -1001,10 +1004,10 @@ public abstract class ToolCore extends Item implements ICustomElectricItem, IBox { // TODO Auto-generated method stub return false; - }*/ + } /* Applied Energistics support, IStorageCell */ - /*@Override + @Override public int getBytes (ItemStack cellItem) { // TODO Auto-generated method stub @@ -1036,5 +1039,5 @@ public abstract class ToolCore extends Item implements ICustomElectricItem, IBox { // TODO Auto-generated method stub return false; - }*/ + } } From e013079fec91bfbf0ddbd0722da45ba84abe566b Mon Sep 17 00:00:00 2001 From: Arthur Uzulin Date: Thu, 10 Oct 2013 21:34:22 +1100 Subject: [PATCH 02/26] Added a null check to tank air block --- src/tconstruct/blocks/TankAirBlock.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tconstruct/blocks/TankAirBlock.java b/src/tconstruct/blocks/TankAirBlock.java index 40af03f5..37f911ba 100644 --- a/src/tconstruct/blocks/TankAirBlock.java +++ b/src/tconstruct/blocks/TankAirBlock.java @@ -58,7 +58,7 @@ public class TankAirBlock extends BlockContainer public AxisAlignedBB getCollisionBoundingBoxFromPool (World world, int x, int y, int z) { TankAirLogic tank = (TankAirLogic) world.getBlockTileEntity(x, y, z); - if (tank.hasItem()) + if (tank != null && tank.hasItem()) return super.getCollisionBoundingBoxFromPool(world, x, y, z); return null; From b85a607ee4b4e42efe168ca306a4e12d453a6e5e Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Fri, 11 Oct 2013 13:00:07 +0100 Subject: [PATCH 03/26] Stone Ladder texture --- .../assets/tinker/textures/blocks/ladder.png | Bin 0 -> 494 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 resources/assets/tinker/textures/blocks/ladder.png diff --git a/resources/assets/tinker/textures/blocks/ladder.png b/resources/assets/tinker/textures/blocks/ladder.png new file mode 100644 index 0000000000000000000000000000000000000000..f344bc239ec52ce4890b55de88d19117e26f19d8 GIT binary patch literal 494 zcmV%y*NyCuiWhw%e^*uh)u>+VA&jv)SmJ0kGTc6u{wdU^bfpVB0nT{eE8$ zS5-w>mRzq_JkKMJW8)t{mSwoEi)C5lc@Ch@rs}!|KnQ_pnq*n_`m`_%)qFnhTpDqLic%|69fT8Q6Qycxm*&*v0(s2 zQKW((;Cwz)Rh1qRLbMo!VMv;$JfBaJB>94vB#BYiwYuN$TrL-*V~dyE#}7D+MkD?J z@g=7jlx2yOlGSR}+W*~))9IucXb+~-DMAR2$K$UI8ZVk$s5$)XZQG_{)$+h~U8IyK^<}ALSv($(mJ9D5=*uXI k)MByd{0o!G Date: Sat, 12 Oct 2013 17:59:02 +1100 Subject: [PATCH 04/26] Fixed a rare/possible null pointer exception --- src/tconstruct/blocks/logic/DrawbridgeLogic.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/tconstruct/blocks/logic/DrawbridgeLogic.java b/src/tconstruct/blocks/logic/DrawbridgeLogic.java index d03ba9a4..10772114 100644 --- a/src/tconstruct/blocks/logic/DrawbridgeLogic.java +++ b/src/tconstruct/blocks/logic/DrawbridgeLogic.java @@ -258,6 +258,9 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc int yPos = yCoord; int zPos = zCoord; + bufferStack = inventory[0].copy(); + bufferStack.stackSize = 1; + switch (direction) { case 0: From b2edbd816d1c90ff78fa2a08756f4331e09144c0 Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Sat, 12 Oct 2013 15:33:35 +0100 Subject: [PATCH 05/26] Implement stone ladder --- resources/assets/tinker/lang/en_US.lang | 1 + .../blocks/{ladder.png => ladder_stone.png} | Bin src/tconstruct/blocks/StoneLadder.java | 36 ++++++++++++++++++ src/tconstruct/common/TContent.java | 3 ++ src/tconstruct/util/config/PHConstruct.java | 2 + 5 files changed, 42 insertions(+) rename resources/assets/tinker/textures/blocks/{ladder.png => ladder_stone.png} (100%) create mode 100644 src/tconstruct/blocks/StoneLadder.java diff --git a/resources/assets/tinker/lang/en_US.lang b/resources/assets/tinker/lang/en_US.lang index 48c0e5e1..8653e9d6 100644 --- a/resources/assets/tinker/lang/en_US.lang +++ b/resources/assets/tinker/lang/en_US.lang @@ -238,6 +238,7 @@ StorageMetals.Steel.name=Block of Steel StorageMetals.Ender.name=Block of Solid Ender tile.decoration.stonetorch.name=Torch +tile.decoration.stoneladder.name=Ladder tile.CraftingStation.name=Crafting Station block.glass.pure.name=Clear Glass diff --git a/resources/assets/tinker/textures/blocks/ladder.png b/resources/assets/tinker/textures/blocks/ladder_stone.png similarity index 100% rename from resources/assets/tinker/textures/blocks/ladder.png rename to resources/assets/tinker/textures/blocks/ladder_stone.png diff --git a/src/tconstruct/blocks/StoneLadder.java b/src/tconstruct/blocks/StoneLadder.java new file mode 100644 index 00000000..fe31026f --- /dev/null +++ b/src/tconstruct/blocks/StoneLadder.java @@ -0,0 +1,36 @@ +package tconstruct.blocks; + +import net.minecraft.block.BlockLadder; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.util.Icon; + +public class StoneLadder extends BlockLadder { + + // Override ladder material + public final Material blockMaterial = Material.rock; + + private Icon icon; + + // Use the normally protected constructor + public StoneLadder(int id) + { + super(id); + this.setUnlocalizedName("decoration.stoneladder"); + this.setCreativeTab(CreativeTabs.tabDecorations); + } + + @Override + public void registerIcons(IconRegister register) + { + icon = register.registerIcon("tinker:ladder_stone"); + } + + @Override + public Icon getIcon(int meta, int side) + { + return icon; + } + +} diff --git a/src/tconstruct/common/TContent.java b/src/tconstruct/common/TContent.java index bebcd075..75e37a26 100644 --- a/src/tconstruct/common/TContent.java +++ b/src/tconstruct/common/TContent.java @@ -140,6 +140,7 @@ public class TContent implements IFuelHandler //Decoration public static Block stoneTorch; + public static Block stoneLadder; public static Block multiBrick; public static Block multiBrickFancy; @@ -707,6 +708,8 @@ public class TContent implements IFuelHandler //Decoration stoneTorch = new StoneTorch(PHConstruct.stoneTorch).setUnlocalizedName("decoration.stonetorch"); GameRegistry.registerBlock(stoneTorch, "decoration.stonetorch"); + stoneLadder = new StoneLadder(PHConstruct.stoneLadder).setUnlocalizedName("decoration.stoneladder"); + GameRegistry.registerBlock(stoneLadder, "decoration.stoneladder"); multiBrick = new MultiBrick(PHConstruct.multiBrick).setUnlocalizedName("Decoration.Brick"); GameRegistry.registerBlock(multiBrick, MultiBrickItem.class, "decoration.multibrick"); diff --git a/src/tconstruct/util/config/PHConstruct.java b/src/tconstruct/util/config/PHConstruct.java index e40de758..7f054c50 100644 --- a/src/tconstruct/util/config/PHConstruct.java +++ b/src/tconstruct/util/config/PHConstruct.java @@ -88,6 +88,7 @@ public class PHConstruct multiBrick = config.getBlock("Multi Brick", 1481).getInt(1481); stoneTorch = config.getBlock("Stone Torch", 1484).getInt(1484); + stoneLadder = config.getBlock("Stone Ladder", 1479).getInt(1479); oreBerry = config.getBlock("Ore Berry One", 1485).getInt(1485); oreBerrySecond = config.getBlock("Ore Berry Two", 1486).getInt(1486); @@ -473,6 +474,7 @@ public class PHConstruct //Decoration public static int stoneTorch; + public static int stoneLadder; public static int multiBrick; public static int multiBrickFancy; public static int redstoneBallRepeater; From 9bdbd6c6f17d4e88d24f5db516eab395cbfc6b02 Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Sat, 12 Oct 2013 15:40:56 +0100 Subject: [PATCH 06/26] Add recipe for stone ladder --- src/tconstruct/common/TContent.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tconstruct/common/TContent.java b/src/tconstruct/common/TContent.java index 75e37a26..2bf3cb2e 100644 --- a/src/tconstruct/common/TContent.java +++ b/src/tconstruct/common/TContent.java @@ -1648,6 +1648,7 @@ public class TContent implements IFuelHandler GameRegistry.addRecipe(new ItemStack(Block.pumpkinLantern, 1, 0), "p", "s", 'p', new ItemStack(Block.pumpkin), 'w', new ItemStack(stoneTorch)); GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(stoneTorch, 4), "p", "w", 'p', new ItemStack(Item.coal, 1, Short.MAX_VALUE), 'w', "stoneRod")); + GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(stoneLadder, 3), "w w", "www", "w w", 'w', "stoneRod")); GameRegistry.addRecipe(new ItemStack(toolRod, 4, 1), "c", "c", 'c', new ItemStack(Block.stone)); GameRegistry.addRecipe(new ItemStack(toolRod, 2, 1), "c", "c", 'c', new ItemStack(Block.cobblestone)); From 5c043d66f43d077635dda32758b57f5bd792f3b9 Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Sat, 12 Oct 2013 23:46:35 +0100 Subject: [PATCH 07/26] Convert to Java logging framework. Closes #227. --- src/ic2/api/item/Items.java | 3 ++- src/tconstruct/TConstruct.java | 20 ++++++++++++------- .../blocks/logic/CastingBasinLogic.java | 4 ++-- .../blocks/logic/CastingChannelLogic.java | 4 ++-- .../blocks/logic/CastingTableLogic.java | 4 ++-- .../blocks/logic/FirestarterLogic.java | 5 +++-- .../blocks/logic/GolemPedestalLogic.java | 5 +++-- .../blocks/logic/SmelteryDrainLogic.java | 7 ++++--- .../blocks/logic/SmelteryLogic.java | 8 ++++---- src/tconstruct/client/TClientEvents.java | 4 ++-- src/tconstruct/client/TClientTickHandler.java | 2 +- src/tconstruct/client/TControls.java | 2 +- src/tconstruct/client/ToolCoreRenderer.java | 3 ++- .../block/BlockRenderCastingChannel.java | 2 +- .../block/CastingTableSpecialRenderer.java | 2 +- .../client/block/DryingRackSpecialRender.java | 2 +- .../client/block/RenderLandmine.java | 2 +- .../client/gui/CraftingStationGui.java | 2 +- src/tconstruct/common/TContent.java | 6 +++--- src/tconstruct/common/TimeTicker.java | 3 ++- src/tconstruct/entity/CartEntity.java | 2 +- .../entity/projectile/DaggerEntity.java | 2 +- .../inventory/AdaptiveSmelteryContainer.java | 6 +++--- .../inventory/SmelteryContainer.java | 6 +++--- .../inventory/ToolStationContainer.java | 2 +- src/tconstruct/items/tools/Arrow.java | 13 ++++++------ src/tconstruct/items/tools/BowBase.java | 5 +++-- src/tconstruct/items/tools/Mattock.java | 5 +++-- .../library/TConstructRegistry.java | 19 ++++++++++-------- .../library/component/TankLayerScan.java | 11 +++++----- .../library/crafting/ShapelessToolRecipe.java | 2 +- .../library/crafting/ToolBuilder.java | 2 +- src/tconstruct/library/tools/ToolCore.java | 5 +++-- src/tconstruct/modifiers/ModBoolean.java | 2 +- src/tconstruct/modifiers/ModRepair.java | 2 +- src/tconstruct/util/TEventHandler.java | 2 +- src/tconstruct/util/config/BOPConfig.java | 3 ++- .../util/config/DimensionBlacklist.java | 4 ++-- src/tconstruct/util/config/PHConstruct.java | 5 +++-- .../util/config/TwilightForestConfig.java | 3 ++- .../util/network/TPacketHandler.java | 6 ++---- src/tconstruct/util/player/ArmorExtended.java | 8 ++++---- .../util/player/ArmorExtendedClient.java | 2 +- .../util/player/TPlayerHandler.java | 8 ++++---- .../worldgen/TBaseWorldGenerator.java | 12 +++++------ .../worldgen/village/ComponentSmeltery.java | 5 +++-- 46 files changed, 127 insertions(+), 105 deletions(-) diff --git a/src/ic2/api/item/Items.java b/src/ic2/api/item/Items.java index 5e695160..f19ebc64 100644 --- a/src/ic2/api/item/Items.java +++ b/src/ic2/api/item/Items.java @@ -1,6 +1,7 @@ package ic2.api.item; import net.minecraft.item.ItemStack; +import tconstruct.TConstruct; /** * Provides access to IC2 blocks and items. @@ -34,7 +35,7 @@ public final class Items { return null; } } catch (Exception e) { - System.out.println("IC2 API: Call getItem failed for "+name); + TConstruct.logger.warning("IC2 API: Call getItem failed for " + name); return null; } diff --git a/src/tconstruct/TConstruct.java b/src/tconstruct/TConstruct.java index c7334c8a..d397eb8d 100644 --- a/src/tconstruct/TConstruct.java +++ b/src/tconstruct/TConstruct.java @@ -23,6 +23,8 @@ import tconstruct.util.player.TPlayerHandler; import tconstruct.worldgen.*; import tconstruct.worldgen.village.*; +import java.util.logging.Logger; + /** TConstruct, the tool mod. * Craft your tools with style, then modify until the original is gone! * @author: mDiyo @@ -37,6 +39,9 @@ public class TConstruct public static final int ingotLiquidValue = 144; public static final int liquidUpdateAmount = 6; + // Shared mod logger + public static final Logger logger = Logger.getLogger("TConstruct"); + /* Instance of this mod, used for grabbing prototype fields */ @Instance("TConstruct") public static TConstruct instance; @@ -46,27 +51,28 @@ public class TConstruct public TConstruct() { + logger.setParent(FMLCommonHandler.instance().getFMLLogger()); if (Loader.isModLoaded("Natura")) { - System.out.println("[TConstruct] Natura, what are we going to do tomorrow night?"); + TConstruct.logger.info("[TConstruct] Natura, what are we going to do tomorrow night?"); if (Loader.isModLoaded("ChaoticBastion")) { - System.out.println("[Natura] TConstruct, we're going to..."); - System.out.println("[ChaoticBastion] All your base are belong to us!"); + TConstruct.logger.info("[Natura] TConstruct, we're going to..."); + TConstruct.logger.info("[ChaoticBastion] All your base are belong to us!"); } else - System.out.println("[Natura] TConstruct, we're going to take over the world!"); + TConstruct.logger.info("[Natura] TConstruct, we're going to take over the world!"); } else { if (Loader.isModLoaded("ChaoticBastion")) { - System.out.println("[TConstruct] Preparing to..."); - System.out.println("[ChaoticBastion] I'MA FIRING MY LAZOR!"); + TConstruct.logger.info("[TConstruct] Preparing to..."); + TConstruct.logger.info("[ChaoticBastion] I'MA FIRING MY LAZOR!"); } else - System.out.println("[TConstruct] Preparing to take over the world"); + TConstruct.logger.info("[TConstruct] Preparing to take over the world"); } } diff --git a/src/tconstruct/blocks/logic/CastingBasinLogic.java b/src/tconstruct/blocks/logic/CastingBasinLogic.java index 368f05ae..fdb60792 100644 --- a/src/tconstruct/blocks/logic/CastingBasinLogic.java +++ b/src/tconstruct/blocks/logic/CastingBasinLogic.java @@ -88,7 +88,7 @@ public class CastingBasinLogic extends InventoryLogic implements IFluidTank, IFl ret = TConstruct.basinCasting.getCastingAmount(this.liquid, inv); } - System.out.println("Ret: " + ret); + TConstruct.logger.info("Ret: " + ret); return ret; } @@ -304,7 +304,7 @@ public class CastingBasinLogic extends InventoryLogic implements IFluidTank, IFl { if (castingDelay > 0) { - //System.out.println("Casting"); + //TConstruct.logger.info("Casting"); castingDelay--; if (castingDelay == 0) castLiquid(); diff --git a/src/tconstruct/blocks/logic/CastingChannelLogic.java b/src/tconstruct/blocks/logic/CastingChannelLogic.java index a41581b0..9e7d08b4 100644 --- a/src/tconstruct/blocks/logic/CastingChannelLogic.java +++ b/src/tconstruct/blocks/logic/CastingChannelLogic.java @@ -121,7 +121,7 @@ public class CastingChannelLogic extends TileEntity implements IFluidTank, IFlui HashMap tankMap = this.getOutputs(); if (tankMap.size() <= 0) { - //System.out.println("Nope, no connections to go to"); + //TConstruct.logger.info("Nope, no connections to go to"); return; } boolean yFilled = false; @@ -211,7 +211,7 @@ public class CastingChannelLogic extends TileEntity implements IFluidTank, IFlui HashMap tankMap = this.getOutputs(); if (tankMap.size() <= 0) { - //System.out.println("Nope, no connections to go to"); + //TConstruct.logger.info("Nope, no connections to go to"); return; } boolean yFilled = false; diff --git a/src/tconstruct/blocks/logic/CastingTableLogic.java b/src/tconstruct/blocks/logic/CastingTableLogic.java index 362c7708..e25e6a74 100644 --- a/src/tconstruct/blocks/logic/CastingTableLogic.java +++ b/src/tconstruct/blocks/logic/CastingTableLogic.java @@ -88,7 +88,7 @@ public class CastingTableLogic extends InventoryLogic implements IFluidTank, IFl ret = TConstruct.tableCasting.getCastingAmount(this.liquid, inv); } - System.out.println("Ret: " + ret); + TConstruct.logger.info("Ret: " + ret); return ret; } @@ -304,7 +304,7 @@ public class CastingTableLogic extends InventoryLogic implements IFluidTank, IFl { if (castingDelay > 0) { - //System.out.println("Casting"); + //TConstruct.logger.info("Casting"); castingDelay--; if (castingDelay == 0) castLiquid(); diff --git a/src/tconstruct/blocks/logic/FirestarterLogic.java b/src/tconstruct/blocks/logic/FirestarterLogic.java index f1f71eea..57e2fb4b 100644 --- a/src/tconstruct/blocks/logic/FirestarterLogic.java +++ b/src/tconstruct/blocks/logic/FirestarterLogic.java @@ -1,5 +1,6 @@ package tconstruct.blocks.logic; +import tconstruct.TConstruct; import tconstruct.library.tools.AbilityHelper; import tconstruct.library.util.IActiveLogic; import tconstruct.library.util.IFacingLogic; @@ -70,7 +71,7 @@ public class FirestarterLogic extends TileEntity implements IFacingLogic, IActiv Block block = Block.blocksList[worldObj.getBlockId(xPos, yPos, zPos)]; if (active) { - System.out.println("Setting fire"); + TConstruct.logger.info("Setting fire"); if (block == null || block.isAirBlock(worldObj, xPos, yPos, zPos)) { worldObj.playSoundEffect((double) xPos + 0.5D, (double) yPos + 0.5D, (double) zPos + 0.5D, "fire.ignite", 1.0F, AbilityHelper.random.nextFloat() * 0.4F + 0.8F); @@ -79,7 +80,7 @@ public class FirestarterLogic extends TileEntity implements IFacingLogic, IActiv } else { - //System.out.println("Stopping fire "+putOut); + //TConstruct.logger.info("Stopping fire "+putOut); if (block == Block.fire) { //worldObj.playSoundEffect((double) xPos + 0.5D, (double) yPos + 0.5D, (double) zPos + 0.5D, "random.fizz", 1.0F, AbilityHelper.random.nextFloat() * 0.4F + 0.8F); diff --git a/src/tconstruct/blocks/logic/GolemPedestalLogic.java b/src/tconstruct/blocks/logic/GolemPedestalLogic.java index 13af961c..5513aaeb 100644 --- a/src/tconstruct/blocks/logic/GolemPedestalLogic.java +++ b/src/tconstruct/blocks/logic/GolemPedestalLogic.java @@ -9,6 +9,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; import net.minecraft.src.ModLoader; import net.minecraft.tileentity.TileEntity; +import tconstruct.TConstruct; public class GolemPedestalLogic extends TileEntity implements IInventory { @@ -190,7 +191,7 @@ public class GolemPedestalLogic extends TileEntity implements IInventory public boolean subtractSoul (int i) { - System.out.println("SUBTRACT WHY"); + TConstruct.logger.info("SUBTRACT WHY"); if (supply == null || supply.itemID >= 512 || cost[supply.itemID] == 0) { worldObj.playSoundAtEntity(ModLoader.getMinecraftInstance().thePlayer, "mob.blaze.death", 1.0F, 0.5F); @@ -200,7 +201,7 @@ public class GolemPedestalLogic extends TileEntity implements IInventory int j = cost[supply.itemID]; int k = souls[supply.itemID]; int l = (supply.stackSize / j) * k; - System.out.println((new StringBuilder()).append("Subtracting amt").append(i).append(" s").append(k).append(" c").append(j).append(" ss").append(supply.stackSize).append(" id") + TConstruct.logger.info((new StringBuilder()).append("Subtracting amt").append(i).append(" s").append(k).append(" c").append(j).append(" ss").append(supply.stackSize).append(" id") .append(supply.itemID).append(" sa").append(l).append(" calc").append(Math.ceil((double) i / (double) k)).toString()); if (l < i) { diff --git a/src/tconstruct/blocks/logic/SmelteryDrainLogic.java b/src/tconstruct/blocks/logic/SmelteryDrainLogic.java index 9dc0c76e..5bc810b4 100644 --- a/src/tconstruct/blocks/logic/SmelteryDrainLogic.java +++ b/src/tconstruct/blocks/logic/SmelteryDrainLogic.java @@ -1,5 +1,6 @@ package tconstruct.blocks.logic; +import tconstruct.TConstruct; import tconstruct.library.crafting.AlloyMix; import tconstruct.library.util.IFacingLogic; import tconstruct.library.util.IMasterLogic; @@ -28,7 +29,7 @@ public class SmelteryDrainLogic extends MultiServantLogic implements IFluidHandl @Override public boolean setPotentialMaster (IMasterLogic master, World world, int x, int y, int z) { - System.out.println("Master: "+master); + TConstruct.logger.info("Master: "+master); return (master instanceof AdaptiveSmelteryLogic || master instanceof SmelteryDrainLogic) && !hasMaster; } @@ -46,11 +47,11 @@ public class SmelteryDrainLogic extends MultiServantLogic implements IFluidHandl @Override public FluidStack drain (ForgeDirection from, int maxDrain, boolean doDrain) { - System.out.println("Attempting drain "+hasValidMaster()); + TConstruct.logger.info("Attempting drain " + hasValidMaster()); if (hasValidMaster() && canDrain(from, null)) { AdaptiveSmelteryLogic smeltery = (AdaptiveSmelteryLogic) worldObj.getBlockTileEntity(master.x, master.y, master.z); - System.out.println("Found master"); + TConstruct.logger.info("Found master"); return smeltery.drain(from, maxDrain, doDrain); } return null; diff --git a/src/tconstruct/blocks/logic/SmelteryLogic.java b/src/tconstruct/blocks/logic/SmelteryLogic.java index f5bf6553..61704cf2 100644 --- a/src/tconstruct/blocks/logic/SmelteryLogic.java +++ b/src/tconstruct/blocks/logic/SmelteryLogic.java @@ -455,7 +455,7 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci return false; currentLiquid += liquid.amount; - //System.out.println("Current liquid: "+currentLiquid); + //TConstruct.logger.info("Current liquid: "+currentLiquid); boolean added = false; for (int i = 0; i < moltenMetal.size(); i++) { @@ -585,11 +585,11 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci TileEntity newTankContainer = worldObj.getBlockTileEntity(possibleTank.x, possibleTank.y, possibleTank.z); if (newTankContainer instanceof IFluidHandler) { - //System.out.println("Tank: "+possibleTank.toString()); + //TConstruct.logger.info("Tank: "+possibleTank.toString()); FluidStack newliquid = ((IFluidHandler) newTankContainer).drain(ForgeDirection.UNKNOWN, 150, false); if (newliquid != null && newliquid.getFluid().getBlockID() == Block.lavaStill.blockID && newliquid.amount > 0) { - //System.out.println("Tank: "+possibleTank.toString()); + //TConstruct.logger.info("Tank: "+possibleTank.toString()); foundTank = true; activeLavaTank = possibleTank; iter = lavaTanks.size(); @@ -616,7 +616,7 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci if (iter >= lavaTanks.size()) foundTank = true; } - //System.out.println("Searching for tank, size: "+lavaTanks.size()); + //TConstruct.logger.info("Searching for tank, size: "+lavaTanks.size()); } } } diff --git a/src/tconstruct/client/TClientEvents.java b/src/tconstruct/client/TClientEvents.java index dd2215c3..4e159114 100644 --- a/src/tconstruct/client/TClientEvents.java +++ b/src/tconstruct/client/TClientEvents.java @@ -44,11 +44,11 @@ public class TClientEvents soundmanager.addSound("tinker:frypan_hit.ogg"); soundmanager.addSound("tinker:little_saw.ogg"); soundmanager.addSound("tinker:launcher_clank.ogg"); - System.out.println("[TConstruct] Successfully loaded sounds."); + TConstruct.logger.info("Successfully loaded sounds."); } catch (Exception e) { - System.err.println("[TConstruct] Failed to register one or more sounds"); + TConstruct.logger.warning("Failed to register one or more sounds"); } } } diff --git a/src/tconstruct/client/TClientTickHandler.java b/src/tconstruct/client/TClientTickHandler.java index aa38d30a..69b8782f 100644 --- a/src/tconstruct/client/TClientTickHandler.java +++ b/src/tconstruct/client/TClientTickHandler.java @@ -46,7 +46,7 @@ public class TClientTickHandler implements ITickHandler //this.mc.renderEngine.bindTexture("/mods/tinker/textures/gui/newhearts.png"); int hp = MathHelper.ceiling_float_int(this.mc.thePlayer.getHealth());//(int) player.getEntityAttribute(SharedMonsterAttributes.field_111267_a).func_111125_b();//player.getHealth(); - //System.out.println("hp: "+hp); + //TConstruct.logger.info("hp: "+hp); for (int iter = 0; iter < hp / 20; iter++) { int renderHearts = (hp - 20*(iter+1)) / 2; diff --git a/src/tconstruct/client/TControls.java b/src/tconstruct/client/TControls.java index ae1eb6d7..b3c366e1 100644 --- a/src/tconstruct/client/TControls.java +++ b/src/tconstruct/client/TControls.java @@ -37,7 +37,7 @@ public class TControls extends TKeyHandler public TControls() { super(new KeyBinding[] { armorKey, refreshCapes }, new boolean[] { false, false }, getVanillaKeyBindings(), new boolean[] { false, false }); - //System.out.println("Controls registered"); + //TConstruct.logger.info("Controls registered"); } private static KeyBinding[] getVanillaKeyBindings () diff --git a/src/tconstruct/client/ToolCoreRenderer.java b/src/tconstruct/client/ToolCoreRenderer.java index 72efadf1..f0057f73 100644 --- a/src/tconstruct/client/ToolCoreRenderer.java +++ b/src/tconstruct/client/ToolCoreRenderer.java @@ -10,6 +10,7 @@ import net.minecraftforge.client.IItemRenderer; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL12; +import tconstruct.TConstruct; import tconstruct.library.tools.ToolCore; public class ToolCoreRenderer implements IItemRenderer @@ -27,7 +28,7 @@ public class ToolCoreRenderer implements IItemRenderer case INVENTORY: return true; default: - System.out.println("[TCon] Unhandled render case!"); + TConstruct.logger.warning("[TCon] Unhandled render case!"); case FIRST_PERSON_MAP: return false; } diff --git a/src/tconstruct/client/block/BlockRenderCastingChannel.java b/src/tconstruct/client/block/BlockRenderCastingChannel.java index a77e8023..002bbdb5 100644 --- a/src/tconstruct/client/block/BlockRenderCastingChannel.java +++ b/src/tconstruct/client/block/BlockRenderCastingChannel.java @@ -158,7 +158,7 @@ public class BlockRenderCastingChannel implements ISimpleBlockRenderingHandler float liquidAmount = tile.liquid.amount / 288f * 0.125f; renderer.setRenderBounds(0.375D, startY, 0.375D, 0.625D, 0.5 + liquidAmount, 0.625D); //Center renderLiquidPart(world, x, y, z, block, renderer, tile); - //System.out.println(tile.recentlyFilledDelay); + //TConstruct.logger.info(tile.recentlyFilledDelay); if (tile.hasTankConnected(ForgeDirection.NORTH)) { diff --git a/src/tconstruct/client/block/CastingTableSpecialRenderer.java b/src/tconstruct/client/block/CastingTableSpecialRenderer.java index 7fdcf608..5aec7d6c 100644 --- a/src/tconstruct/client/block/CastingTableSpecialRenderer.java +++ b/src/tconstruct/client/block/CastingTableSpecialRenderer.java @@ -18,7 +18,7 @@ public class CastingTableSpecialRenderer extends TileEntitySpecialRenderer @Override public void renderTileEntityAt (TileEntity logic, double var2, double var4, double var6, float var8) { - //System.out.println("Render!!!"); + //TConstruct.logger.info("Render!!!"); this.render((CastingTableLogic) logic, var2, var4, var6, var8); } diff --git a/src/tconstruct/client/block/DryingRackSpecialRender.java b/src/tconstruct/client/block/DryingRackSpecialRender.java index a971da60..da44b4e0 100644 --- a/src/tconstruct/client/block/DryingRackSpecialRender.java +++ b/src/tconstruct/client/block/DryingRackSpecialRender.java @@ -23,7 +23,7 @@ public class DryingRackSpecialRender extends TileEntitySpecialRenderer @Override public void renderTileEntityAt (TileEntity logic, double var2, double var4, double var6, float var8) { - //System.out.println("Render!!!"); + //TConstruct.logger.info("Render!!!"); this.render((DryingRackLogic) logic, var2, var4, var6, var8); } diff --git a/src/tconstruct/client/block/RenderLandmine.java b/src/tconstruct/client/block/RenderLandmine.java index 6a06627a..bf084466 100644 --- a/src/tconstruct/client/block/RenderLandmine.java +++ b/src/tconstruct/client/block/RenderLandmine.java @@ -56,7 +56,7 @@ public class RenderLandmine implements ISimpleBlockRenderingHandler ForgeDirection dir = Helper.convertMetaToForgeOrientation(i1); - //System.out.println(i1 + " for " + dir); + //TConstruct.logger.info(i1 + " for " + dir); switch (dir) { diff --git a/src/tconstruct/client/gui/CraftingStationGui.java b/src/tconstruct/client/gui/CraftingStationGui.java index 387e20e9..8ceb5120 100644 --- a/src/tconstruct/client/gui/CraftingStationGui.java +++ b/src/tconstruct/client/gui/CraftingStationGui.java @@ -18,7 +18,7 @@ public class CraftingStationGui extends GuiContainer /*public void onGuiClosed () { - System.out.println("Gui Closed"); + TConstruct.logger.info("Gui Closed"); super.onGuiClosed(); }*/ diff --git a/src/tconstruct/common/TContent.java b/src/tconstruct/common/TContent.java index 2bf3cb2e..d1fd3cfd 100644 --- a/src/tconstruct/common/TContent.java +++ b/src/tconstruct/common/TContent.java @@ -2068,7 +2068,7 @@ public class TContent implements IFuelHandler Object obj = getStaticItem("itemResource", "thaumcraft.common.config.ConfigItems"); if (obj != null) { - System.out.println("[TConstruct] Thaumcraft detected. Adding thaumium tools."); + TConstruct.logger.info("Thaumcraft detected. Adding thaumium tools."); thaumcraftAvailable = true; TConstructClientRegistry.addMaterialRenderMapping(31, "tinker", "thaumium", true); TConstructRegistry.addToolMaterial(31, "Thaumium", 3, 400, 700, 2, 1.3F, 0, 0f, "\u00A75", "Thaumic"); @@ -2085,7 +2085,7 @@ public class TContent implements IFuelHandler } else { - System.out.println("[TConstruct] Thaumcraft not detected."); + TConstruct.logger.warning("Thaumcraft not detected."); } if (Loader.isModLoaded("Natura")) @@ -2195,7 +2195,7 @@ public class TContent implements IFuelHandler } catch (Exception e) { - System.out.println("[TConstruct] Could not find " + name); + TConstruct.logger.warning("Could not find " + name); return null; } } diff --git a/src/tconstruct/common/TimeTicker.java b/src/tconstruct/common/TimeTicker.java index 9cf6967e..80515eaa 100644 --- a/src/tconstruct/common/TimeTicker.java +++ b/src/tconstruct/common/TimeTicker.java @@ -4,6 +4,7 @@ import java.util.EnumSet; import cpw.mods.fml.common.ITickHandler; import cpw.mods.fml.common.TickType; +import tconstruct.TConstruct; public class TimeTicker implements ITickHandler { @@ -15,7 +16,7 @@ public class TimeTicker implements ITickHandler @Override public void tickStart (EnumSet type, Object... tickData) { - System.out.println("Tick"); + TConstruct.logger.info("Tick"); time++; tickParts = (int) (time % 20); seconds = (int) (time / 20); diff --git a/src/tconstruct/entity/CartEntity.java b/src/tconstruct/entity/CartEntity.java index 871edca2..af9aca41 100644 --- a/src/tconstruct/entity/CartEntity.java +++ b/src/tconstruct/entity/CartEntity.java @@ -469,7 +469,7 @@ public class CartEntity extends Entity implements IInventory, IEntityAdditionalS void moveTowardsEntity (Entity entity) { - //System.out.println("Moving towards entity"); + //TConstruct.logger.info("Moving towards entity"); /*double distX = this.posX - entity.posX; double distZ = this.posZ - entity.posZ; //posY = posY + 0.1; diff --git a/src/tconstruct/entity/projectile/DaggerEntity.java b/src/tconstruct/entity/projectile/DaggerEntity.java index 439a8dcc..c5b24e6f 100644 --- a/src/tconstruct/entity/projectile/DaggerEntity.java +++ b/src/tconstruct/entity/projectile/DaggerEntity.java @@ -22,7 +22,7 @@ public class DaggerEntity extends RotatingBase public DaggerEntity(ItemStack itemstack, World world, EntityPlayer entityplayer) { super(world, entityplayer, 0.75F, 0.8F); - //System.out.println("Stack: "+itemstack); + //TConstruct.logger.info("Stack: "+itemstack); returnStackSlot = entityplayer.inventory.currentItem; returnStack = itemstack; } diff --git a/src/tconstruct/inventory/AdaptiveSmelteryContainer.java b/src/tconstruct/inventory/AdaptiveSmelteryContainer.java index b5c08fb0..db6dd467 100644 --- a/src/tconstruct/inventory/AdaptiveSmelteryContainer.java +++ b/src/tconstruct/inventory/AdaptiveSmelteryContainer.java @@ -55,7 +55,7 @@ public class AdaptiveSmelteryContainer extends ActiveContainer if (invRow != slotRow) { slotRow = invRow; - //System.out.println(invRow); + //TConstruct.logger.info(invRow); int basePos = invRow * 3; for (int iter = 0; iter < activeInventorySlots.size(); iter++) { @@ -135,7 +135,7 @@ public class AdaptiveSmelteryContainer extends ActiveContainer @Override protected boolean mergeItemStack (ItemStack inputStack, int startSlot, int endSlot, boolean flag) { - //System.out.println("Merge"); + //TConstruct.logger.info("Merge"); boolean merged = false; int slotPos = startSlot; @@ -149,7 +149,7 @@ public class AdaptiveSmelteryContainer extends ActiveContainer /*if (inputStack.isStackable() && startSlot >= logic.getSizeInventory()) { - System.out.println("Rawr!"); + TConstruct.logger.info("Rawr!"); while (inputStack.stackSize > 0 && (!flag && slotPos < endSlot || flag && slotPos >= startSlot)) { slot = (Slot) this.inventorySlots.get(slotPos); diff --git a/src/tconstruct/inventory/SmelteryContainer.java b/src/tconstruct/inventory/SmelteryContainer.java index d220e2b0..82b21661 100644 --- a/src/tconstruct/inventory/SmelteryContainer.java +++ b/src/tconstruct/inventory/SmelteryContainer.java @@ -49,7 +49,7 @@ public class SmelteryContainer extends ActiveContainer if (invRow != slotRow) { slotRow = invRow; - //System.out.println(invRow); + //TConstruct.logger.info(invRow); int basePos = invRow * 3; for (int iter = 0; iter < activeInventorySlots.size(); iter++) { @@ -166,7 +166,7 @@ public class SmelteryContainer extends ActiveContainer @Override protected boolean mergeItemStack (ItemStack inputStack, int startSlot, int endSlot, boolean flag) { - //System.out.println("Merge"); + //TConstruct.logger.info("Merge"); boolean merged = false; int slotPos = startSlot; @@ -180,7 +180,7 @@ public class SmelteryContainer extends ActiveContainer /*if (inputStack.isStackable() && startSlot >= logic.getSizeInventory()) { - System.out.println("Rawr!"); + TConstruct.logger.info("Rawr!"); while (inputStack.stackSize > 0 && (!flag && slotPos < endSlot || flag && slotPos >= startSlot)) { slot = (Slot) this.inventorySlots.get(slotPos); diff --git a/src/tconstruct/inventory/ToolStationContainer.java b/src/tconstruct/inventory/ToolStationContainer.java index 19c455f9..65c62030 100644 --- a/src/tconstruct/inventory/ToolStationContainer.java +++ b/src/tconstruct/inventory/ToolStationContainer.java @@ -231,7 +231,7 @@ public class ToolStationContainer extends ActiveContainer } /*boolean emptySlots = ( ((Slot) inventorySlots.get(2)).getStack() == null && ((Slot) inventorySlots.get(3)).getStack() == null ); - System.out.println("Empty slots"); + TConstruct.logger.info("Empty slots"); if (!failedToMerge && emptySlots) player.worldObj.playAuxSFX(1021, (int)player.posX, (int)player.posY, (int)player.posZ, 0);*/ diff --git a/src/tconstruct/items/tools/Arrow.java b/src/tconstruct/items/tools/Arrow.java index 27dea1d8..a3518826 100644 --- a/src/tconstruct/items/tools/Arrow.java +++ b/src/tconstruct/items/tools/Arrow.java @@ -2,6 +2,7 @@ package tconstruct.items.tools; import java.util.List; +import tconstruct.TConstruct; import tconstruct.common.TContent; import tconstruct.library.crafting.ToolBuilder; import tconstruct.library.tools.ToolCore; @@ -104,8 +105,8 @@ public class Arrow extends ToolCore ItemStack tool = ToolBuilder.instance.buildTool(new ItemStack(getHeadItem(), 1, 3), new ItemStack(getHandleItem(), 1, 0), accessoryStack, extraStack, ""); if (tool == null) { - System.out.println("Creative builder failed tool for Vanilla style" + this.getToolName()); - System.out.println("Make sure you do not have item ID conflicts"); + TConstruct.logger.warning("Creative builder failed tool for Vanilla style" + this.getToolName()); + TConstruct.logger.warning("Make sure you do not have item ID conflicts"); } else { @@ -124,8 +125,8 @@ public class Arrow extends ToolCore if (tool == null) { - System.out.println("Creative builder failed tool for Vanilla style" + this.getToolName()); - System.out.println("Make sure you do not have item ID conflicts"); + TConstruct.logger.warning("Creative builder failed tool for Vanilla style" + this.getToolName()); + TConstruct.logger.warning("Make sure you do not have item ID conflicts"); } else { @@ -146,8 +147,8 @@ public class Arrow extends ToolCore ItemStack tool = ToolBuilder.instance.buildTool(new ItemStack(getHeadItem(), 1, id), new ItemStack(getHandleItem(), 1, id), accessoryStack, extraStack, name + getToolName()); if (tool == null) { - System.out.println("Creative builder failed tool for " + name + this.getToolName()); - System.out.println("Make sure you do not have item ID conflicts"); + TConstruct.logger.warning("Creative builder failed tool for " + name + this.getToolName()); + TConstruct.logger.warning("Make sure you do not have item ID conflicts"); } else { diff --git a/src/tconstruct/items/tools/BowBase.java b/src/tconstruct/items/tools/BowBase.java index 3a08375d..ff1e8914 100644 --- a/src/tconstruct/items/tools/BowBase.java +++ b/src/tconstruct/items/tools/BowBase.java @@ -5,6 +5,7 @@ import java.util.Iterator; import java.util.List; import java.util.Map; +import tconstruct.TConstruct; import tconstruct.common.TContent; import tconstruct.entity.projectile.ArrowEntity; import tconstruct.library.crafting.ToolBuilder; @@ -770,8 +771,8 @@ public abstract class BowBase extends ToolCore ItemStack tool = ToolBuilder.instance.buildTool(new ItemStack(getHeadItem(), 1, id), new ItemStack(getHandleItem(), 1, 0), accessoryStack, extraStack, name + getToolName()); if (tool == null) { - System.out.println("Creative builder failed tool for " + name + this.getToolName()); - System.out.println("Make sure you do not have item ID conflicts"); + TConstruct.logger.warning("Creative builder failed tool for " + name + this.getToolName()); + TConstruct.logger.warning("Make sure you do not have item ID conflicts"); } else { diff --git a/src/tconstruct/items/tools/Mattock.java b/src/tconstruct/items/tools/Mattock.java index 3c1b3359..f6c4ed19 100644 --- a/src/tconstruct/items/tools/Mattock.java +++ b/src/tconstruct/items/tools/Mattock.java @@ -8,6 +8,7 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.world.World; +import tconstruct.TConstruct; import tconstruct.common.TContent; import tconstruct.library.crafting.ToolBuilder; import tconstruct.library.tools.AbilityHelper; @@ -119,8 +120,8 @@ public class Mattock extends DualHarvestTool ItemStack tool = ToolBuilder.instance.buildTool(new ItemStack(getHeadItem(), 1, id), new ItemStack(getHandleItem(), 1, id), accessoryStack, extraStack, name + getToolName()); if (tool == null) { - System.out.println("Creative builder failed tool for " + name + this.getToolName()); - System.out.println("Make sure you do not have item ID conflicts"); + TConstruct.logger.warning("Creative builder failed tool for " + name + this.getToolName()); + TConstruct.logger.warning("Make sure you do not have item ID conflicts"); } else { diff --git a/src/tconstruct/library/TConstructRegistry.java b/src/tconstruct/library/TConstructRegistry.java index 43228cac..12788f1f 100644 --- a/src/tconstruct/library/TConstructRegistry.java +++ b/src/tconstruct/library/TConstructRegistry.java @@ -5,6 +5,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; +import java.util.logging.Logger; import tconstruct.library.crafting.Detailing; import tconstruct.library.crafting.LiquidCasting; @@ -31,6 +32,8 @@ public class TConstructRegistry { public static TConstructRegistry instance = new TConstructRegistry(); + public static Logger logger = Logger.getLogger("TCon-API"); + /* Creative tabs */ public static TabTools toolTab; public static TabTools materialTab; @@ -67,7 +70,7 @@ public class TConstructRegistry { Item add = itemDirectory.get(name); if (add != null) - System.out.println("[TCon API] " + name + " is already present in the Item directory"); + logger.warning(name + " is already present in the Item directory"); itemDirectory.put(name, itemstack); } @@ -82,7 +85,7 @@ public class TConstructRegistry { Item ret = itemDirectory.get(name); if (ret == null) - System.out.println("[TCon API] Could not find " + name + " in the Item directory"); + logger.warning("Could not find " + name + " in the Item directory"); return ret; } @@ -113,7 +116,7 @@ public class TConstructRegistry { ItemStack add = itemstackDirectory.get(name); if (add != null) - System.out.println("[TCon API] " + name + " is already present in the ItemStack directory"); + logger.warning(name + " is already present in the ItemStack directory"); itemstackDirectory.put(name, itemstack); } @@ -128,7 +131,7 @@ public class TConstructRegistry { ItemStack ret = itemstackDirectory.get(name); if (ret == null) - System.out.println("[TCon API] Could not find " + name + " in the ItemStack directory"); + logger.warning("Could not find " + name + " in the ItemStack directory"); return ret; } @@ -197,7 +200,7 @@ public class TConstructRegistry { ToolBuilder tb = ToolBuilder.instance; if (parts.length < 1 || parts.length > 4 || parts.length == 3) - System.out.println("[TCon API] Wrong amount of items to craft into a tool"); + logger.warning("Wrong amount of items to craft into a tool"); tb.addToolRecipe(output, parts); } @@ -446,7 +449,7 @@ public class TConstructRegistry } catch (Exception e) { - System.out.println("[TCon API] Could not find casting table recipes."); + logger.warning("Could not find casting table recipes."); return null; } } @@ -467,7 +470,7 @@ public class TConstructRegistry } catch (Exception e) { - System.out.println("[TCon API] Could not find casting basin recipes."); + logger.warning("Could not find casting basin recipes."); return null; } } @@ -488,7 +491,7 @@ public class TConstructRegistry } catch (Exception e) { - System.out.println("[TCon API] Could not find chisel detailing recipes."); + logger.warning("Could not find chisel detailing recipes."); return null; } } diff --git a/src/tconstruct/library/component/TankLayerScan.java b/src/tconstruct/library/component/TankLayerScan.java index f1409843..094a5082 100644 --- a/src/tconstruct/library/component/TankLayerScan.java +++ b/src/tconstruct/library/component/TankLayerScan.java @@ -10,6 +10,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagIntArray; import net.minecraft.nbt.NBTTagList; import net.minecraft.tileentity.TileEntity; +import tconstruct.TConstruct; import tconstruct.common.TContent; import tconstruct.library.util.CoordTuple; import tconstruct.library.util.CoordTupleSort; @@ -108,7 +109,7 @@ public class TankLayerScan extends LogicComponent break; } if (!world.isRemote && debug) - System.out.println("Bricks in recursion: " + blockCoords.size()); + TConstruct.logger.info("Bricks in recursion: " + blockCoords.size()); blockCoords.clear(); bricks = 0; @@ -116,8 +117,8 @@ public class TankLayerScan extends LogicComponent boolean sealed = floodTest(master.xCoord + xPos, master.yCoord, master.zCoord + zPos); if (!world.isRemote && debug) { - System.out.println("Air in ring: " + airBlocks); - System.out.println("Bricks in ring: " + bricks); + TConstruct.logger.info("Air in ring: " + airBlocks); + TConstruct.logger.info("Bricks in ring: " + bricks); } if (sealed) @@ -135,8 +136,8 @@ public class TankLayerScan extends LogicComponent if (!world.isRemote && debug) { - System.out.println("Air in structure: " + airCoords.size()); - System.out.println("Bricks in structure: " + blockCoords.size()); + TConstruct.logger.info("Air in structure: " + airCoords.size()); + TConstruct.logger.info("Bricks in structure: " + blockCoords.size()); } } } diff --git a/src/tconstruct/library/crafting/ShapelessToolRecipe.java b/src/tconstruct/library/crafting/ShapelessToolRecipe.java index 114c7a12..40f8e41e 100644 --- a/src/tconstruct/library/crafting/ShapelessToolRecipe.java +++ b/src/tconstruct/library/crafting/ShapelessToolRecipe.java @@ -40,7 +40,7 @@ public class ShapelessToolRecipe extends ShapelessRecipes { ItemStack itemstack1 = (ItemStack) iterator.next(); - //System.out.println("Rawr! "+itemstack1.getItemDamage()); + //TConstruct.logger.info("Rawr! "+itemstack1.getItemDamage()); if (itemstack.itemID == itemstack1.itemID && (itemstack1.getItemDamage() == Short.MAX_VALUE || itemstack.getItemDamage() == itemstack1.getItemDamage())) { if (itemstack.getItem() instanceof ToolCore) diff --git a/src/tconstruct/library/crafting/ToolBuilder.java b/src/tconstruct/library/crafting/ToolBuilder.java index 30c9cf1a..3653af11 100644 --- a/src/tconstruct/library/crafting/ToolBuilder.java +++ b/src/tconstruct/library/crafting/ToolBuilder.java @@ -196,7 +196,7 @@ public class ToolBuilder } } - //System.out.println("Valid: "+item); + //TConstruct.logger.info("Valid: "+item); if (item == null) return null; diff --git a/src/tconstruct/library/tools/ToolCore.java b/src/tconstruct/library/tools/ToolCore.java index 3a5bfa32..7b688009 100644 --- a/src/tconstruct/library/tools/ToolCore.java +++ b/src/tconstruct/library/tools/ToolCore.java @@ -24,6 +24,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.Icon; import net.minecraft.world.World; import net.minecraftforge.event.entity.player.PlayerInteractEvent; +import tconstruct.TConstruct; import tconstruct.library.ActiveToolMod; import tconstruct.library.TConstructRegistry; import tconstruct.library.crafting.ToolBuilder; @@ -537,8 +538,8 @@ public abstract class ToolCore extends Item implements ICustomElectricItem, IBox ItemStack tool = ToolBuilder.instance.buildTool(new ItemStack(getHeadItem(), 1, id), new ItemStack(getHandleItem(), 1, id), accessoryStack, extraStack, name + getToolName()); if (tool == null) { - System.out.println("Creative builder failed tool for " + name + this.getToolName()); - System.out.println("Make sure you do not have item ID conflicts"); + TConstruct.logger.warning("Creative builder failed tool for " + name + this.getToolName()); + TConstruct.logger.warning("Make sure you do not have item ID conflicts"); } else { diff --git a/src/tconstruct/modifiers/ModBoolean.java b/src/tconstruct/modifiers/ModBoolean.java index 10b15272..cf8a22ed 100644 --- a/src/tconstruct/modifiers/ModBoolean.java +++ b/src/tconstruct/modifiers/ModBoolean.java @@ -31,7 +31,7 @@ public class ModBoolean extends ToolMod NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); tags.setBoolean(key, true); - //System.out.println("Key: "+key+" "+tags.getBoolean(key)); + //TConstruct.logger.info("Key: "+key+" "+tags.getBoolean(key)); int modifiers = tags.getInteger("Modifiers"); modifiers -= 1; diff --git a/src/tconstruct/modifiers/ModRepair.java b/src/tconstruct/modifiers/ModRepair.java index ff85de20..a89fc72a 100644 --- a/src/tconstruct/modifiers/ModRepair.java +++ b/src/tconstruct/modifiers/ModRepair.java @@ -60,7 +60,7 @@ public class ModRepair extends ToolMod materialValue = PatternBuilder.instance.getPartValue(input[1]); int increase = (int) (50 + (dur * 0.4f * materialValue)); - //System.out.println("Increase: "+increase); + //TConstruct.logger.info("Increase: "+increase); int modifiers = tags.getInteger("Modifiers"); float mods = 1.0f; diff --git a/src/tconstruct/util/TEventHandler.java b/src/tconstruct/util/TEventHandler.java index bd0d27e1..dd8f55a6 100644 --- a/src/tconstruct/util/TEventHandler.java +++ b/src/tconstruct/util/TEventHandler.java @@ -438,7 +438,7 @@ public class TEventHandler { if (event.entity instanceof EntityXPOrb) { - System.out.println("Entity: " + event.entity); + TConstruct.logger.info("Entity: " + event.entity); } }*/ diff --git a/src/tconstruct/util/config/BOPConfig.java b/src/tconstruct/util/config/BOPConfig.java index 69de3591..2abba5ab 100644 --- a/src/tconstruct/util/config/BOPConfig.java +++ b/src/tconstruct/util/config/BOPConfig.java @@ -3,6 +3,7 @@ package tconstruct.util.config; import java.io.File; import java.io.IOException; import net.minecraftforge.common.Configuration; +import tconstruct.TConstruct; public class BOPConfig { @@ -25,7 +26,7 @@ public class BOPConfig config.load(); promisedLandDimensionID = config.get("dimension settings", "Promised Land Dimension ID", -200).getInt(); - System.out.println("[TConstruct]PL Dim ID: " + promisedLandDimensionID); + TConstruct.logger.info("PL Dim ID: " + promisedLandDimensionID); } else { diff --git a/src/tconstruct/util/config/DimensionBlacklist.java b/src/tconstruct/util/config/DimensionBlacklist.java index 7f657c73..f8556174 100644 --- a/src/tconstruct/util/config/DimensionBlacklist.java +++ b/src/tconstruct/util/config/DimensionBlacklist.java @@ -42,7 +42,7 @@ public class DimensionBlacklist { if (blacklist.get(len) == dim) return false; - //System.out.println("[TConstruct]diminblist +" + blacklist.get(len)); + //TConstruct.logger.info("diminblist +" + blacklist.get(len)); } return true; @@ -53,7 +53,7 @@ public class DimensionBlacklist for (int len = 0; len < nopool.size(); len++) { if (nopool.get(len) == dim) - //System.out.println("[TConstruct]DimNoPool "+ nopool.get(len)); + //TConstruct.logger.info("DimNoPool "+ nopool.get(len)); return true; } return false; diff --git a/src/tconstruct/util/config/PHConstruct.java b/src/tconstruct/util/config/PHConstruct.java index 7f054c50..07ab3489 100644 --- a/src/tconstruct/util/config/PHConstruct.java +++ b/src/tconstruct/util/config/PHConstruct.java @@ -5,6 +5,7 @@ import java.io.IOException; import net.minecraftforge.common.Configuration; import net.minecraftforge.common.Property; +import tconstruct.TConstruct; import tconstruct.library.tools.AbilityHelper; public class PHConstruct @@ -29,8 +30,8 @@ public class PHConstruct } catch (IOException e) { - System.out.println("Could not create configuration file for TConstruct. Reason:"); - System.out.println(e); + TConstruct.logger.severe("Could not create configuration file for TConstruct. Reason:"); + TConstruct.logger.severe(e.getLocalizedMessage()); } /* [Forge] Configuration class, used as config method */ diff --git a/src/tconstruct/util/config/TwilightForestConfig.java b/src/tconstruct/util/config/TwilightForestConfig.java index 96a34351..0e446054 100644 --- a/src/tconstruct/util/config/TwilightForestConfig.java +++ b/src/tconstruct/util/config/TwilightForestConfig.java @@ -3,6 +3,7 @@ package tconstruct.util.config; import java.io.File; import java.io.IOException; import net.minecraftforge.common.Configuration; +import tconstruct.TConstruct; public class TwilightForestConfig { @@ -16,7 +17,7 @@ public class TwilightForestConfig config.load(); twilightForestDimensionID = config.get("dimension", "dimensionID", -100).getInt(); - System.out.println("[TConstruct]TF Dim ID: " + twilightForestDimensionID); + TConstruct.logger.info("TF Dim ID: " + twilightForestDimensionID); } else { diff --git a/src/tconstruct/util/network/TPacketHandler.java b/src/tconstruct/util/network/TPacketHandler.java index 970332ac..632e7b57 100644 --- a/src/tconstruct/util/network/TPacketHandler.java +++ b/src/tconstruct/util/network/TPacketHandler.java @@ -55,9 +55,8 @@ public class TPacketHandler implements IPacketHandler } catch (Exception e) { - System.out.println("Failed at reading client packet for TConstruct."); + TConstruct.logger.warning("Failed at reading client packet for TConstruct."); e.printStackTrace(); - return; } } @@ -187,9 +186,8 @@ public class TPacketHandler implements IPacketHandler } catch (IOException e) { - System.out.println("Failed at reading server packet for TConstruct."); + TConstruct.logger.warning("Failed at reading server packet for TConstruct."); e.printStackTrace(); - return; } } diff --git a/src/tconstruct/util/player/ArmorExtended.java b/src/tconstruct/util/player/ArmorExtended.java index 2d4df3fe..25fc848a 100644 --- a/src/tconstruct/util/player/ArmorExtended.java +++ b/src/tconstruct/util/player/ArmorExtended.java @@ -50,7 +50,7 @@ public class ArmorExtended implements IInventory { if (inventory[slot] != null) { - //System.out.println("Took something from slot " + slot); + //TConstruct.logger.info("Took something from slot " + slot); if (inventory[slot].stackSize <= quantity) { ItemStack stack = inventory[slot]; @@ -83,7 +83,7 @@ public class ArmorExtended implements IInventory public void setInventorySlotContents (int slot, ItemStack itemstack) { inventory[slot] = itemstack; - //System.out.println("Changed slot " + slot + " on side " + FMLCommonHandler.instance().getEffectiveSide()); + //TConstruct.logger.info("Changed slot " + slot + " on side " + FMLCommonHandler.instance().getEffectiveSide()); if (itemstack != null && itemstack.stackSize > getInventoryStackLimit()) { itemstack.stackSize = getInventoryStackLimit(); @@ -159,7 +159,7 @@ public class ArmorExtended implements IInventory { ItemStack stack = inventory[6]; int meta = stack.getItemDamage(); - //System.out.println("Calculating HP on side " + FMLCommonHandler.instance().getEffectiveSide()); + //TConstruct.logger.info("Calculating HP on side " + FMLCommonHandler.instance().getEffectiveSide()); if (meta == 2) { int prevHealth = stats.bonusHealth; @@ -173,7 +173,7 @@ public class ArmorExtended implements IInventory stats.bonusHealth = bonusHP; int healthChange = bonusHP - prevHealth; - //System.out.println("healthChange: "+healthChange+" on side "+FMLCommonHandler.instance().getEffectiveSide()); + //TConstruct.logger.info("healthChange: "+healthChange+" on side "+FMLCommonHandler.instance().getEffectiveSide()); if (healthChange != 0) { AttributeInstance attributeinstance = player.getAttributeMap().getAttributeInstance(SharedMonsterAttributes.maxHealth); diff --git a/src/tconstruct/util/player/ArmorExtendedClient.java b/src/tconstruct/util/player/ArmorExtendedClient.java index 9e9b95e6..be64876b 100644 --- a/src/tconstruct/util/player/ArmorExtendedClient.java +++ b/src/tconstruct/util/player/ArmorExtendedClient.java @@ -4,7 +4,7 @@ public class ArmorExtendedClient extends ArmorExtended { /*public void recalculateSkills(EntityPlayer player, TPlayerStats stats) { - System.out.println("Client skills"); + TConstruct.logger.info("Client skills"); if (inventory[1] != null && inventory[1].getItem() == TContent.glove) { if (TProxyClient.skillList.size() < 1) diff --git a/src/tconstruct/util/player/TPlayerHandler.java b/src/tconstruct/util/player/TPlayerHandler.java index d3f9f6ad..89bb5cce 100644 --- a/src/tconstruct/util/player/TPlayerHandler.java +++ b/src/tconstruct/util/player/TPlayerHandler.java @@ -33,7 +33,7 @@ public class TPlayerHandler implements IPlayerTracker @Override public void onPlayerLogin (EntityPlayer entityplayer) { - //System.out.println("Player: "+entityplayer); + //TConstruct.logger.info("Player: "+entityplayer); //Lookup player NBTTagCompound tags = entityplayer.getEntityData(); if (!tags.hasKey("TConstruct")) @@ -189,7 +189,7 @@ public class TPlayerHandler implements IPlayerTracker stats.prevOnGround = player.onGround; //if () - //System.out.println("Fall: "+player.fallDistance); + //TConstruct.logger.info("Fall: "+player.fallDistance); } } }*/ @@ -211,7 +211,7 @@ public class TPlayerHandler implements IPlayerTracker public TPlayerStats getPlayerStats (String username) { TPlayerStats stats = playerStats.get(username); - //System.out.println("Stats: "+stats); + //TConstruct.logger.info("Stats: "+stats); if (stats == null) { stats = new TPlayerStats(); @@ -243,7 +243,7 @@ public class TPlayerHandler implements IPlayerTracker public static void setEntitySize (float width, float height, Entity entity) { - //System.out.println("Size: " + height); + //TConstruct.logger.info("Size: " + height); if (width != entity.width || height != entity.height) { entity.width = width; diff --git a/src/tconstruct/worldgen/TBaseWorldGenerator.java b/src/tconstruct/worldgen/TBaseWorldGenerator.java index 23a3aed3..b6ff9a54 100644 --- a/src/tconstruct/worldgen/TBaseWorldGenerator.java +++ b/src/tconstruct/worldgen/TBaseWorldGenerator.java @@ -117,7 +117,7 @@ public class TBaseWorldGenerator implements IWorldGenerator if (yPos != -1) { /*CoordTuple coord = new CoordTuple(xPos, yPos, zPos); - System.out.println("Iron: "+coord.toString());*/ + TConstruct.logger.info("Iron: "+coord.toString());*/ ironBush.generate(world, random, xPos, yPos, zPos); } } @@ -133,7 +133,7 @@ public class TBaseWorldGenerator implements IWorldGenerator if (yPos != -1) { /*CoordTuple coord = new CoordTuple(xPos, yPos, zPos); - System.out.println("Gold: "+coord.toString());*/ + TConstruct.logger.info("Gold: "+coord.toString());*/ goldBush.generate(world, random, xPos, yPos, zPos); } } @@ -149,7 +149,7 @@ public class TBaseWorldGenerator implements IWorldGenerator if (yPos != -1) { /*CoordTuple coord = new CoordTuple(xPos, yPos, zPos); - System.out.println("Copper: "+coord.toString());*/ + TConstruct.logger.info("Copper: "+coord.toString());*/ copperBush.generate(world, random, xPos, yPos, zPos); } } @@ -165,7 +165,7 @@ public class TBaseWorldGenerator implements IWorldGenerator if (yPos != -1) { /*CoordTuple coord = new CoordTuple(xPos, yPos, zPos); - System.out.println("Tin: "+coord.toString());*/ + TConstruct.logger.info("Tin: "+coord.toString());*/ tinBush.generate(world, random, xPos, yPos, zPos); } } @@ -181,7 +181,7 @@ public class TBaseWorldGenerator implements IWorldGenerator if (yPos != -1) { /*CoordTuple coord = new CoordTuple(xPos, yPos, zPos); - System.out.println("Aluminum: "+coord.toString());*/ + TConstruct.logger.info("Aluminum: "+coord.toString());*/ aluminumBush.generate(world, random, xPos, yPos, zPos); } } @@ -197,7 +197,7 @@ public class TBaseWorldGenerator implements IWorldGenerator if (yPos != -1) { /*CoordTuple coord = new CoordTuple(xPos, yPos, zPos); - System.out.println("Silver: "+coord.toString());*/ + TConstruct.logger.info("Silver: "+coord.toString());*/ silverBush.generate(world, random, xPos, yPos, zPos); } } diff --git a/src/tconstruct/worldgen/village/ComponentSmeltery.java b/src/tconstruct/worldgen/village/ComponentSmeltery.java index ab2a6765..1dff0da0 100644 --- a/src/tconstruct/worldgen/village/ComponentSmeltery.java +++ b/src/tconstruct/worldgen/village/ComponentSmeltery.java @@ -3,6 +3,7 @@ package tconstruct.worldgen.village; import java.util.List; import java.util.Random; +import tconstruct.TConstruct; import tconstruct.common.TContent; import net.minecraft.block.Block; @@ -91,7 +92,7 @@ public class ComponentSmeltery extends ComponentVillage int remapDirection (int direction) { - System.out.println("Direction: " + direction); + TConstruct.logger.info("Direction: " + direction); switch (direction) { case 0: @@ -103,7 +104,7 @@ public class ComponentSmeltery extends ComponentVillage case 3: return 0; } - System.out.println("This shouldn't happen"); + TConstruct.logger.severe("This shouldn't happen (remapDirection in tconstruct.worldgen.village.ComponentSmeltery)"); return -1; } From 76513831e5448f60060d3bca298b4ad8c43ef94a Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Sat, 12 Oct 2013 23:49:36 +0100 Subject: [PATCH 08/26] Accidentally edited IC2 API. Reverted. --- src/ic2/api/item/Items.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/ic2/api/item/Items.java b/src/ic2/api/item/Items.java index f19ebc64..a7291ea4 100644 --- a/src/ic2/api/item/Items.java +++ b/src/ic2/api/item/Items.java @@ -1,7 +1,6 @@ package ic2.api.item; import net.minecraft.item.ItemStack; -import tconstruct.TConstruct; /** * Provides access to IC2 blocks and items. @@ -35,7 +34,7 @@ public final class Items { return null; } } catch (Exception e) { - TConstruct.logger.warning("IC2 API: Call getItem failed for " + name); + System.out.println("IC2 API: Call getItem failed for " + name); return null; } From 7a8c63d6473c1c3f9126ea4dcef8b5d5db4aedea Mon Sep 17 00:00:00 2001 From: Arthur Uzulin Date: Sun, 13 Oct 2013 13:22:39 +1100 Subject: [PATCH 09/26] Fixed a possible NPE in casting basins/tables --- src/tconstruct/client/block/SearedRender.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tconstruct/client/block/SearedRender.java b/src/tconstruct/client/block/SearedRender.java index 7c71e5dd..25025a40 100644 --- a/src/tconstruct/client/block/SearedRender.java +++ b/src/tconstruct/client/block/SearedRender.java @@ -173,7 +173,7 @@ public class SearedRender implements ISimpleBlockRenderingHandler ItemStack it = logic.getStackInSlot(0); if(it != null){ CastingRecipe rec = TConstruct.tableCasting.getCastingRecipe(logic.liquid, it); - if(rec != null){ + if(rec != null && rec.fluidRenderProperties != null){ minHeight = rec.fluidRenderProperties.minHeight; maxHeight = rec.fluidRenderProperties.maxHeight; @@ -388,7 +388,7 @@ public class SearedRender implements ISimpleBlockRenderingHandler ItemStack it = logic.getStackInSlot(0); if(it != null){ CastingRecipe rec = TConstruct.basinCasting.getCastingRecipe(logic.liquid, it); - if(rec != null){ + if(rec != null && rec.fluidRenderProperties != null){ minHeight = rec.fluidRenderProperties.minHeight; maxHeight = rec.fluidRenderProperties.maxHeight; From 55588400cef583947c77ed51cf97f88247b9087a Mon Sep 17 00:00:00 2001 From: Arthur Uzulin Date: Sun, 13 Oct 2013 13:55:45 +1100 Subject: [PATCH 10/26] Fixed crafting station-hopper dupe bug --- .../blocks/logic/CraftingStationLogic.java | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/tconstruct/blocks/logic/CraftingStationLogic.java b/src/tconstruct/blocks/logic/CraftingStationLogic.java index 194edac4..f4e6dc36 100644 --- a/src/tconstruct/blocks/logic/CraftingStationLogic.java +++ b/src/tconstruct/blocks/logic/CraftingStationLogic.java @@ -1,12 +1,16 @@ package tconstruct.blocks.logic; +import net.minecraft.item.ItemStack; + +import net.minecraft.inventory.ISidedInventory; + import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.Container; import net.minecraft.world.World; import tconstruct.inventory.CraftingStationContainer; import tconstruct.library.blocks.InventoryLogic; -public class CraftingStationLogic extends InventoryLogic +public class CraftingStationLogic extends InventoryLogic implements ISidedInventory { public CraftingStationLogic() { @@ -31,4 +35,19 @@ public class CraftingStationLogic extends InventoryLogic return false; return true; } + + @Override + public int[] getAccessibleSlotsFromSide(int var1) { + return new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}; + } + + @Override + public boolean canInsertItem(int i, ItemStack itemstack, int j) { + return i != 0; + } + + @Override + public boolean canExtractItem(int i, ItemStack itemstack, int j) { + return i != 0; + } } From 1c93a8fba70b56e1e907c0497e7b48f135a531e9 Mon Sep 17 00:00:00 2001 From: Progwml6 Date: Sat, 12 Oct 2013 23:31:08 -0400 Subject: [PATCH 11/26] remove random console spam logging --- src/tconstruct/blocks/logic/SmelteryDrainLogic.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/tconstruct/blocks/logic/SmelteryDrainLogic.java b/src/tconstruct/blocks/logic/SmelteryDrainLogic.java index 5bc810b4..a6ee2b38 100644 --- a/src/tconstruct/blocks/logic/SmelteryDrainLogic.java +++ b/src/tconstruct/blocks/logic/SmelteryDrainLogic.java @@ -29,7 +29,7 @@ public class SmelteryDrainLogic extends MultiServantLogic implements IFluidHandl @Override public boolean setPotentialMaster (IMasterLogic master, World world, int x, int y, int z) { - TConstruct.logger.info("Master: "+master); + // TConstruct.logger.info("Master: "+master); return (master instanceof AdaptiveSmelteryLogic || master instanceof SmelteryDrainLogic) && !hasMaster; } @@ -47,11 +47,11 @@ public class SmelteryDrainLogic extends MultiServantLogic implements IFluidHandl @Override public FluidStack drain (ForgeDirection from, int maxDrain, boolean doDrain) { - TConstruct.logger.info("Attempting drain " + hasValidMaster()); + // TConstruct.logger.info("Attempting drain " + hasValidMaster()); if (hasValidMaster() && canDrain(from, null)) { AdaptiveSmelteryLogic smeltery = (AdaptiveSmelteryLogic) worldObj.getBlockTileEntity(master.x, master.y, master.z); - TConstruct.logger.info("Found master"); + // TConstruct.logger.info("Found master"); return smeltery.drain(from, maxDrain, doDrain); } return null; From 741dd0a3b8972a598975787ee8c69edcb248024f Mon Sep 17 00:00:00 2001 From: Arthur Uzulin Date: Sun, 13 Oct 2013 15:11:28 +1100 Subject: [PATCH 12/26] Worked on the GUI of the advanced drawbridge --- .../textures/gui/drawbridgeAdvanced.png | Bin 2522 -> 2619 bytes .../blocks/logic/AdvancedDrawbridgeLogic.java | 13 +++- src/tconstruct/client/TProxyClient.java | 2 +- .../client/gui/AdvDrawbridgeGui.java | 31 ++++++++-- .../AdvancedDrawbridgeContainer.java | 58 +++++++++++++++--- 5 files changed, 86 insertions(+), 18 deletions(-) diff --git a/resources/assets/tinker/textures/gui/drawbridgeAdvanced.png b/resources/assets/tinker/textures/gui/drawbridgeAdvanced.png index 112899f415bbaac251e0d15dc677543a7b34b1e4..d146b1a9c41abec5160ab32e769018a12f25b318 100644 GIT binary patch delta 1990 zcmaKsdo-Kb8pd}%VIqPU5oBDxXghAvi#ff8ku+%MbgHGasJawG4PjK3q4Fh;OD9@2 zb(A(kTsoLi6xB7QqGsaSO4LxK4$)3&Y1QJm1vwwnnX}G6XYaNDdDmWR@8@}c?=!61 zNXpu(trqy@At#{R*o6Sv{xbGyv)ycU^`t$boWB5SB@9m>uxl{c$-* zIB038e%X-; zvYcmkG(Wko$v|>CQ@MaS8)^hW+(-J#?V_1Ldj6++5Cp`+Xk0w;5{)mi>Uz^Va^m(! zmxdAYZ0(EJIIPa;<%;6dKUUp6E2!Y~%?4^=FwB#`te)E0ub)aAOaE^)lmDyG`37fP#DtA`_pW&_`SycKkOioMxP49+X%f3cWMhU zlM3Kg$mQO0IpAJa2SmUHpmy9XV36rvlC>v;=i8tMq(uP=T5YxGvuY8Nkbv(KncEEw zkiY=BH?k=gY3N=^GIsOWXG zLf+_Fx^hwo;Bc2z#S6t(-iuNf87qonNNa2)Dw_O33+2(%3tzjXwlu}Iwo!l+1!DW~ zjZIA@SJjYu)%54AfRV5?z~!Yd4~utz!gk^pcTf-JNsuL31h^(FxF2min>k5=9`2>+ z0BH%EW9|Cpm=?+gl5>Gvi2)F5PjHx^dbMlWNmNu^EKE1(0&{sA#GF` zxUL$eb3fvBlp;$aKi~8}Y1n{4yt?xmfGeyKf!hH=Tk+IoEDD1=ASga7(82+=ZP#a> zXRL+Vss?-$vZJVc_}sJD$&q>kSw!7*{H{ej`VC#k#UEFDSjN7Y8LC5EFoFc+Aem$_ zwy7K%liiQX*WO9F(mFDdzcwgoQy}~8>||Z%0|YVa9;Z@_>z6eq1MN-H8yoEucZF9L zKg&OAcNI%QK99q6oT1m$y$I9Lx{=0h7$ZjG2yz1mn9-yjf~$DYkp}<<-~eoGqMD}p zw}=0dh3u;7Zh!!t6d`n8nDaDzH#6g}T>X8n>|R6uqI``LX_g0NIU}>m)e~t94YTLZVnspoPpw_6Sl-N=ojeFuSn8o1|RTv%5}==Ww(n5=r8k zVI?NZWp+neORhw?Fi;ueAH&%KYPYW&9E8y6_-&0JiQUi}Z~yKh5tWq3XOw>5(yT{K zsii43ABmAR4LUS*jG*wI#+^@0`~=0)_J)TtZIq-GRInY1w4R5ei|h3RHm%~qZ#f*l zMAKbToeoa%=rKViv)`2y9qGH5QqI2@Y5MaOEDf^7p$N*8dS4$NsXr(^A1CjgIM!?b zyE!OK4+yinSI#Qz{*48gDb$*M*UldQTrUsly2+Jsr4HCuxm?~QDXoVsHUWGa$pzd3 z7A*GRK_CIg^AM^Kfpi!4xXn88xhkwHi=V1`VCTB#Af7V=22JedZ*y0&|A8isc7MKV z_{ONBUJZxLUG-29@SD&TZpm765(ypfa}(9)rjnL8rdxh0fRGLK^NKK;&RK7Cre@x@ zu=OUYGVA(unE%$7re^M4=!<2r>5z?e*HFa38=Gc_$02pM4nhOKVEP9UJ4VV*W#Ypj z6RcUrxKLz!-)el+bEd($X*!+`9l(07-?s4lDV#R^>b7wFJerdIHAw$I3*Y@%q);f1 z`U6S~g7Z=da9vn-X|!BBau5)Drniy&9S|$!>Xh(*GEEQuE7SJKXmynTB<{F=0h?@ar%wmx4wwL)UST z7jleJi2P!UuJ-mr=K8kA7*bhTS&v$04H&#C*7c%q+qx2!YxBdePdn4?RSF5zlsAUF zjEs!sqFf>ua|iQSKj~+$)wv#tB%GmfD|Fp$thQ=w>TxP_x0S^e96Um`Y80OscAJ-FaoOKYRGwC* zZocwKD6hT@#CB=kS2>R3qUu6!ZXtRA)12xPAWa zT-60+NlEF;1iKLaArW(231-ogP0kipSoWpyfnVrM--q_Gwd#I?&orK}E? ze6@O?Jq&{!#srxRNFDOD)iY+IY3G~RYU{`Eyo4FZ(E!zffROyT+CVqtc~f?=rJoNq zd;Ce1$y?i0^t`tuVyP_8EQLS-4I7v1O4mJacV?%g$iy?pMbpSF8dIO^aY@sf$S5=d z8!ol;Uw5taI7LLd9IAIYvn_q_>mKZGF%^fWQI;jCm54j7rnRrUJd!O?wy z3jhoXO!A?J+NB#a8^cJm4K;vkfS1HxIMd$BQL9CwppuVnBafQ|;C74@ZErQ$qS@iM zthWmW?5!Wkp04ihrjP)BImH@ST3oaS%;L^XL4?`k=u_hnW%fuZ$XwWjYPsRlp$Z zxb4eLV-7v7=Mu%H--x=IBcqwaQ)&pjAQUwP<=VoNHOBN8fclIaCkdRD%hNf|7290j zm_qM;x5I#B4F{sO92{`VLgKL+R8*4p)XVW;kqq55MG1*oo`w2@H&I?5U z;SU_;)s1(U`WPX&fcmB6^jnv~p>OfOcOPps%RG}UU7Fe1@_YLcP$A!LfWvWL_qoEm z2)pT>8Y~+82N}>}ONYsG7ceN1tCH`CVrSFHSZi_$p#)+MmrL0QaNJsddg{oqUv9F8fA?#gWm#nLDv$0|MFs+f(G>#`O|TN8NtSo(!0cRRz4_;cA_OhOkKkPq_&;?uzZc?1IjKmZ7nZgotkm|l8C&*eon znSlQ9nM%8c^7~JcQB@HhVv^a#y?Ro)o7;boK&krjCPkv*PT02qK}V{ zIqR=wy$=%Tr;M#2(B!YWGh%09Y03H&4*U#sUz1PO4cGI9GFeJGhx6)vA0~)|9Q1Rz z5R{3M1k-c`WOePa6vw3;Q zvay;YX2VrkA97RPw+G@h@=TLE{A~IgFxF zU2HjEr0MwP?zY#_T_PibRr7~X@0Pzuelr^1D{vns!3Q7D(%CK4DFL_XfLhqgD zP`GlsbyKcLP>3T^3K3l*3JGlh4jkPR%2a;KVI<_&3ax!YnL%q3fVi_+n#Bn!-=E?g z;O_3ev!!5~P~qz4mP+4~g%@({t_q*o&<4=9gnwHX`MST^0HO)B;66e`M8q$K?R-Fr z(`R

*;)5p2p!EQif68Wcg5WDn2UK94v`=|QTp zdxqm93G0O$xy3x{M4^YSMIni(izRD`5&-idaNV)v#NVi!JLfe;(P4DX4TX3CWBjAO zeV-Mss&Tq_;S+LmbF;t7(NRZs*q_o_2FDTkWB4(OHIj22+}CSSnB-hL7@|sY*Sqe9 ozY&z!Y>EA(e`e7BIF!(d;`HLJ#ych#iq|&xdi(CK^< i1 = this.buttonList.iterator(); while(i1.hasNext()){ GuiButton b = i1.next(); @@ -90,6 +102,7 @@ public class AdvDrawbridgeGui extends GuiContainer b.drawButton = !flag; } } + ((AdvancedDrawbridgeContainer)this.inventorySlots).updateContainerSlots(); } protected void actionPerformed (GuiButton button) @@ -135,4 +148,10 @@ public class AdvDrawbridgeGui extends GuiContainer PacketDispatcher.sendPacketToServer(packet); } + + @Override + public void updateScreen(){ + super.updateScreen(); + this.containerNeglectMouse = false; + } } diff --git a/src/tconstruct/inventory/AdvancedDrawbridgeContainer.java b/src/tconstruct/inventory/AdvancedDrawbridgeContainer.java index 04b6efca..40af6fc7 100644 --- a/src/tconstruct/inventory/AdvancedDrawbridgeContainer.java +++ b/src/tconstruct/inventory/AdvancedDrawbridgeContainer.java @@ -1,11 +1,13 @@ package tconstruct.inventory; -import tconstruct.client.gui.AdvDrawbridgeGui; +import net.minecraft.entity.player.EntityPlayer; +import java.util.Iterator; import net.minecraft.entity.player.*; import net.minecraft.inventory.*; import net.minecraft.item.ItemStack; -import tconstruct.blocks.logic.*; +import tconstruct.blocks.logic.AdvancedDrawbridgeLogic; +import tconstruct.client.gui.AdvDrawbridgeGui; public class AdvancedDrawbridgeContainer extends Container { public AdvancedDrawbridgeLogic logic; @@ -26,7 +28,7 @@ public class AdvancedDrawbridgeContainer extends Container { public AdvancedDrawbridgeContainer(InventoryPlayer inventoryplayer, AdvancedDrawbridgeLogic logic, AdvDrawbridgeGui gui) { this.logic = logic; this.gui = gui; - + addContainerSlots(logic); bindPlayerInventory(inventoryplayer); updateContainerSlots(); @@ -46,9 +48,12 @@ public class AdvancedDrawbridgeContainer extends Container { public void addContainerSlots(AdvancedDrawbridgeLogic logic) { this.addSlotToContainer(new SlotOpaqueBlocksOnly(logic.camoInventory, 0, 35, 36)); - - for(int i = 0; i < logic.getSizeInventory(); i++){ - this.addSlotToContainer(new DrawbridgeSlot(logic, i, -2 + 18 * i, 40, logic)); + + for (int i = 0; i < logic.getSizeInventory(); i++) { + int ind = (int) (Math.floor(i / 8) * 8); + int x = i < 8 ? 10 + 20 * i : 10 + 20 * (i - 8); + int y = 35 + (int) Math.floor(i / 8) * 18 + (i < 8 ? 0 : 1); + this.addSlotToContainer(new DrawbridgeSlot(logic, i, x, y, logic)); } } @@ -85,8 +90,45 @@ public class AdvancedDrawbridgeContainer extends Container { } public void updateContainerSlots() { - if (gui == null || gui.isGuiExpanded) { - + if (gui == null) { + return; + } else if (gui.isGuiExpanded) { + Iterator i1 = inventorySlots.iterator(); + int index = 0; + while (i1.hasNext()) { + Slot sl = i1.next(); + if (index == 0) { + sl.xDisplayPosition = -1000; + sl.yDisplayPosition = -1000; + } else if (sl instanceof DrawbridgeSlot) { + sl.xDisplayPosition = (index - 1) < 8 ? 10 + 20 * (index - 1) : 10 + 20 * ((index - 1) - 8); + sl.yDisplayPosition = 35 + (int) Math.floor((index - 1) / 8) * 18 + ((index - 1) < 8 ? 0 : 1); + } + index++; + } + } else { + Iterator i1 = inventorySlots.iterator(); + int index = 0; + while (i1.hasNext()) { + Slot sl = i1.next(); + if (index == 0) { + sl.xDisplayPosition = 35; + sl.yDisplayPosition = 36; + } else if (sl instanceof DrawbridgeSlot) { + sl.xDisplayPosition = -1000; + sl.yDisplayPosition = -1000; + } + index++; + } + } + } + + @Override + public ItemStack slotClick(int par1, int par2, int par3, EntityPlayer par4EntityPlayer){ + if(gui != null && gui.containerNeglectMouse){ + return null; + }else{ + return super.slotClick(par1, par2, par3, par4EntityPlayer); } } } From 5043e1cf51307b37def883e8d7c73b56e0e8306e Mon Sep 17 00:00:00 2001 From: Vexatos Date: Sun, 13 Oct 2013 19:03:15 +0200 Subject: [PATCH 13/26] Added ladder. --- resources/assets/tinker/lang/de_DE.lang | 1 + 1 file changed, 1 insertion(+) diff --git a/resources/assets/tinker/lang/de_DE.lang b/resources/assets/tinker/lang/de_DE.lang index 7214e989..a0fc2694 100644 --- a/resources/assets/tinker/lang/de_DE.lang +++ b/resources/assets/tinker/lang/de_DE.lang @@ -238,6 +238,7 @@ StorageMetals.Steel.name=Stahlblock StorageMetals.Ender.name=Block Soliden Enders tile.decoration.stonetorch.name=Fackel +tile.decoration.stoneladder.name=Leiter tile.CraftingStation.name=Handwerksstation block.glass.pure.name=Klares Glas From beb19eb9b52f9087f38894abb49cacd6f6e57c44 Mon Sep 17 00:00:00 2001 From: TheVikingWarrior Date: Sun, 13 Oct 2013 21:02:42 +0200 Subject: [PATCH 14/26] Added Ladder --- resources/assets/tinker/lang/it_IT.lang | 1 + 1 file changed, 1 insertion(+) diff --git a/resources/assets/tinker/lang/it_IT.lang b/resources/assets/tinker/lang/it_IT.lang index 29e0b3e7..fc100a1a 100644 --- a/resources/assets/tinker/lang/it_IT.lang +++ b/resources/assets/tinker/lang/it_IT.lang @@ -238,6 +238,7 @@ StorageMetals.Steel.name=Blocco d'Acciaio StorageMetals.Ender.name=Blocco di Ender Solido tile.decoration.stonetorch.name=Torcia +tile.decoration.stoneladder.name=Scala a Pioli tile.CraftingStation.name=Tavolo da Lavoro block.glass.pure.name=Vetro Chiaro From 4d8f94ac2fe4db38a9324c286c8876be613dd8d4 Mon Sep 17 00:00:00 2001 From: Progwml6 Date: Mon, 14 Oct 2013 00:20:56 -0400 Subject: [PATCH 15/26] allow access to smelterycomponent via adaptivesmeltery logic, and add in some stuff necessary to fixing gui restored fuel section of the gui to full function, partial function to the fluid section --- .../blocks/component/SmelteryComponent.java | 8 ++++++ .../blocks/logic/AdaptiveSmelteryLogic.java | 11 +++++--- .../client/gui/AdaptiveSmelteryGui.java | 26 +++++++++++-------- 3 files changed, 31 insertions(+), 14 deletions(-) diff --git a/src/tconstruct/blocks/component/SmelteryComponent.java b/src/tconstruct/blocks/component/SmelteryComponent.java index 572b7460..6d4005bf 100644 --- a/src/tconstruct/blocks/component/SmelteryComponent.java +++ b/src/tconstruct/blocks/component/SmelteryComponent.java @@ -246,6 +246,14 @@ public class SmelteryComponent extends LogicComponent return meltingTemps[slot]; } + public int getScaledFuelGague (int scale) + { + int ret = (fuelGague * scale) / 52; + if (ret < 1) + ret = 1; + return ret; + } + /* NBT */ public void readNetworkNBT (NBTTagCompound tags) { diff --git a/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java b/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java index dd88c003..9436180d 100644 --- a/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java +++ b/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java @@ -46,6 +46,11 @@ public class AdaptiveSmelteryLogic extends AdaptiveInventoryLogic implements IAc int tick = 0; + public SmelteryComponent getSmeltery () + { + return smeltery; + } + public void updateEntity () { tick++; @@ -234,8 +239,8 @@ public class AdaptiveSmelteryLogic extends AdaptiveInventoryLogic implements IAc { return null; } - } - + } + @Override public void onInventoryChanged () { @@ -424,7 +429,7 @@ public class AdaptiveSmelteryLogic extends AdaptiveInventoryLogic implements IAc { return "crafters.Smeltery"; } - + /* Fluids */ @Override diff --git a/src/tconstruct/client/gui/AdaptiveSmelteryGui.java b/src/tconstruct/client/gui/AdaptiveSmelteryGui.java index ade6f8bf..fa0e862c 100644 --- a/src/tconstruct/client/gui/AdaptiveSmelteryGui.java +++ b/src/tconstruct/client/gui/AdaptiveSmelteryGui.java @@ -4,8 +4,10 @@ import java.util.ArrayList; import java.util.Iterator; import java.util.List; +import net.minecraft.block.Block; import net.minecraft.client.renderer.RenderHelper; import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.texture.TextureMap; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.Icon; @@ -21,6 +23,7 @@ import org.lwjgl.input.Mouse; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL12; +import tconstruct.blocks.component.SmelteryComponent; import tconstruct.blocks.logic.AdaptiveSmelteryLogic; import tconstruct.inventory.ActiveContainer; import tconstruct.inventory.AdaptiveSmelteryContainer; @@ -34,14 +37,15 @@ public class AdaptiveSmelteryGui extends NewContainerGui float currentScroll = 0.0F; int slotPos = 0; int prevSlotPos = 0; - + private SmelteryComponent scomp; public AdaptiveSmelteryGui(InventoryPlayer inventoryplayer, AdaptiveSmelteryLogic smeltery, World world, int x, int y, int z) { super((ActiveContainer) smeltery.getGuiContainer(inventoryplayer, world, x, y, z)); logic = smeltery; username = inventoryplayer.player.username; xSize = 248; - //smeltery.updateFuelDisplay(); + scomp = logic.getSmeltery(); + scomp.update(); } public void drawScreen (int mouseX, int mouseY, float par3) @@ -144,17 +148,17 @@ public class AdaptiveSmelteryGui extends NewContainerGui } } - /*if (logic.fuelGague > 0) + if (scomp.fuelGague > 0) { int leftX = cornerX + 117; - int topY = (cornerY + 68) - logic.getScaledFuelGague(52); + int topY = (cornerY + 68) - scomp.getScaledFuelGague(52); int sizeX = 12; - int sizeY = logic.getScaledFuelGague(52); + int sizeY = scomp.getScaledFuelGague(52); if (mouseX >= leftX && mouseX <= leftX + sizeX && mouseY >= topY && mouseY < topY + sizeY) { - drawFluidStackTooltip(new FluidStack(-37, logic.fuelAmount), mouseX - cornerX + 36, mouseY - cornerY); + drawFluidStackTooltip(new FluidStack(-37, scomp.fuelAmount), mouseX - cornerX + 36, mouseY - cornerY); } - }*/ + } } private static final ResourceLocation background = new ResourceLocation("tinker", "textures/gui/smeltery.png"); @@ -170,11 +174,11 @@ public class AdaptiveSmelteryGui extends NewContainerGui drawTexturedModalRect(cornerX + 46, cornerY, 0, 0, 176, ySize); //Fuel - Lava - /*this.mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture); - if (logic.fuelGague > 0) + this.mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture); + if (scomp.fuelGague > 0) { Icon lavaIcon = Block.lavaStill.getIcon(0, 0); - int fuel = logic.getScaledFuelGague(52); + int fuel = scomp.getScaledFuelGague(52); int count = 0; while (fuel > 0) { @@ -183,7 +187,7 @@ public class AdaptiveSmelteryGui extends NewContainerGui drawLiquidRect(cornerX + 117, (cornerY + 68) - size - 16 * count, lavaIcon, 12, size); count++; } - }*/ + } FluidTankInfo[] info = logic.getTankInfo(ForgeDirection.UNKNOWN); int capacity = 0; From 1db06b4e5068b2057871b0c39a03a51089cd17e6 Mon Sep 17 00:00:00 2001 From: Progwml6 Date: Mon, 14 Oct 2013 01:37:40 -0400 Subject: [PATCH 16/26] more fixes --- .../blocks/logic/AdaptiveSmelteryLogic.java | 5 +++++ src/tconstruct/client/gui/AdaptiveSmelteryGui.java | 14 +++++++++++--- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java b/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java index 9436180d..688f3d65 100644 --- a/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java +++ b/src/tconstruct/blocks/logic/AdaptiveSmelteryLogic.java @@ -46,6 +46,11 @@ public class AdaptiveSmelteryLogic extends AdaptiveInventoryLogic implements IAc int tick = 0; + public MultiFluidTank getMultiTank () + { + return multitank; + } + public SmelteryComponent getSmeltery () { return smeltery; diff --git a/src/tconstruct/client/gui/AdaptiveSmelteryGui.java b/src/tconstruct/client/gui/AdaptiveSmelteryGui.java index fa0e862c..4cd0fb89 100644 --- a/src/tconstruct/client/gui/AdaptiveSmelteryGui.java +++ b/src/tconstruct/client/gui/AdaptiveSmelteryGui.java @@ -1,5 +1,7 @@ package tconstruct.client.gui; +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; import java.util.ArrayList; import java.util.Iterator; import java.util.List; @@ -9,6 +11,7 @@ import net.minecraft.client.renderer.RenderHelper; import net.minecraft.client.renderer.Tessellator; import net.minecraft.client.renderer.texture.TextureMap; import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.network.packet.Packet250CustomPayload; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.Icon; import net.minecraft.util.ResourceLocation; @@ -23,10 +26,12 @@ import org.lwjgl.input.Mouse; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL12; +import cpw.mods.fml.common.network.PacketDispatcher; import tconstruct.blocks.component.SmelteryComponent; import tconstruct.blocks.logic.AdaptiveSmelteryLogic; import tconstruct.inventory.ActiveContainer; import tconstruct.inventory.AdaptiveSmelteryContainer; +import tconstruct.library.component.MultiFluidTank; public class AdaptiveSmelteryGui extends NewContainerGui { @@ -38,6 +43,7 @@ public class AdaptiveSmelteryGui extends NewContainerGui int slotPos = 0; int prevSlotPos = 0; private SmelteryComponent scomp; + private MultiFluidTank multitank; public AdaptiveSmelteryGui(InventoryPlayer inventoryplayer, AdaptiveSmelteryLogic smeltery, World world, int x, int y, int z) { super((ActiveContainer) smeltery.getGuiContainer(inventoryplayer, world, x, y, z)); @@ -45,7 +51,9 @@ public class AdaptiveSmelteryGui extends NewContainerGui username = inventoryplayer.player.username; xSize = 248; scomp = logic.getSmeltery(); + multitank = logic.getMultiTank(); scomp.update(); + } public void drawScreen (int mouseX, int mouseY, float par3) @@ -444,14 +452,14 @@ public class AdaptiveSmelteryGui extends NewContainerGui int cornerY = (height - ySize) / 2; int fluidToBeBroughtUp = -1; - for (FluidStack liquid : logic.moltenMetal) + for (FluidStack liquid : multitank.getAllFluids()) { int basePos = 54; int initialLiquidSize = 0; int liquidSize = 0;//liquid.amount * 52 / liquidLayers; - if (logic.getCapacity() > 0) + if (multitank.getCapacity() > 0) { - int total = logic.getTotalLiquid(); + int total = multitank.getFluidAmount(); int liquidLayers = (total / 20000 + 1) * 20000; if (liquidLayers > 0) { From caa7bb9c5bf988070cf4c48ba4f0e255d4a94d55 Mon Sep 17 00:00:00 2001 From: Arthur Uzulin Date: Mon, 14 Oct 2013 20:41:14 +1100 Subject: [PATCH 17/26] Add pattern/cast names to en_US.lang --- resources/assets/tinker/lang/en_US.lang | 57 ++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 2 deletions(-) diff --git a/resources/assets/tinker/lang/en_US.lang b/resources/assets/tinker/lang/en_US.lang index 8653e9d6..23d8916b 100644 --- a/resources/assets/tinker/lang/en_US.lang +++ b/resources/assets/tinker/lang/en_US.lang @@ -146,7 +146,60 @@ item.InfiTool.PotionLauncher.name=Potion Launcher item.InfiTool.Mattock.name=Mattock item.tconstruct.Pattern.blank_pattern.name=Blank Pattern +item.tconstruct.Pattern.rod.name=Tool Rod Pattern +item.tconstruct.Pattern.pickaxe.name=Pickaxe Head Pattern +item.tconstruct.Pattern.shovel.name=Shovel Head Pattern +item.tconstruct.Pattern.axe.name=Axe Head Pattern +item.tconstruct.Pattern.swordblade.name=Sword Blade Pattern +item.tconstruct.Pattern.largeguard.name=Wide Guard Pattern +item.tconstruct.Pattern.mediumguard.name=Hand Guard Pattern +item.tconstruct.Pattern.crossbar.name=Crossbar Pattern +item.tconstruct.Pattern.binding.name=Tool Binding Pattern +item.tconstruct.Pattern.frypan.name=Pan Pattern +item.tconstruct.Pattern.sign.name=Wide Board Pattern +item.tconstruct.Pattern.knifeblade.name=Knife Blade Pattern +item.tconstruct.Pattern.chisel.name=Chisel Head Pattern +item.tconstruct.Pattern.largerod.name=Tough Rod Pattern +item.tconstruct.Pattern.toughbinding.name=Tough Binding Pattern +item.tconstruct.Pattern.largeplate.name=Large Plate Pattern +item.tconstruct.Pattern.broadaxe.name=Broadaxe Head Pattern +item.tconstruct.Pattern.scythe.name=Scythe Head Pattern +item.tconstruct.Pattern.excavator.name=Excavator Head Pattern +item.tconstruct.Pattern.largeblade.name=Large Blade Pattern +item.tconstruct.Pattern.hammerhead.name=Hammer Head Pattern +item.tconstruct.Pattern.fullguard.name=Full Guard Pattern +item.tconstruct.Pattern.bowstring.name=Bowstring Pattern +item.tconstruct.Pattern.fletching.name=Fletching Pattern +item.tconstruct.Pattern.arrowhead.name=Arrowhead Pattern + item.tconstruct.Pattern.blank_cast.name=Blank Cast +item.tconstruct.MetalPattern.rod.name=Tool Rod Cast +item.tconstruct.MetalPattern.pickaxe.name=Pickaxe Head Cast +item.tconstruct.MetalPattern.shovel.name=Shovel Head Cast +item.tconstruct.MetalPattern.axe.name=Axe Head Cast +item.tconstruct.MetalPattern.swordblade.name=Sword Blade Cast +item.tconstruct.MetalPattern.largeguard.name=Wide Guard Cast +item.tconstruct.MetalPattern.mediumguard.name=Hand Guard Cast +item.tconstruct.MetalPattern.crossbar.name=Crossbar Cast +item.tconstruct.MetalPattern.binding.name=Tool Binding Cast +item.tconstruct.MetalPattern.frypan.name=Pan Cast +item.tconstruct.MetalPattern.sign.name=Wide Board Cast +item.tconstruct.MetalPattern.knifeblade.name=Knife Blade Cast +item.tconstruct.MetalPattern.chisel.name=Chisel Head Cast +item.tconstruct.MetalPattern.largerod.name=Tough Rod Cast +item.tconstruct.MetalPattern.toughbinding.name=Tough Binding Cast +item.tconstruct.MetalPattern.largeplate.name=Large Plate Cast +item.tconstruct.MetalPattern.broadaxe.name=Broadaxe Head Cast +item.tconstruct.MetalPattern.scythe.name=Scythe Head Cast +item.tconstruct.MetalPattern.excavator.name=Excavator Head Cast +item.tconstruct.MetalPattern.largeblade.name=Large Blade Cast +item.tconstruct.MetalPattern.hammerhead.name=Hammer Head Cast +item.tconstruct.MetalPattern.fullguard.name=Full Guard Cast +item.tconstruct.MetalPattern.bowstring.name=Bowstring Cast +item.tconstruct.MetalPattern.fletching.name=Fletching Cast +item.tconstruct.MetalPattern.arrowhead.name=Arrowhead Cast +item.tconstruct.MetalPattern.ingot.name=Ingot Cast + item.tconstruct.Materials.PaperStack.name=Paper Stack item.tconstruct.Materials.SlimeCrystal.name=Slime Crystal @@ -457,8 +510,8 @@ toolpart.ToughBind=Tough Binding toolpart.ToughRod=Tough Rod toolpart.LargePlate=Large Plate toolpart.SwordBlade=Sword Blade -toolpart.LargeGuard=Large Guard -toolpart.MediumGuard=Medium Guard +toolpart.LargeGuard=Wide Guard +toolpart.MediumGuard=Hand Guard toolpart.Crossbar=Crossbar toolpart.KnifeBlade=Knife Blade toolpart.FullGuard=Full Guard From c677fa0c461d2692899f9ca381ca1965a933a7c5 Mon Sep 17 00:00:00 2001 From: Vexatos Date: Mon, 14 Oct 2013 12:44:39 +0200 Subject: [PATCH 18/26] Update de_DE.lang --- resources/assets/tinker/lang/de_DE.lang | 64 ++++++++++++++++++++++--- 1 file changed, 58 insertions(+), 6 deletions(-) diff --git a/resources/assets/tinker/lang/de_DE.lang b/resources/assets/tinker/lang/de_DE.lang index a0fc2694..e7bdc046 100644 --- a/resources/assets/tinker/lang/de_DE.lang +++ b/resources/assets/tinker/lang/de_DE.lang @@ -146,7 +146,59 @@ item.InfiTool.PotionLauncher.name=Trankwerfer item.InfiTool.Mattock.name=Breithacke item.tconstruct.Pattern.blank_pattern.name=Leere Schablone +item.tconstruct.Pattern.rod.name=Werkzeuggriffsschablone +item.tconstruct.Pattern.pickaxe.name=Spitzhackenkopfschablone +item.tconstruct.Pattern.shovel.name=Schaufelkopfschablone +item.tconstruct.Pattern.axe.name=Axtkopfschablone +item.tconstruct.Pattern.swordblade.name=Schwertklingenschablone +item.tconstruct.Pattern.largeguard.name=Breite Schützerschablone +item.tconstruct.Pattern.mediumguard.name=Handschützerschablone +item.tconstruct.Pattern.crossbar.name=Querstangenschablone +item.tconstruct.Pattern.binding.name=Wekzeugbindungsschablone +item.tconstruct.Pattern.frypan.name=Pfannenschablone +item.tconstruct.Pattern.sign.name=Große Schildbrettschablone +item.tconstruct.Pattern.knifeblade.name=Messerklingenschablone +item.tconstruct.Pattern.chisel.name=Meißelkopfschablone +item.tconstruct.Pattern.largerod.name=Robuste Griffschablone +item.tconstruct.Pattern.toughbinding.name=Robuste Bindungsschablone +item.tconstruct.Pattern.largeplate.name=Große Plattenschablone +item.tconstruct.Pattern.broadaxe.name=Breitaxtkopfschablone +item.tconstruct.Pattern.scythe.name=Sensenkopfschablone +item.tconstruct.Pattern.excavator.name=Exkavatorkopfschablone +item.tconstruct.Pattern.largeblade.name=Große Klingenschablone +item.tconstruct.Pattern.hammerhead.name=Hammerkopfschablone +item.tconstruct.Pattern.fullguard.name=Volle Schützerschablone +item.tconstruct.Pattern.bowstring.name=Bogensehnenschablone +item.tconstruct.Pattern.fletching.name=Befiederungsschablone +item.tconstruct.Pattern.arrowhead.name=Pfeilspitzenschablone + item.tconstruct.Pattern.blank_cast.name=Leere Gussform +item.tconstruct.MetalPattern.rod.name=Werkzeuggriffsgussform +item.tconstruct.MetalPattern.pickaxe.name=Spitzhackenkopfgussform +item.tconstruct.MetalPattern.shovel.name=Schaufelkopfgussform +item.tconstruct.MetalPattern.axe.name=Axtkopfgussform +item.tconstruct.MetalPattern.swordblade.name=Schwertklingengussform +item.tconstruct.MetalPattern.largeguard.name=Breite Schützergussform +item.tconstruct.MetalPattern.mediumguard.name=Handschützergussform +item.tconstruct.MetalPattern.crossbar.name=Querstangengussform +item.tconstruct.MetalPattern.binding.name=Wekzeugbindungsgussform +item.tconstruct.MetalPattern.frypan.name=Pfannengussform +item.tconstruct.MetalPattern.sign.name=Große Schildbrettgussform +item.tconstruct.MetalPattern.knifeblade.name=Messerklingengussform +item.tconstruct.MetalPattern.chisel.name=Meißelkopfgussform +item.tconstruct.MetalPattern.largerod.name=Robuste Griffgussform +item.tconstruct.MetalPattern.toughbinding.name=Robuste Bindungsgussform +item.tconstruct.MetalPattern.largeplate.name=Große Plattengussform +item.tconstruct.MetalPattern.broadaxe.name=Breitaxtkopfgussform +item.tconstruct.MetalPattern.scythe.name=Sensenkopfgussform +item.tconstruct.MetalPattern.excavator.name=Exkavatorkopfgussform +item.tconstruct.MetalPattern.largeblade.name=Große Klingengussform +item.tconstruct.MetalPattern.hammerhead.name=Hammerkopfgussform +item.tconstruct.MetalPattern.fullguard.name=Volle Schützergussform +item.tconstruct.MetalPattern.bowstring.name=Bogensehnengussform +item.tconstruct.MetalPattern.fletching.name=Befiederungsgussform +item.tconstruct.MetalPattern.arrowhead.name=Pfeilspitzengussform +item.tconstruct.MetalPattern.ingot.name=Barrengussform item.tconstruct.Materials.PaperStack.name=Papierstapel item.tconstruct.Materials.SlimeCrystal.name=Schleimkristall @@ -452,21 +504,21 @@ toolpart.ToolRod=Werkzeuggriff toolpart.PickHead=Spitzhackenkopf toolpart.ShovelHead=Schaufelkopf toolpart.AxeHead=Axtkopf -toolpart.Binding=Verbindung -toolpart.ToughBind=Robuste Verbindung +toolpart.Binding=Wekzeugbindung +toolpart.ToughBind=Robuste Bindung toolpart.ToughRod=Robuster Griff toolpart.LargePlate=Große Platte toolpart.SwordBlade=Swertklinge -toolpart.LargeGuard=Großer Schützer -toolpart.MediumGuard=Mittelgroßer Schützer +toolpart.LargeGuard=Breiter Schützer +toolpart.MediumGuard=Handschützer toolpart.Crossbar=Querstange toolpart.KnifeBlade=Messerklinge toolpart.FullGuard=Voller Schützer toolpart.FrypanHead=Pfanne -toolpart.SignHead=Schildkopf +toolpart.SignHead=Schildbrett toolpart.ChiselHead=Meißelkopf toolpart.ScytheHead=Sensenkopf -toolpart.LumberHead=Breitschwertkopf +toolpart.LumberHead=Breitaxtkopf toolpart.ExcavatorHead=Exkavatorkopf toolpart.ToolShard=Scherbe toolpart.LargeSwordBlade=Große Schwerklinge From b78348e4fcb2609423e74a74e4646610b48ff6a3 Mon Sep 17 00:00:00 2001 From: Vexatos Date: Mon, 14 Oct 2013 12:44:52 +0200 Subject: [PATCH 19/26] Update en_US.lang --- resources/assets/tinker/lang/en_US.lang | 1 - 1 file changed, 1 deletion(-) diff --git a/resources/assets/tinker/lang/en_US.lang b/resources/assets/tinker/lang/en_US.lang index 23d8916b..b835f192 100644 --- a/resources/assets/tinker/lang/en_US.lang +++ b/resources/assets/tinker/lang/en_US.lang @@ -200,7 +200,6 @@ item.tconstruct.MetalPattern.fletching.name=Fletching Cast item.tconstruct.MetalPattern.arrowhead.name=Arrowhead Cast item.tconstruct.MetalPattern.ingot.name=Ingot Cast - item.tconstruct.Materials.PaperStack.name=Paper Stack item.tconstruct.Materials.SlimeCrystal.name=Slime Crystal item.tconstruct.Materials.SearedBrick.name=Seared Brick From e25d97ff097a68312e21cab5c738ab32fbb24bcf Mon Sep 17 00:00:00 2001 From: TheVikingWarrior Date: Mon, 14 Oct 2013 21:27:50 +0200 Subject: [PATCH 20/26] Update it_IT.lang --- resources/assets/tinker/lang/it_IT.lang | 52 +++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/resources/assets/tinker/lang/it_IT.lang b/resources/assets/tinker/lang/it_IT.lang index fc100a1a..748bc0fa 100644 --- a/resources/assets/tinker/lang/it_IT.lang +++ b/resources/assets/tinker/lang/it_IT.lang @@ -146,7 +146,59 @@ item.InfiTool.PotionLauncher.name=Lanciatore di Pozzioni item.InfiTool.Mattock.name=Zappa item.tconstruct.Pattern.blank_pattern.name=Modello +item.tconstruct.Pattern.rod.name=Modello per Manico +item.tconstruct.Pattern.pickaxe.name=Modello per Testa di Piccone +item.tconstruct.Pattern.shovel.name=Modello per Testa di Pala +item.tconstruct.Pattern.axe.name=Modello per Testa d'Ascia +item.tconstruct.Pattern.swordblade.name=Modello per Lama di Spada +item.tconstruct.Pattern.largeguard.name=Modello per Guardia Larga +item.tconstruct.Pattern.mediumguard.name=Modello per Guardia Media +item.tconstruct.Pattern.crossbar.name=Modello per Guardia Traversa +item.tconstruct.Pattern.binding.name=Modello per Legatura +item.tconstruct.Pattern.frypan.name=Modello per Padella +item.tconstruct.Pattern.sign.name=Modello per Testa di Cartello +item.tconstruct.Pattern.knifeblade.name=Modello per Lama di Coltello +item.tconstruct.Pattern.chisel.name=Modello per Testa di Cesellatore +item.tconstruct.Pattern.largerod.name=Modello per Manico Resistente +item.tconstruct.Pattern.toughbinding.name=Modello per Legatura Resistente +item.tconstruct.Pattern.largeplate.name=Modello per Piastra Grande +item.tconstruct.Pattern.broadaxe.name=Modello per Testa d'Ascia Larga +item.tconstruct.Pattern.scythe.name=Modello per Testa di Falce +item.tconstruct.Pattern.excavator.name=Modello per Testa di Scavatore +item.tconstruct.Pattern.largeblade.name=Modello per Grande Lama di Spada +item.tconstruct.Pattern.hammerhead.name=Modello per Testa di Martello +item.tconstruct.Pattern.fullguard.name=Modello per Guardia Piena +item.tconstruct.Pattern.bowstring.name=Modello per Corda d'Arco +item.tconstruct.Pattern.fletching.name=Modello per Testa di Freccia +item.tconstruct.Pattern.arrowhead.name=Modello per Impennaggio + item.tconstruct.Pattern.blank_cast.name=Stampo +item.tconstruct.MetalPattern.rod.name=Stampo per Manico +item.tconstruct.MetalPattern.pickaxe.name=Stampo per Testa di Piccone +item.tconstruct.MetalPattern.shovel.name=Stampo per Testa di Pala +item.tconstruct.MetalPattern.axe.name=Stampo per Testa d'Ascia +item.tconstruct.MetalPattern.swordblade.name=Stampo per Lama di Spada +item.tconstruct.MetalPattern.largeguard.name=Stampo per Guardia Larga +item.tconstruct.MetalPattern.mediumguard.name=Stampo per Guardia Media +item.tconstruct.MetalPattern.crossbar.name=Stampo per Guardia Traversa +item.tconstruct.MetalPattern.binding.name=Stampo per Legatura +item.tconstruct.MetalPattern.frypan.name=Stampo per Padella +item.tconstruct.MetalPattern.sign.name=Stampo per Testa di Cartello +item.tconstruct.MetalPattern.knifeblade.name=Stampo per Lama di Coltello +item.tconstruct.MetalPattern.chisel.name=Stampo per Testa di Cesellatore +item.tconstruct.MetalPattern.largerod.name=Stampo per Manico Resistente +item.tconstruct.MetalPattern.toughbinding.name=Stampo per Legatura Resistente +item.tconstruct.MetalPattern.largeplate.name=Stampo per Piastra Grande +item.tconstruct.MetalPattern.broadaxe.name=Stampo per Testa d'Ascia Larga +item.tconstruct.MetalPattern.scythe.name=Stampo per Testa di Falce +item.tconstruct.MetalPattern.excavator.name=Stampo per Testa di Scavatore +item.tconstruct.MetalPattern.largeblade.name=Stampo per Grande Lama di Spada +item.tconstruct.MetalPattern.hammerhead.name=Stampo per Testa di Martello +item.tconstruct.MetalPattern.fullguard.name=Stampo per Guardia Piena +item.tconstruct.MetalPattern.bowstring.name=Stampo per Corda d'Arco +item.tconstruct.MetalPattern.fletching.name=Stampo per Testa di Freccia +item.tconstruct.MetalPattern.arrowhead.name=Stampo per Impennaggio +item.tconstruct.MetalPattern.ingot.name=Stampo per Lingotti item.tconstruct.Materials.PaperStack.name=Pila di Carta item.tconstruct.Materials.SlimeCrystal.name=Cristallo di Slime From b0f0a12ae9f4eab1bd8dc0945ef71b050780097f Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Tue, 15 Oct 2013 21:14:23 +0100 Subject: [PATCH 21/26] Reduce max recursion count. (Hopefully) closes #248. --- src/tconstruct/library/component/TankLayerScan.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/tconstruct/library/component/TankLayerScan.java b/src/tconstruct/library/component/TankLayerScan.java index 094a5082..6a776f26 100644 --- a/src/tconstruct/library/component/TankLayerScan.java +++ b/src/tconstruct/library/component/TankLayerScan.java @@ -11,7 +11,6 @@ import net.minecraft.nbt.NBTTagIntArray; import net.minecraft.nbt.NBTTagList; import net.minecraft.tileentity.TileEntity; import tconstruct.TConstruct; -import tconstruct.common.TContent; import tconstruct.library.util.CoordTuple; import tconstruct.library.util.CoordTupleSort; import tconstruct.library.util.IFacingLogic; @@ -37,7 +36,8 @@ public class TankLayerScan extends LogicComponent protected ArrayList validAirCoords = new ArrayList(); protected CoordTuple returnStone; - private boolean debug = false; + private static boolean debug = false; + private static final int MAX_LAYER_RECURSION_DEPTH = 3500; public TankLayerScan(TileEntity te, Block... ids) { @@ -256,7 +256,7 @@ public class TankLayerScan extends LogicComponent protected boolean floodTest (int x, int y, int z) { - if (airBlocks > 4000) + if (airBlocks > MAX_LAYER_RECURSION_DEPTH) return false; for (int[] offset : validAirCoords) From aa810a2aa1807a1482adfb41e5e05d6aae2ca974 Mon Sep 17 00:00:00 2001 From: Arthur Uzulin Date: Wed, 16 Oct 2013 17:37:33 +1100 Subject: [PATCH 22/26] Improved tool part localization --- resources/assets/tinker/lang/en_US.lang | 52 ++++++++++++------------- src/tconstruct/items/ToolPart.java | 11 +++++- 2 files changed, 35 insertions(+), 28 deletions(-) diff --git a/resources/assets/tinker/lang/en_US.lang b/resources/assets/tinker/lang/en_US.lang index b835f192..b5d26810 100644 --- a/resources/assets/tinker/lang/en_US.lang +++ b/resources/assets/tinker/lang/en_US.lang @@ -500,32 +500,32 @@ parttype.steel=Steel parttype.blueslime=Slime parttype.thaumium=Thaumium -toolpart.ToolRod=Tool Rod -toolpart.PickHead=Pickaxe Head -toolpart.ShovelHead=Shovel Head -toolpart.AxeHead=Axe Head -toolpart.Binding=Binding -toolpart.ToughBind=Tough Binding -toolpart.ToughRod=Tough Rod -toolpart.LargePlate=Large Plate -toolpart.SwordBlade=Sword Blade -toolpart.LargeGuard=Wide Guard -toolpart.MediumGuard=Hand Guard -toolpart.Crossbar=Crossbar -toolpart.KnifeBlade=Knife Blade -toolpart.FullGuard=Full Guard -toolpart.FrypanHead=Pan -toolpart.SignHead=Sign Head -toolpart.ChiselHead=Chisel Head -toolpart.ScytheHead=Scythe Head -toolpart.LumberHead=Broad Axe Head -toolpart.ExcavatorHead=Excavator Head -toolpart.ToolShard=Shard -toolpart.LargeSwordBlade=Large Sword Blade -toolpart.HammerHead=Hammer Head -toolpart.Bowstring=Bowstring -toolpart.ArrowHead=Arrowhead -toolpart.Fletching=Fletching +toolpart.ToolRod=%%material Tool Rod +toolpart.PickHead=%%material Pickaxe Head +toolpart.ShovelHead=%%material Shovel Head +toolpart.AxeHead=%%material Axe Head +toolpart.Binding=%%material Binding +toolpart.ToughBind=%%material Tough Binding +toolpart.ToughRod=%%material Tough Rod +toolpart.LargePlate=%%material Large Plate +toolpart.SwordBlade=%%material Sword Blade +toolpart.LargeGuard=%%material Wide Guard +toolpart.MediumGuard=%%material Hand Guard +toolpart.Crossbar=%%material Crossbar +toolpart.KnifeBlade=%%material Knife Blade +toolpart.FullGuard=%%material Full Guard +toolpart.FrypanHead=%%material Pan +toolpart.SignHead=%%material Sign Head +toolpart.ChiselHead=%%material Chisel Head +toolpart.ScytheHead=%%material Scythe Head +toolpart.LumberHead=%%material Broad Axe Head +toolpart.ExcavatorHead=%%material Excavator Head +toolpart.ToolShard=%%material Shard +toolpart.LargeSwordBlade=%%material Large Sword Blade +toolpart.HammerHead=%%material Hammer Head +toolpart.Bowstring=%%material Bowstring +toolpart.ArrowHead=%%material Arrowhead +toolpart.Fletching=%%material Fletching fluid.iron.molten=Molten Iron fluid.gold.molten=Molten Gold diff --git a/src/tconstruct/items/ToolPart.java b/src/tconstruct/items/ToolPart.java index 81798fe1..8a9b84eb 100644 --- a/src/tconstruct/items/ToolPart.java +++ b/src/tconstruct/items/ToolPart.java @@ -24,10 +24,17 @@ public class ToolPart extends CraftingItem implements IToolPart @Override public String getItemDisplayName (ItemStack par1ItemStack) { - StringBuilder builder = new StringBuilder(); + String material = StatCollector.translateToLocal("parttype." + toolTextureNames[par1ItemStack.getItemDamage()]); + String name = StatCollector.translateToLocal("toolpart." + partName); + name = name.replaceAll("%%material", material); + + return name; + + /*StringBuilder builder = new StringBuilder(); builder.append(StatCollector.translateToLocal("parttype." + toolTextureNames[par1ItemStack.getItemDamage()])).append(" ").append(StatCollector.translateToLocal("toolpart." + partName)); return builder.toString(); - /*String s = ("" + StatCollector.translateToLocal("toolpart."+partName)).trim(); + -- + String s = ("" + StatCollector.translateToLocal("toolpart."+partName)).trim(); String s1 = toolMaterialNames[par1ItemStack.getItemDamage()]; if (s1 != null) From 0bc48375abaf4e0d0a9389869dd2352b380003d3 Mon Sep 17 00:00:00 2001 From: TheVikingWarrior Date: Wed, 16 Oct 2013 19:00:53 +0200 Subject: [PATCH 23/26] Update it_IT.lang --- resources/assets/tinker/lang/it_IT.lang | 52 ++++++++++++------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/resources/assets/tinker/lang/it_IT.lang b/resources/assets/tinker/lang/it_IT.lang index 748bc0fa..b9913c6f 100644 --- a/resources/assets/tinker/lang/it_IT.lang +++ b/resources/assets/tinker/lang/it_IT.lang @@ -500,32 +500,32 @@ parttype.steel=d'Acciaio parttype.blueslime=di Slime parttype.thaumium=di Taumium -toolpart.ToolRod=Manico -toolpart.PickHead=Testa di Piccone -toolpart.ShovelHead=Testa di Pala -toolpart.AxeHead=Testa d'Ascia -toolpart.Binding=Legatura -toolpart.ToughBind=Legatura Resistente -toolpart.ToughRod=Manico Resistente -toolpart.LargePlate=Piastra Grande -toolpart.SwordBlade=Lama di Spada -toolpart.LargeGuard=Guardia Larga -toolpart.MediumGuard=Guardia Media -toolpart.Crossbar=Guardia Traversa -toolpart.KnifeBlade=Lama di Coltello -toolpart.FullGuard=Guardia Piena -toolpart.FrypanHead=Padella -toolpart.SignHead=Testa di Cartello -toolpart.ChiselHead=Testa di Cesellatore -toolpart.ScytheHead=Testa di Falce -toolpart.LumberHead=Testa d'Ascia Larga -toolpart.ExcavatorHead=Testa di Scavatore -toolpart.ToolShard=Frammento -toolpart.LargeSwordBlade=Grande Lama di Spada -toolpart.HammerHead=Testa di Martello -toolpart.Bowstring=Corda d'Arco -toolpart.ArrowHead=Testa di Freccia -toolpart.Fletching=Impennaggio +toolpart.ToolRod=Manico %%material +toolpart.PickHead=Testa di Piccone %%material +toolpart.ShovelHead=Testa di Pala %%material +toolpart.AxeHead=Testa d'Ascia %%material +toolpart.Binding=Legatura %%material +toolpart.ToughBind=Legatura Resistente %%material +toolpart.ToughRod=Manico Resistente %%material +toolpart.LargePlate=Piastra Grande %%material +toolpart.SwordBlade=Lama di Spada %%material +toolpart.LargeGuard=Guardia Larga %%material +toolpart.MediumGuard=Guardia Media %%material +toolpart.Crossbar=Guardia Traversa %%material +toolpart.KnifeBlade=Lama di Coltello %%material +toolpart.FullGuard=Guardia Piena %%material +toolpart.FrypanHead=Padella %%material +toolpart.SignHead=Testa di Cartello %%material +toolpart.ChiselHead=Testa di Cesellatore %%material +toolpart.ScytheHead=Testa di Falce %%material +toolpart.LumberHead=Testa d'Ascia Larga %%material +toolpart.ExcavatorHead=Testa di Scavatore %%material +toolpart.ToolShard=Frammento %%material +toolpart.LargeSwordBlade=Grande Lama di Spada %%material +toolpart.HammerHead=Testa di Martello %%material +toolpart.Bowstring=Corda d'Arco %%material +toolpart.ArrowHead=Testa di Freccia %%material +toolpart.Fletching=Impennaggio%%material fluid.iron.molten=Ferro Fuso fluid.gold.molten=Oro Fuso From b387a954da4be7117d8c9ca09f2085afc765f491 Mon Sep 17 00:00:00 2001 From: Vexatos Date: Thu, 17 Oct 2013 19:38:02 +0200 Subject: [PATCH 24/26] Updated German Translation. Thank you, @fuj1n. --- resources/assets/tinker/lang/de_DE.lang | 90 ++++++++++++------------- 1 file changed, 45 insertions(+), 45 deletions(-) diff --git a/resources/assets/tinker/lang/de_DE.lang b/resources/assets/tinker/lang/de_DE.lang index e7bdc046..4c5916e8 100644 --- a/resources/assets/tinker/lang/de_DE.lang +++ b/resources/assets/tinker/lang/de_DE.lang @@ -480,52 +480,52 @@ death.two.smeltery=%1$s ist mit der Schmelzerei eins geworden death.three.smeltery=%1$s wird ein Meilenstein für unsere Revolution sein! death.four.smeltery=%1$s dachte, das Schwimmen in heißen Flüssigkeiten wäre eine ntry> -parttype.wood=Holz - -parttype.stone=Stein - -parttype.iron=Eisen - -parttype.flint=Feuterstein - -parttype.cactus=Kaktus - -parttype.bone=Knochen - -parttype.obsidian=Obsidian - -parttype.slime=Schleim - -parttype.paper=Papier - -parttype.netherrack=Netherstein - -parttype.cobalt=Cobalt - -parttype.ardite=Ardit - -parttype.manyullyn=Manyullyn - -parttype.copper=Kupfer - -parttype.bronze=Bronze - -parttype.alumite=Alumit - -parttype.steel=Stahl - -parttype.blueslime=Schleim - -parttype.thaumium=Thaumium - +parttype.wood=Holz +parttype.stone=Stein +parttype.iron=Eisen +parttype.flint=Feuterstein +parttype.cactus=Kaktus +parttype.bone=Knochen +parttype.obsidian=Obsidian +parttype.slime=Schleim +parttype.paper=Papier +parttype.netherrack=Netherstein +parttype.cobalt=Cobalt +parttype.ardite=Ardit +parttype.manyullyn=Manyullyn +parttype.copper=Kupfer +parttype.bronze=Bronze +parttype.alumite=Alumit +parttype.steel=Stahl +parttype.blueslime=Schleim +parttype.thaumium=Thaumium -toolpart.ToolRod=Werkzeuggriff -toolpart.PickHead=Spitzhackenkopf -toolpart.ShovelHead=Schaufelkopf -toolpart.AxeHead=Axtkopf -toolpart.Binding=Wekzeugbindung -toolpart.ToughBind=Robuste Bindung -toolpart.ToughRod=Robuster Griff -toolpart.LargePlate=Große Platte -toolpart.SwordBlade=Swertklinge -toolpart.LargeGuard=Breiter Schützer -toolpart.MediumGuard=Handschützer -toolpart.Crossbar=Querstange -toolpart.KnifeBlade=Messerklinge -toolpart.FullGuard=Voller Schützer -toolpart.FrypanHead=Pfanne -toolpart.SignHead=Schildbrett -toolpart.ChiselHead=Meißelkopf -toolpart.ScytheHead=Sensenkopf -toolpart.LumberHead=Breitaxtkopf -toolpart.ExcavatorHead=Exkavatorkopf -toolpart.ToolShard=Scherbe -toolpart.LargeSwordBlade=Große Schwerklinge -toolpart.HammerHead=Hammerkopf -toolpart.Bowstring=Bogensehne -toolpart.ArrowHead=Pfeilspitze -toolpart.Fletching=Befiederung +toolpart.ToolRod=%%material-Werkzeuggriff +toolpart.PickHead=%%material-Spitzhackenkopf +toolpart.ShovelHead=%%material-Schaufelkopf +toolpart.AxeHead=%%material-Axtkopf +toolpart.Binding=%%material-Wekzeugbindung +toolpart.ToughBind=Robuste %%materialbindung +toolpart.ToughRod=Robuster %%materialgriff +toolpart.LargePlate=Große %%materialplatte +toolpart.SwordBlade=%%material-Schwertklinge +toolpart.LargeGuard=Breiter %%materialschützer +toolpart.MediumGuard=%%material-Handschützer +toolpart.Crossbar=%%material-Querstange +toolpart.KnifeBlade=%%material-Messerklinge +toolpart.FullGuard=Voller %%materialschützer +toolpart.FrypanHead=%%material-Pfanne +toolpart.SignHead=%%material-Schildbrett +toolpart.ChiselHead=%%material-Meißelkopf +toolpart.ScytheHead=%%material-Sensenkopf +toolpart.LumberHead=%%material-Breitaxtkopf +toolpart.ExcavatorHead=%%material-Exkavatorkopf +toolpart.ToolShard=%%materialscherbe +toolpart.LargeSwordBlade=Große %%materialschwertklinge +toolpart.HammerHead=%%material-Hammerkopf +toolpart.Bowstring=%%materialbogensehne +toolpart.ArrowHead=%%materialpfeilspitze +toolpart.Fletching=%%materialbefiederung fluid.iron.molten=Geschmolzenes Eisen fluid.gold.molten=Geschmolzenes Gold From 1b2dda831674857816de2dec925c929214a569ba Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Thu, 17 Oct 2013 20:54:27 +0100 Subject: [PATCH 25/26] Fix 32-bit crapness in TankLayerScan. --- src/tconstruct/library/component/TankLayerScan.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/tconstruct/library/component/TankLayerScan.java b/src/tconstruct/library/component/TankLayerScan.java index 6a776f26..02d03901 100644 --- a/src/tconstruct/library/component/TankLayerScan.java +++ b/src/tconstruct/library/component/TankLayerScan.java @@ -10,6 +10,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagIntArray; import net.minecraft.nbt.NBTTagList; import net.minecraft.tileentity.TileEntity; +import scala.compat.Platform$; import tconstruct.TConstruct; import tconstruct.library.util.CoordTuple; import tconstruct.library.util.CoordTupleSort; @@ -37,7 +38,7 @@ public class TankLayerScan extends LogicComponent protected CoordTuple returnStone; private static boolean debug = false; - private static final int MAX_LAYER_RECURSION_DEPTH = 3500; + private static int MAX_LAYER_RECURSION_DEPTH = System.getProperty("os.arch").equals("amd64") ? 4000 : 2000; // Recursion causes overflows on 32-bit, so reduce if not 64-bit public TankLayerScan(TileEntity te, Block... ids) { @@ -50,6 +51,7 @@ public class TankLayerScan extends LogicComponent validAirCoords.add(new int[] { -1, 0 }); validAirCoords.add(new int[] { 0, 1 }); validAirCoords.add(new int[] { 0, -1 }); + //TConstruct.logger.info("Using recursion size " + MAX_LAYER_RECURSION_DEPTH + " on JVM arch " + System.getProperty("os.arch")); } public void checkValidStructure () From 7a991571bec2b5c2ad434797f4cad5466cd30cd3 Mon Sep 17 00:00:00 2001 From: Sunstrike Date: Fri, 18 Oct 2013 12:30:38 +0100 Subject: [PATCH 26/26] Don't crash when Seared items are put in the new smeltery... --- src/tconstruct/client/block/SearedRender.java | 371 +++++++++--------- 1 file changed, 188 insertions(+), 183 deletions(-) diff --git a/src/tconstruct/client/block/SearedRender.java b/src/tconstruct/client/block/SearedRender.java index 25025a40..d09c9890 100644 --- a/src/tconstruct/client/block/SearedRender.java +++ b/src/tconstruct/client/block/SearedRender.java @@ -159,156 +159,159 @@ public class SearedRender implements ISimpleBlockRenderingHandler renderer.setRenderBounds(0.6875, 0.0F, 0.6875, 1.0F, 0.625F, 1.0F); renderer.renderStandardBlock(block, x, y, z); - CastingTableLogic logic = (CastingTableLogic) world.getBlockTileEntity(x, y, z); - if (logic.liquid != null) - { - float minHeight = 0.9375F; - float maxHeight = 1F; - - float minX = 0.0625F; - float maxX = 0.9375F; - float minZ = 0.0625F; - float maxZ = 0.9375F; - - ItemStack it = logic.getStackInSlot(0); - if(it != null){ - CastingRecipe rec = TConstruct.tableCasting.getCastingRecipe(logic.liquid, it); - if(rec != null && rec.fluidRenderProperties != null){ - minHeight = rec.fluidRenderProperties.minHeight; - maxHeight = rec.fluidRenderProperties.maxHeight; - - minX = rec.fluidRenderProperties.minX; - maxX = rec.fluidRenderProperties.maxX; - minZ = rec.fluidRenderProperties.minZ; - maxZ = rec.fluidRenderProperties.maxZ; - } - } - - float height = logic.getLiquidAmount() / (logic.getCapacity() * 1.03F) / 16F; - renderer.setRenderBounds(minX, minHeight, minZ, maxX, minHeight + height, maxZ); + if (world.getBlockTileEntity(x, y, z) instanceof CastingTableLogic) { + CastingTableLogic logic = (CastingTableLogic) world.getBlockTileEntity(x, y, z); + if (logic.liquid != null) + { + float minHeight = 0.9375F; + float maxHeight = 1F; - Fluid fluid = logic.liquid.getFluid(); - BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world); - /*if (logic.liquid.fluidID < 4096) //Block - { - Block liquidBlock = Block.blocksList[logic.liquid.fluidID]; - if (liquidBlock != null) + float minX = 0.0625F; + float maxX = 0.9375F; + float minZ = 0.0625F; + float maxZ = 0.9375F; + + ItemStack it = logic.getStackInSlot(0); + if(it != null){ + CastingRecipe rec = TConstruct.tableCasting.getCastingRecipe(logic.liquid, it); + if(rec != null && rec.fluidRenderProperties != null){ + minHeight = rec.fluidRenderProperties.minHeight; + maxHeight = rec.fluidRenderProperties.maxHeight; + + minX = rec.fluidRenderProperties.minX; + maxX = rec.fluidRenderProperties.maxX; + minZ = rec.fluidRenderProperties.minZ; + maxZ = rec.fluidRenderProperties.maxZ; + } + } + + float height = logic.getLiquidAmount() / (logic.getCapacity() * 1.03F) / 16F; + renderer.setRenderBounds(minX, minHeight, minZ, maxX, minHeight + height, maxZ); + + Fluid fluid = logic.liquid.getFluid(); + BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world); + /*if (logic.liquid.fluidID < 4096) //Block { - //ForgeHooksClient.bindTexture(liquidBlock.getTextureFile(), 0); - BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, 0, x, y, z, renderer, world); + Block liquidBlock = Block.blocksList[logic.liquid.fluidID]; + if (liquidBlock != null) + { + //ForgeHooksClient.bindTexture(liquidBlock.getTextureFile(), 0); + BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, 0, x, y, z, renderer, world); + } } + else + //Item + { + Item liquidItem = Item.itemsList[logic.liquid.fluidID]; + if (liquidItem != null) + { + //ForgeHooksClient.bindTexture(liquidItem.getTextureFile(), 0); + BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(0), x, y, z, renderer, world); + } + }*/ } - else - //Item - { - Item liquidItem = Item.itemsList[logic.liquid.fluidID]; - if (liquidItem != null) - { - //ForgeHooksClient.bindTexture(liquidItem.getTextureFile(), 0); - BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(0), x, y, z, renderer, world); - } - }*/ } } else if (metadata == 1) { - FaucetLogic logic = (FaucetLogic) world.getBlockTileEntity(x, y, z); - float xMin = 0.375F, zMin = 0.375F, xMax = 0.625F, zMax = 0.625F; - switch (logic.getRenderDirection()) - { - case 2: - renderer.setRenderBounds(0.25, 0.25, 0.625, 0.75, 0.375, 1); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.25, 0.375, 0.625, 0.375, 0.625, 1); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.625, 0.375, 0.625, 0.75, 0.625, 1); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.375, 0.375, 0.625, 0.625, 0.625, 1); - zMin = 0.5F; - //zMin = 0.625F; - break; - case 3: - renderer.setRenderBounds(0.25, 0.25, 0, 0.75, 0.375, 0.375); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.25, 0.375, 0, 0.375, 0.625, 0.375); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.625, 0.375, 0, 0.75, 0.625, 0.375); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.375, 0.375, 0, 0.625, 0.625, 0.375); - zMax = 0.5F; - break; - case 4: - renderer.setRenderBounds(0.625, 0.25, 0.25, 1, 0.375, 0.75); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.625, 0.375, 0.25, 1, 0.625, 0.375); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.625, 0.375, 0.625, 1, 0.625, 0.75); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0.625, 0.375, 0.375, 1, 0.625, 0.625); - xMin = 0.5F; - break; - case 5: - renderer.setRenderBounds(0, 0.25, 0.25, 0.375, 0.375, 0.75); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0, 0.375, 0.25, 0.375, 0.625, 0.375); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0, 0.375, 0.625, 0.375, 0.625, 0.75); - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBounds(0, 0.375, 0.375, 0.375, 0.625, 0.625); - xMax = 0.5F; - break; - } - - float yMin = 0F; - int uID = world.getBlockId(x, y - 1, z); - int uMeta = world.getBlockMetadata(x, y - 1, z); - if (uID == TContent.searedBlock.blockID && uMeta == 0) - { - yMin = -0.125F; - } - else if (uID == TContent.searedBlock.blockID && uMeta == 2) - { - yMin = -0.75F; - } - else if (uID == TContent.lavaTank.blockID) - { - yMin = -1F; - } - else if (uID == TContent.castingChannel.blockID) - { - yMin = -0.5F; - } - - if (logic.liquid != null) - { - Fluid fluid = logic.liquid.getFluid(); - renderer.setRenderBounds(xMin, yMin, zMin, xMax, 0.625, zMax); - BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world); - /*if (fluid.canBePlacedInWorld()) + if (world.getBlockTileEntity(x, y, z) instanceof FaucetLogic) { + FaucetLogic logic = (FaucetLogic) world.getBlockTileEntity(x, y, z); + float xMin = 0.375F, zMin = 0.375F, xMax = 0.625F, zMax = 0.625F; + switch (logic.getRenderDirection()) { - Block liquidBlock = Block.blocksList[blockToRender.itemID]; - BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, 0, x, y, z, renderer, world); - renderer.setRenderBounds(xMin, yMin, zMin, xMax, 0.625, zMax); - BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, 0, x, y, z, renderer, world); - }*/ - /*ItemStack blockToRender = new ItemStack(logic.liquid.fluidID, 1, logic.liquid.itemMeta); - if (blockToRender.itemID < 4096) //Block - { - + case 2: + renderer.setRenderBounds(0.25, 0.25, 0.625, 0.75, 0.375, 1); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.25, 0.375, 0.625, 0.375, 0.625, 1); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625, 0.375, 0.625, 0.75, 0.625, 1); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375, 0.375, 0.625, 0.625, 0.625, 1); + zMin = 0.5F; + //zMin = 0.625F; + break; + case 3: + renderer.setRenderBounds(0.25, 0.25, 0, 0.75, 0.375, 0.375); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.25, 0.375, 0, 0.375, 0.625, 0.375); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625, 0.375, 0, 0.75, 0.625, 0.375); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375, 0.375, 0, 0.625, 0.625, 0.375); + zMax = 0.5F; + break; + case 4: + renderer.setRenderBounds(0.625, 0.25, 0.25, 1, 0.375, 0.75); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625, 0.375, 0.25, 1, 0.625, 0.375); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625, 0.375, 0.625, 1, 0.625, 0.75); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625, 0.375, 0.375, 1, 0.625, 0.625); + xMin = 0.5F; + break; + case 5: + renderer.setRenderBounds(0, 0.25, 0.25, 0.375, 0.375, 0.75); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0, 0.375, 0.25, 0.375, 0.625, 0.375); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0, 0.375, 0.625, 0.375, 0.625, 0.75); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0, 0.375, 0.375, 0.375, 0.625, 0.625); + xMax = 0.5F; + break; } - else - //Item - { - Item liquidItem = Item.itemsList[blockToRender.itemID]; - //ForgeHooksClient.bindTexture(liquidItem.getTextureFile(), 0); - int meta = blockToRender.getItemDamage(); - BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(meta), x, y, z, renderer, world); - renderer.setRenderBounds(xMin, yMin, zMin, xMax, 0.625, zMax); - BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(meta), x, y, z, renderer, world); - }*/ - //renderer.renderStandardBlock(block, x, y, z); - } + float yMin = 0F; + int uID = world.getBlockId(x, y - 1, z); + int uMeta = world.getBlockMetadata(x, y - 1, z); + if (uID == TContent.searedBlock.blockID && uMeta == 0) + { + yMin = -0.125F; + } + else if (uID == TContent.searedBlock.blockID && uMeta == 2) + { + yMin = -0.75F; + } + else if (uID == TContent.lavaTank.blockID) + { + yMin = -1F; + } + else if (uID == TContent.castingChannel.blockID) + { + yMin = -0.5F; + } + + if (logic.liquid != null) + { + Fluid fluid = logic.liquid.getFluid(); + renderer.setRenderBounds(xMin, yMin, zMin, xMax, 0.625, zMax); + BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world); + /*if (fluid.canBePlacedInWorld()) + { + Block liquidBlock = Block.blocksList[blockToRender.itemID]; + BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, 0, x, y, z, renderer, world); + renderer.setRenderBounds(xMin, yMin, zMin, xMax, 0.625, zMax); + BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, 0, x, y, z, renderer, world); + }*/ + /*ItemStack blockToRender = new ItemStack(logic.liquid.fluidID, 1, logic.liquid.itemMeta); + if (blockToRender.itemID < 4096) //Block + { + + } + else + //Item + { + Item liquidItem = Item.itemsList[blockToRender.itemID]; + //ForgeHooksClient.bindTexture(liquidItem.getTextureFile(), 0); + int meta = blockToRender.getItemDamage(); + BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(meta), x, y, z, renderer, world); + renderer.setRenderBounds(xMin, yMin, zMin, xMax, 0.625, zMax); + BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(meta), x, y, z, renderer, world); + }*/ + //renderer.renderStandardBlock(block, x, y, z); + } + } } else if (metadata == 2) { @@ -374,54 +377,56 @@ public class SearedRender implements ISimpleBlockRenderingHandler renderer.renderStandardBlock(block, x, y, z); //Liquids - CastingBasinLogic logic = (CastingBasinLogic) world.getBlockTileEntity(x, y, z); - if (logic.liquid != null) - { - float minHeight = 0.25F; - float maxHeight = 0.95F; - - float minX = 0.0625F; - float maxX = 0.9375F; - float minZ = 0.0625F; - float maxZ = 0.9375F; - - ItemStack it = logic.getStackInSlot(0); - if(it != null){ - CastingRecipe rec = TConstruct.basinCasting.getCastingRecipe(logic.liquid, it); - if(rec != null && rec.fluidRenderProperties != null){ - minHeight = rec.fluidRenderProperties.minHeight; - maxHeight = rec.fluidRenderProperties.maxHeight; - - minX = rec.fluidRenderProperties.minX; - maxX = rec.fluidRenderProperties.maxX; - minZ = rec.fluidRenderProperties.minZ; - maxZ = rec.fluidRenderProperties.maxZ; - } - } - float height = (logic.getLiquidAmount() / (logic.getCapacity() * 1.05F) * 0.6875F) / maxHeight; - renderer.setRenderBounds(minX, minHeight, minZ, maxX, minHeight + height, maxZ); + if (world.getBlockTileEntity(x, y, z) instanceof CastingBasinLogic) { + CastingBasinLogic logic = (CastingBasinLogic) world.getBlockTileEntity(x, y, z); + if (logic.liquid != null) + { + float minHeight = 0.25F; + float maxHeight = 0.95F; - Fluid fluid = logic.liquid.getFluid(); - BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world); - /*if (logic.liquid.itemID < 4096) //Block - { - Block liquidBlock = Block.blocksList[logic.liquid.itemID]; - if (liquidBlock != null) + float minX = 0.0625F; + float maxX = 0.9375F; + float minZ = 0.0625F; + float maxZ = 0.9375F; + + ItemStack it = logic.getStackInSlot(0); + if(it != null){ + CastingRecipe rec = TConstruct.basinCasting.getCastingRecipe(logic.liquid, it); + if(rec != null && rec.fluidRenderProperties != null){ + minHeight = rec.fluidRenderProperties.minHeight; + maxHeight = rec.fluidRenderProperties.maxHeight; + + minX = rec.fluidRenderProperties.minX; + maxX = rec.fluidRenderProperties.maxX; + minZ = rec.fluidRenderProperties.minZ; + maxZ = rec.fluidRenderProperties.maxZ; + } + } + float height = (logic.getLiquidAmount() / (logic.getCapacity() * 1.05F) * 0.6875F) / maxHeight; + renderer.setRenderBounds(minX, minHeight, minZ, maxX, minHeight + height, maxZ); + + Fluid fluid = logic.liquid.getFluid(); + BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world); + /*if (logic.liquid.itemID < 4096) //Block { - //ForgeHooksClient.bindTexture(liquidBlock.getTextureFile(), 0); - BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, logic.liquid.itemMeta, x, y, z, renderer, world); + Block liquidBlock = Block.blocksList[logic.liquid.itemID]; + if (liquidBlock != null) + { + //ForgeHooksClient.bindTexture(liquidBlock.getTextureFile(), 0); + BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, logic.liquid.itemMeta, x, y, z, renderer, world); + } } + else + //Item + { + Item liquidItem = Item.itemsList[logic.liquid.itemID]; + if (liquidItem != null) + { + //ForgeHooksClient.bindTexture(liquidItem.getTextureFile(), 0); + BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(logic.liquid.itemMeta), x, y, z, renderer, world); + } + }*/ } - else - //Item - { - Item liquidItem = Item.itemsList[logic.liquid.itemID]; - if (liquidItem != null) - { - //ForgeHooksClient.bindTexture(liquidItem.getTextureFile(), 0); - BlockSkinRenderHelper.renderFakeBlock(liquidItem.getIconFromDamage(logic.liquid.itemMeta), x, y, z, renderer, world); - } - }*/ } } else