From 27e43ebfa7612fe0b89534f8a61849440ab26ab3 Mon Sep 17 00:00:00 2001 From: Rseifert Date: Mon, 29 Oct 2012 13:47:33 -0400 Subject: [PATCH] Cleaned up and started on crafters I removed some commented out areas from the other files. Also started on autocrafter at the moment nothing is done just creating init files, methods, and trying to layout the ground work. Let see if i can code these cleaner than i usually do he he :) Also looks like some other things are getting uploaded in this. Might be a slight version diff in the UE and Buildcraft api version i have. As well i added the textures to the src folder. Not sure how you mod with them in the resource folder. --- resources/assemblyline/textures/ejector.png | Bin 0 -> 1054 bytes resources/assemblyline/textures/injector.png | Bin 0 -> 957 bytes src/common/assemblyline/TileEntityBase.java | 106 ----------- .../belts/TileEntityConveyorBelt.java | 4 +- .../machines/crafter/ContainerCrafter.java | 98 ++++++++++ .../machines/crafter/EntityCraftingArm.java | 47 ++++- .../machines/crafter/ItemCrafterArm.java | 12 ++ .../crafter/TileEntityAutoCrafter.java | 14 +- .../crafter/TileEntityCraftingArm.java | 132 +++++++++++++- .../buildcraft/api/core/Orientations.java | 80 ++++++++ src/common/buildcraft/api/core/Position.java | 141 +++++++++++++++ .../buildcraft/api/core/SafeTimeTracker.java | 44 +++++ .../buildcraft/api/liquids/ILiquid.java | 20 ++ .../buildcraft/api/liquids/ILiquidTank.java | 27 +++ .../api/liquids/ITankContainer.java | 46 +++++ .../buildcraft/api/liquids/LiquidData.java | 45 +++++ .../api/liquids/LiquidDictionary.java | 57 ++++++ .../buildcraft/api/liquids/LiquidManager.java | 64 +++++++ .../buildcraft/api/liquids/LiquidStack.java | 109 +++++++++++ .../buildcraft/api/liquids/LiquidTank.java | 100 ++++++++++ .../buildcraft/api/power/IPowerProvider.java | 41 +++++ .../buildcraft/api/power/IPowerReceptor.java | 23 +++ .../buildcraft/api/power/PowerFramework.java | 56 ++++++ .../buildcraft/api/power/PowerProvider.java | 162 +++++++++++++++++ .../prefab/TileEntityConductor.java | 171 ++++++++++++++++++ .../prefab/multiblock/BlockMulti.java | 99 ++++++++++ .../prefab/multiblock/IBlockActivate.java | 17 ++ .../prefab/multiblock/IMultiBlock.java | 30 +++ .../prefab/multiblock/TileEntityMulti.java | 120 ++++++++++++ .../prefab/network/ConnectionHandler.java | 88 +++++++++ .../network/ISimpleConnectionHandler.java | 14 ++ .../prefab/ore/OreGenBase.java | 104 +++++++++++ .../prefab/ore/OreGenReplace.java | 134 ++++++++++++++ .../prefab/ore/OreGenReplaceStone.java | 18 ++ .../prefab/ore/OreGenerator.java | 75 ++++++++ .../prefab/potion/CustomPotion.java | 41 +++++ .../prefab/potion/CustomPotionEffect.java | 41 +++++ .../assemblyline/textures/BeltMid.png | Bin 0 -> 373 bytes .../assemblyline/textures/BeltSingle.png | Bin 0 -> 387 bytes .../assemblyline/textures/BeltTexture.png | Bin 0 -> 791 bytes .../assemblyline/textures/CoalGenerator.png | Bin 0 -> 3762 bytes .../assemblyline/textures/ConveyorBelt.png | Bin 0 -> 401 bytes .../assemblyline/textures/ConveyorBeltF.png | Bin 0 -> 402 bytes .../assemblyline/textures/ConveyorBeltR.png | Bin 0 -> 397 bytes .../assemblyline/textures/ConveyorBeltRF.png | Bin 0 -> 407 bytes .../assemblyline/textures/Grey64.png | Bin 0 -> 534 bytes .../assemblyline/textures/dropbox.png | Bin 0 -> 950 bytes .../assemblyline/textures/ejector.png | Bin 0 -> 1054 bytes .../assemblyline/textures/gui_crafter.png | Bin 0 -> 1053 bytes .../assemblyline/textures/gui_ejector.png | Bin 0 -> 3800 bytes .../assemblyline/textures/injector.png | Bin 0 -> 957 bytes .../assemblyline/textures/manipulator1.png | Bin 0 -> 957 bytes .../assemblyline/textures/manipulator2.png | Bin 0 -> 3665 bytes .../assemblyline/textures/sorter.png | Bin 0 -> 1054 bytes 54 files changed, 2253 insertions(+), 127 deletions(-) create mode 100644 resources/assemblyline/textures/ejector.png create mode 100644 resources/assemblyline/textures/injector.png create mode 100644 src/common/assemblyline/machines/crafter/ContainerCrafter.java create mode 100644 src/common/assemblyline/machines/crafter/ItemCrafterArm.java create mode 100644 src/common/buildcraft/api/core/Orientations.java create mode 100644 src/common/buildcraft/api/core/Position.java create mode 100644 src/common/buildcraft/api/core/SafeTimeTracker.java create mode 100644 src/common/buildcraft/api/liquids/ILiquid.java create mode 100644 src/common/buildcraft/api/liquids/ILiquidTank.java create mode 100644 src/common/buildcraft/api/liquids/ITankContainer.java create mode 100644 src/common/buildcraft/api/liquids/LiquidData.java create mode 100644 src/common/buildcraft/api/liquids/LiquidDictionary.java create mode 100644 src/common/buildcraft/api/liquids/LiquidManager.java create mode 100644 src/common/buildcraft/api/liquids/LiquidStack.java create mode 100644 src/common/buildcraft/api/liquids/LiquidTank.java create mode 100644 src/common/buildcraft/api/power/IPowerProvider.java create mode 100644 src/common/buildcraft/api/power/IPowerReceptor.java create mode 100644 src/common/buildcraft/api/power/PowerFramework.java create mode 100644 src/common/buildcraft/api/power/PowerProvider.java create mode 100644 src/common/universalelectricity/prefab/TileEntityConductor.java create mode 100644 src/common/universalelectricity/prefab/multiblock/BlockMulti.java create mode 100644 src/common/universalelectricity/prefab/multiblock/IBlockActivate.java create mode 100644 src/common/universalelectricity/prefab/multiblock/IMultiBlock.java create mode 100644 src/common/universalelectricity/prefab/multiblock/TileEntityMulti.java create mode 100644 src/common/universalelectricity/prefab/network/ConnectionHandler.java create mode 100644 src/common/universalelectricity/prefab/network/ISimpleConnectionHandler.java create mode 100644 src/common/universalelectricity/prefab/ore/OreGenBase.java create mode 100644 src/common/universalelectricity/prefab/ore/OreGenReplace.java create mode 100644 src/common/universalelectricity/prefab/ore/OreGenReplaceStone.java create mode 100644 src/common/universalelectricity/prefab/ore/OreGenerator.java create mode 100644 src/common/universalelectricity/prefab/potion/CustomPotion.java create mode 100644 src/common/universalelectricity/prefab/potion/CustomPotionEffect.java create mode 100644 src/minecraft/assemblyline/textures/BeltMid.png create mode 100644 src/minecraft/assemblyline/textures/BeltSingle.png create mode 100644 src/minecraft/assemblyline/textures/BeltTexture.png create mode 100644 src/minecraft/assemblyline/textures/CoalGenerator.png create mode 100644 src/minecraft/assemblyline/textures/ConveyorBelt.png create mode 100644 src/minecraft/assemblyline/textures/ConveyorBeltF.png create mode 100644 src/minecraft/assemblyline/textures/ConveyorBeltR.png create mode 100644 src/minecraft/assemblyline/textures/ConveyorBeltRF.png create mode 100644 src/minecraft/assemblyline/textures/Grey64.png create mode 100644 src/minecraft/assemblyline/textures/dropbox.png create mode 100644 src/minecraft/assemblyline/textures/ejector.png create mode 100644 src/minecraft/assemblyline/textures/gui_crafter.png create mode 100644 src/minecraft/assemblyline/textures/gui_ejector.png create mode 100644 src/minecraft/assemblyline/textures/injector.png create mode 100644 src/minecraft/assemblyline/textures/manipulator1.png create mode 100644 src/minecraft/assemblyline/textures/manipulator2.png create mode 100644 src/minecraft/assemblyline/textures/sorter.png diff --git a/resources/assemblyline/textures/ejector.png b/resources/assemblyline/textures/ejector.png new file mode 100644 index 0000000000000000000000000000000000000000..feba2e00164af67757833c7dcc1fc4d71ec8f3c4 GIT binary patch literal 1054 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sDEfH31!Z9ZuR2IkG4E{-7;ac^fkP7*fcab5nrAcpZAQ+J5i zomN$yhc+A9q+3cfx+Zw8GA+72>1+I|Wk8_&x_sEo5LgHRX~z3q#GmsgkS=sa`LI znHcQupXy<1Fk1SBlaXP5eySUz!_1&xEes9kw;L^HSm2{s>%?&2dGyRchJa;L>=YRu zd|rEIMQjdH#(#By)#k0Kf2TTr6>b_|;{(O8ccmrETy|AxrWAuS5 zPqY2^RSMpi$0VpE`#?RO?fYzA*MGzKXpJa?F{g6)Y-Wap&nw@AG6ZbfVwQ-Dt;pZBO-}1((EswQd)ou5 z&j$Wwy#C?rg1|PWhPSyXR{RCOZR=it|Mk9Cnzg~#E_@@KK>C6=x(<8RrTu*7y1-IN z-0vyF_J)laqJmXtRHrZZP@s=t$Gzr&D_z{}3Cz)kk97Q=zu z*xp8lfW>`zq6`nVtvlwxup-cXI~PMiba=7?!<7|_qgfettX*v=z>sz2;@YOY4BJah z+4$`FKb$Z#n~>CCB+I$m?`*YAjy4;^5rzX&3dg>iY-Vzp6?8;}iNSE+@|mIxm!>GG z2{Lqiv^~3~hQ}wkYlceNPpO0`3hZOR`-au?dTT@fw^cwb z&pt=}S^xgN-QPd|eja^qy0rTL@2`)&eYTysb+qyF&L7K*7smgwJOAxNefIMQru&&| zxL$mkH%nck`#@#ZRn_2P_8;FK-mT}{^Yh0_ZzmSn*9@`=Ywo{HV{Rx>m7FcW(DT*$ zZVtnQbt=iiObr|Bme1y8xHL5-$BDt<+WV5tj1Idd_4sly9Q!plZ(HhJmRB=H{duZ) z-Iklpcj4W`D}raL8G~1={A}mDzuVZ9QEaLn>~) zz3U%z+d!hNu=OF|+on?MyWH_gkxyiv*;%@azg1CpA+|yThcdz4aWqy!xRixo>UH*GR24({Wi3Uaq z2A%^9zETgqef!?Hb6;P6-Sc>RXIT~hbzf@ZOO!IU-=4{_YA2h8&29d|XT}W7TTHkl zd>@=iXJDJ*%o)L<(M0+ObyfY8SU%p>;v{Lj4Wof__43Vamld)P6u8# zi|YXy2~2DbtZW)(Y<`FcoVxP-^y}hJ+tik6aW}Lo_Oc(iWWbidz{bF= zbAVyzyQlttt)FX@%r-u7`0?LY4?ouZna3#Mz@R31;M0f7Wk;B zJrl-!=T1rePg_%m;Li-x+Rg2NVKJe4!T|>P5SA#pdu6;6Twa};b?Nq09j55W(AHMg z2S&%+^?$aRwuOi>1Rnxgo|_1<+<<`@81xN{2N;Zv8zT*r zZ!y$cfdkxOD_a0d-2n}UYzbzA12Q}x{xMv;CnuIHvy8`vq4|mA7f1FL(M5mLn4F!R0AEk!@v>>+U-h zJgaQbRAw-BILsJeZ@_TZ7@nqh7@!VuILS~FyIqRk?PS`7Dc8FV{VJ)efRm*sVLohUIEl-#j_n}va?A= - * 10) { count = 0; if (!worldObj.isRemote && - * this.sendDataA() != null) { Packet packet = - * PacketManager.getPacket("asmLine", this, - * this.buildData(1)); - * PacketManager.sendPacketToClients(packet, - * worldObj, Vector3.get(this), 40); } if - * (!worldObj.isRemote && this.sendDataG() != - * null && this.isOpen) { Packet packet = - * PacketManager.getPacket("asmLine", this, - * this.buildData(0)); - * PacketManager.sendPacketToClients(packet, - * worldObj, Vector3.get(this), 10); } } if - * (ticks++ % tickRate() >= 0 && - * !isDisabled()) { this.tickedUpdate(); } } - */ /** * Inventory functions. @@ -186,93 +168,5 @@ public abstract class TileEntityBase extends TileEntityAdvanced implements IPack } nbt.setTag("Items", var2); } -/* - @Override - public void handlePacketData(NetworkManager network, int packetType, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) - { - if (worldObj.isRemote) - { - try - { - int ID = dataStream.readInt(); - if (ID == 0) - { - this.guiPacket(network, packetType, packet, player, dataStream); - } - else if (ID == 1) - { - this.animationPacket(network, packetType, packet, player, dataStream); - } - else - { - } - - } - catch (Exception e) - { - e.printStackTrace(); - } - } - } - - /** - * Used to read GUI only data sent to the TE - - public abstract void guiPacket(NetworkManager network, int packetType, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream); - - /** - * Used to read animation data for things that - * can be seen on a TE - - public abstract void animationPacket(NetworkManager network, int packetType, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream); - - /** - * Used to read data for none animation or gui - * server sent packets - * - public abstract void otherPacket(NetworkManager network, int packetType, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream); - - public Object[] buildData(int packetID) - { - Object[] data = new Object[1]; - - if (packetID == 0) - { - data = new Object[this.sendDataG().length + 1]; - data[0] = packetID; - for (int i = 0; i < this.sendDataG().length; i++) - { - data[i + 1] = this.sendDataG()[i]; - } - } - else if (packetID == 1) - { - data = new Object[this.sendDataA().length + 1]; - data[0] = packetID; - for (int i = 0; i < this.sendDataA().length; i++) - { - data[i + 1] = this.sendDataA()[i]; - } - } - return data; - } - - /** - * Array of data too be sent for animation - * updates - * - * @return - * - public abstract Object[] sendDataA(); - - /** - * Array of data too be sent if the TE's GUI - * is open at the time - * - * @return - * - public abstract Object[] sendDataG(); - - */ } diff --git a/src/common/assemblyline/belts/TileEntityConveyorBelt.java b/src/common/assemblyline/belts/TileEntityConveyorBelt.java index 4d7f6281..b466ee25 100644 --- a/src/common/assemblyline/belts/TileEntityConveyorBelt.java +++ b/src/common/assemblyline/belts/TileEntityConveyorBelt.java @@ -88,7 +88,7 @@ public class TileEntityConveyorBelt extends TileEntityElectricityReceiver implem { super.updateEntity(); - if (this.ticks % 20 == 0) + if (this.ticks % 10 == 0) { if (!worldObj.isRemote) { @@ -300,7 +300,7 @@ public class TileEntityConveyorBelt extends TileEntityElectricityReceiver implem * Used to tell the belt not to apply velocity * to some Entity in case they are being * handled by another block. For example - * ejector + * Rejector * * @param entity */ diff --git a/src/common/assemblyline/machines/crafter/ContainerCrafter.java b/src/common/assemblyline/machines/crafter/ContainerCrafter.java new file mode 100644 index 00000000..3240fae3 --- /dev/null +++ b/src/common/assemblyline/machines/crafter/ContainerCrafter.java @@ -0,0 +1,98 @@ +package assemblyline.machines.crafter; + +import net.minecraft.src.Container; +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.InventoryPlayer; +import net.minecraft.src.Item; +import net.minecraft.src.ItemStack; +import net.minecraft.src.Slot; + +public class ContainerCrafter extends Container +{ + private TileEntityAutoCrafter tileEntity; + + public ContainerCrafter(InventoryPlayer par1InventoryPlayer, TileEntityAutoCrafter tileEntity) + { + this.tileEntity = tileEntity; + for(int r = 0; r < 3; r++) + { + for(int i = 0; i < 3; i++) + { + this.addSlotToContainer(new Slot(tileEntity, i+ r*3, 33 + i*18, 34 + r * 18)); + } + } + int var3; + + for (var3 = 0; var3 < 3; ++var3) + { + for (int var4 = 0; var4 < 9; ++var4) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + } + + @Override + public boolean canInteractWith(EntityPlayer par1EntityPlayer) + { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + /** + * Called to transfer a stack from one inventory to the other eg. when shift clicking. + */ + @Override + public ItemStack func_82846_b(EntityPlayer par1EntityPlayer, int par1) + { + ItemStack itemStack3 = null; + Slot itemStack = (Slot)this.inventorySlots.get(par1); + + if (itemStack != null && itemStack.getHasStack()) + { + ItemStack itemStack2 = itemStack.getStack(); + itemStack3 = itemStack2.copy(); + + if (par1 != 0) + { + if (itemStack2.itemID == Item.coal.shiftedIndex) + { + if (!this.mergeItemStack(itemStack2, 0, 1, false)) + { + return null; + } + } + else if (par1 >= 30 && par1 < 37 && !this.mergeItemStack(itemStack2, 3, 30, false)) + { + return null; + } + } + else if (!this.mergeItemStack(itemStack2, 3, 37, false)) + { + return null; + } + + if (itemStack2.stackSize == 0) + { + itemStack.putStack((ItemStack)null); + } + else + { + itemStack.onSlotChanged(); + } + + if (itemStack2.stackSize == itemStack3.stackSize) + { + return null; + } + + itemStack.func_82870_a(par1EntityPlayer, itemStack2); + } + + return itemStack3; + } +} diff --git a/src/common/assemblyline/machines/crafter/EntityCraftingArm.java b/src/common/assemblyline/machines/crafter/EntityCraftingArm.java index 0ea4f2c6..a95b4c1b 100644 --- a/src/common/assemblyline/machines/crafter/EntityCraftingArm.java +++ b/src/common/assemblyline/machines/crafter/EntityCraftingArm.java @@ -1,11 +1,39 @@ package assemblyline.machines.crafter; +import universalelectricity.core.Vector3; import net.minecraft.src.Entity; +import net.minecraft.src.EntityItem; +import net.minecraft.src.ItemStack; import net.minecraft.src.NBTTagCompound; import net.minecraft.src.World; public class EntityCraftingArm extends Entity { - + /** + * Used to ID the type of arm + */ + static enum armType + { + ARM,SOLDER,DRILL,BREAKER + } + /** + * type of arm this robotic arm currently is + */ + public armType arm = armType.ARM; + /** + * stack this arm is holding if any + */ + public ItemStack stack = null; + /** + * TileEntity this arm is working with + */ + public TileEntityCraftingArm blockArm = null; + /** + * position that the arms claw should be at + */ + public Vector3 clawPos = new Vector3(); + + public boolean isWorking = false; + public EntityCraftingArm(World par1World) { super(par1World); } @@ -17,14 +45,23 @@ public class EntityCraftingArm extends Entity { } @Override - protected void readEntityFromNBT(NBTTagCompound var1) { - // TODO Auto-generated method stub + protected void readEntityFromNBT(NBTTagCompound nbt) { + this.arm = armType.values()[nbt.getInteger("type")]; } @Override - protected void writeEntityToNBT(NBTTagCompound var1) { - // TODO Auto-generated method stub + protected void writeEntityToNBT(NBTTagCompound nbt) { + nbt.setInteger("type", arm.ordinal()); } + + public boolean grabItem(EntityItem item) + { + if(this.stack == null) + { + //TODO set current stack to item as soon as it reaches coords + } + return false; + } } diff --git a/src/common/assemblyline/machines/crafter/ItemCrafterArm.java b/src/common/assemblyline/machines/crafter/ItemCrafterArm.java new file mode 100644 index 00000000..bc6cc76e --- /dev/null +++ b/src/common/assemblyline/machines/crafter/ItemCrafterArm.java @@ -0,0 +1,12 @@ +package assemblyline.machines.crafter; + +import net.minecraft.src.Item; + +public class ItemCrafterArm extends Item { + + protected ItemCrafterArm(int par1) { + super(par1); + this.setHasSubtypes(true); + } + +} diff --git a/src/common/assemblyline/machines/crafter/TileEntityAutoCrafter.java b/src/common/assemblyline/machines/crafter/TileEntityAutoCrafter.java index c7dce0c2..4bada93e 100644 --- a/src/common/assemblyline/machines/crafter/TileEntityAutoCrafter.java +++ b/src/common/assemblyline/machines/crafter/TileEntityAutoCrafter.java @@ -9,7 +9,7 @@ import assemblyline.TileEntityBase; import com.google.common.io.ByteArrayDataInput; -public class TileEntityAutoCrafter extends TileEntityBase implements ISidedInventory +public class TileEntityAutoCrafter extends TileEntityBase { @Override public String getInvName() @@ -28,16 +28,4 @@ public class TileEntityAutoCrafter extends TileEntityBase implements ISidedInven { } - - @Override - public int getStartInventorySide(ForgeDirection side) - { - return 0; - } - - @Override - public int getSizeInventorySide(ForgeDirection side) - { - return 0; - } } diff --git a/src/common/assemblyline/machines/crafter/TileEntityCraftingArm.java b/src/common/assemblyline/machines/crafter/TileEntityCraftingArm.java index 9f48622e..f66d5b69 100644 --- a/src/common/assemblyline/machines/crafter/TileEntityCraftingArm.java +++ b/src/common/assemblyline/machines/crafter/TileEntityCraftingArm.java @@ -1,7 +1,137 @@ package assemblyline.machines.crafter; +import com.google.common.io.ByteArrayDataInput; + +import assemblyline.TileEntityBase; +import universalelectricity.implement.IElectricityReceiver; +import universalelectricity.prefab.TileEntityElectricityReceiver; +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.INetworkManager; +import net.minecraft.src.Packet250CustomPayload; import net.minecraft.src.TileEntity; +import net.minecraftforge.common.ForgeDirection; -public class TileEntityCraftingArm extends TileEntity { +public class TileEntityCraftingArm extends TileEntityBase implements IElectricityReceiver { + public enum armTasks + { + NONE,COLLECT,MINE,PLACE,SORT,CRAFT + } + + /** + * Entity robotic arm to be used with this tileEntity + */ + public EntityCraftingArm EntityArm = null; + public double wattUsed = 20; + + public double jouleReceived = 0; + + public double maxJoules = 100; + /** + * does this arm have a task to do + */ + public boolean hasTask = true; + /** + * what kind of task this arm should do + */ + public armTasks task = armTasks.NONE; + + public void updateEntity() + { + super.updateEntity(); + if(this.ticks % 5 == 0 && !this.isDisabled() && this.hasTask && EntityArm != null) + { + this.jouleReceived -= this.wattUsed; + this.doWork(); + } + } + + /** + * controls the robotic arm into doing a set task + */ + public void doWork() + { + + } + + /** + * UE methods + */ + @Override + public void onReceive(TileEntity sender, double amps, double voltage, + ForgeDirection side) { + this.jouleReceived = Math.max(jouleReceived + (amps * voltage), + maxJoules); + + } + + @Override + public double wattRequest() { + return maxJoules - jouleReceived; + } + + @Override + public boolean canReceiveFromSide(ForgeDirection side) { + if (side != ForgeDirection.UP) { + return true; + } + return false; + } + @Override + public void onDisable(int duration) { + // TODO Auto-generated method stub + + } + + + @Override + public boolean isDisabled() { + // TODO Auto-generated method stub + return false; + } + + + @Override + public boolean canConnect(ForgeDirection side) { + if(side != ForgeDirection.UP) + { + return true; + } + return false; + } + + @Override + public double getVoltage() { + // TODO Auto-generated method stub + return 120; + } + /** + * Data + */ + @Override + public void handlePacketData(INetworkManager network, int packetType, + Packet250CustomPayload packet, EntityPlayer player, + ByteArrayDataInput dataStream) { + // TODO Auto-generated method stub + + } + + /** + * inventory + */ + @Override + public int getSizeInventory() { + // TODO Auto-generated method stub + return 1; + } + + + @Override + public String getInvName() { + // TODO Auto-generated method stub + return "RoboticArm"; + } + + + } diff --git a/src/common/buildcraft/api/core/Orientations.java b/src/common/buildcraft/api/core/Orientations.java new file mode 100644 index 00000000..6b27a4b0 --- /dev/null +++ b/src/common/buildcraft/api/core/Orientations.java @@ -0,0 +1,80 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.core; + +import net.minecraftforge.common.ForgeDirection; + +public enum Orientations { + YNeg, // 0 + YPos, // 1 + ZNeg, // 2 + ZPos, // 3 + XNeg, // 4 + XPos, // 5 + Unknown; + + public Orientations reverse() { + switch (this) { + case YPos: + return Orientations.YNeg; + case YNeg: + return Orientations.YPos; + case ZPos: + return Orientations.ZNeg; + case ZNeg: + return Orientations.ZPos; + case XPos: + return Orientations.XNeg; + case XNeg: + return Orientations.XPos; + default: + return Orientations.Unknown; + } + } + + public ForgeDirection toDirection(){ + switch(this){ + case YNeg: + return ForgeDirection.DOWN; + case YPos: + return ForgeDirection.UP; + case ZNeg: + return ForgeDirection.NORTH; + case ZPos: + return ForgeDirection.SOUTH; + case XNeg: + return ForgeDirection.WEST; + case XPos: + return ForgeDirection.EAST; + default: + return ForgeDirection.UNKNOWN; + + } + } + + public Orientations rotateLeft() { + switch (this) { + case XPos: + return ZPos; + case ZNeg: + return XPos; + case XNeg: + return ZNeg; + case ZPos: + return XNeg; + default: + return this; + } + } + + public static Orientations[] dirs() { + return new Orientations[] { YNeg, YPos, ZNeg, ZPos, XNeg, XPos }; + } +} diff --git a/src/common/buildcraft/api/core/Position.java b/src/common/buildcraft/api/core/Position.java new file mode 100644 index 00000000..2ee79d7e --- /dev/null +++ b/src/common/buildcraft/api/core/Position.java @@ -0,0 +1,141 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.core; + +import net.minecraft.src.NBTTagCompound; +import net.minecraft.src.TileEntity; + +public class Position { + + public double x, y, z; + public Orientations orientation; + + public Position(double ci, double cj, double ck) { + x = ci; + y = cj; + z = ck; + orientation = Orientations.Unknown; + } + + public Position(double ci, double cj, double ck, Orientations corientation) { + x = ci; + y = cj; + z = ck; + orientation = corientation; + } + + public Position(Position p) { + x = p.x; + y = p.y; + z = p.z; + orientation = p.orientation; + } + + public Position(NBTTagCompound nbttagcompound) { + x = nbttagcompound.getDouble("i"); + y = nbttagcompound.getDouble("j"); + z = nbttagcompound.getDouble("k"); + + orientation = Orientations.Unknown; + } + + public Position(TileEntity tile) { + x = tile.xCoord; + y = tile.yCoord; + z = tile.zCoord; + } + + public void moveRight(double step) { + switch (orientation) { + case ZPos: + x = x - step; + break; + case ZNeg: + x = x + step; + break; + case XPos: + z = z + step; + break; + case XNeg: + z = z - step; + break; + default: + } + } + + public void moveLeft(double step) { + moveRight(-step); + } + + public void moveForwards(double step) { + switch (orientation) { + case YPos: + y = y + step; + break; + case YNeg: + y = y - step; + break; + case ZPos: + z = z + step; + break; + case ZNeg: + z = z - step; + break; + case XPos: + x = x + step; + break; + case XNeg: + x = x - step; + break; + default: + } + } + + public void moveBackwards(double step) { + moveForwards(-step); + } + + public void moveUp(double step) { + switch (orientation) { + case ZPos: + case ZNeg: + case XPos: + case XNeg: + y = y + step; + break; + default: + } + + } + + public void moveDown(double step) { + moveUp(-step); + } + + public void writeToNBT(NBTTagCompound nbttagcompound) { + nbttagcompound.setDouble("i", x); + nbttagcompound.setDouble("j", y); + nbttagcompound.setDouble("k", z); + } + + @Override + public String toString() { + return "{" + x + ", " + y + ", " + z + "}"; + } + + public Position min(Position p) { + return new Position(p.x > x ? x : p.x, p.y > y ? y : p.y, p.z > z ? z : p.z); + } + + public Position max(Position p) { + return new Position(p.x < x ? x : p.x, p.y < y ? y : p.y, p.z < z ? z : p.z); + } + +} \ No newline at end of file diff --git a/src/common/buildcraft/api/core/SafeTimeTracker.java b/src/common/buildcraft/api/core/SafeTimeTracker.java new file mode 100644 index 00000000..b5cf2649 --- /dev/null +++ b/src/common/buildcraft/api/core/SafeTimeTracker.java @@ -0,0 +1,44 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.core; + +import net.minecraft.src.World; + +public class SafeTimeTracker { + + private long lastMark = 0; + + /** + * Return true if a given delay has passed since last time marked was called + * successfully. + */ + public boolean markTimeIfDelay(World world, long delay) { + if (world == null) { + return false; + } + + long currentTime = world.getWorldTime(); + + if (currentTime < lastMark) { + lastMark = currentTime; + return false; + } else if (lastMark + delay <= currentTime) { + lastMark = world.getWorldTime(); + return true; + } else { + return false; + } + + } + + public void markTime(World world) { + lastMark = world.getWorldTime(); + } +} diff --git a/src/common/buildcraft/api/liquids/ILiquid.java b/src/common/buildcraft/api/liquids/ILiquid.java new file mode 100644 index 00000000..74d9fbe9 --- /dev/null +++ b/src/common/buildcraft/api/liquids/ILiquid.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.liquids; + +public interface ILiquid { + + public int stillLiquidId(); + + public boolean isMetaSensitive(); + + public int stillLiquidMeta(); + +} diff --git a/src/common/buildcraft/api/liquids/ILiquidTank.java b/src/common/buildcraft/api/liquids/ILiquidTank.java new file mode 100644 index 00000000..d570e16e --- /dev/null +++ b/src/common/buildcraft/api/liquids/ILiquidTank.java @@ -0,0 +1,27 @@ +package buildcraft.api.liquids; + +public interface ILiquidTank { + + /** + * @return LiquidStack representing the liquid contained in the tank, null if empty. + */ + LiquidStack getLiquid(); + void setLiquid(LiquidStack liquid); + void setCapacity(int capacity); + int getCapacity(); + + /** + * + * @param resource + * @param doFill + * @return Amount of liquid used for filling. + */ + int fill(LiquidStack resource, boolean doFill); + /** + * + * @param maxDrain + * @param doDrain + * @return Null if nothing was drained, otherwise a LiquidStack containing the drained. + */ + LiquidStack drain(int maxDrain, boolean doDrain); +} diff --git a/src/common/buildcraft/api/liquids/ITankContainer.java b/src/common/buildcraft/api/liquids/ITankContainer.java new file mode 100644 index 00000000..51c89126 --- /dev/null +++ b/src/common/buildcraft/api/liquids/ITankContainer.java @@ -0,0 +1,46 @@ +package buildcraft.api.liquids; + +import buildcraft.api.core.Orientations; + +public interface ITankContainer { + + /** + * Fills liquid into internal tanks, distribution is left to the ITankContainer. + * @param from Orientation the liquid is pumped in from. + * @param resource LiquidStack representing the maximum amount of liquid filled into the ITankContainer + * @param doFill If false filling will only be simulated. + * @return Amount of resource that was filled into internal tanks. + */ + int fill(Orientations from, LiquidStack resource, boolean doFill); + /** + * Fills liquid into the specified internal tank. + * @param from Orientation the liquid is pumped in from. + * @param resource LiquidStack representing the maximum amount of liquid filled into the ITankContainer + * @param doFill If false filling will only be simulated. + * @return Amount of resource that was filled into internal tanks. + */ + int fill(int tankIndex, LiquidStack resource, boolean doFill); + + /** + * Drains liquid out of internal tanks, distribution is left to the ITankContainer. + * @param from Orientation the liquid is drained to. + * @param maxDrain Maximum amount of liquid to drain. + * @param doDrain If false draining will only be simulated. + * @return LiquidStack representing the liquid and amount actually drained from the ITankContainer + */ + LiquidStack drain(Orientations from, int maxDrain, boolean doDrain); + /** + * Drains liquid out of the specified internal tank. + * @param from Orientation the liquid is drained to. + * @param maxDrain Maximum amount of liquid to drain. + * @param doDrain If false draining will only be simulated. + * @return LiquidStack representing the liquid and amount actually drained from the ITankContainer + */ + LiquidStack drain(int tankIndex, int maxDrain, boolean doDrain); + + /** + * @return Array of {@link LiquidTank}s contained in this ITankContainer + */ + ILiquidTank[] getTanks(); + +} diff --git a/src/common/buildcraft/api/liquids/LiquidData.java b/src/common/buildcraft/api/liquids/LiquidData.java new file mode 100644 index 00000000..97187772 --- /dev/null +++ b/src/common/buildcraft/api/liquids/LiquidData.java @@ -0,0 +1,45 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.liquids; + +import net.minecraft.src.Item; +import net.minecraft.src.ItemStack; + +public class LiquidData { + + public final LiquidStack stillLiquid; + public final LiquidStack movingLiquid; + + public final ItemStack filled; + public final ItemStack container; + + public LiquidData(int stillLiquidId, int movingLiquidId, Item filled) { + this(new LiquidStack(stillLiquidId, LiquidManager.BUCKET_VOLUME), new LiquidStack(movingLiquidId, LiquidManager.BUCKET_VOLUME), new ItemStack(filled, 1), new ItemStack(Item.bucketEmpty)); + } + + public LiquidData(int stillLiquidId, int movingLiquidId, ItemStack filled) { + this(new LiquidStack(stillLiquidId, LiquidManager.BUCKET_VOLUME), new LiquidStack(movingLiquidId, LiquidManager.BUCKET_VOLUME), filled, new ItemStack(Item.bucketEmpty)); + } + + public LiquidData(LiquidStack stillLiquid, ItemStack filled, ItemStack container) { + this(stillLiquid, stillLiquid, filled, container); + } + + public LiquidData(LiquidStack stillLiquid, LiquidStack movingLiquid, ItemStack filled, ItemStack container) { + this.stillLiquid = stillLiquid; + this.movingLiquid = movingLiquid; + this.filled = filled; + this.container = container; + + if(stillLiquid == null || filled == null || container == null) + throw new RuntimeException("stillLiquid, filled, or container is null, this is an error"); + } + +} diff --git a/src/common/buildcraft/api/liquids/LiquidDictionary.java b/src/common/buildcraft/api/liquids/LiquidDictionary.java new file mode 100644 index 00000000..fece9bfa --- /dev/null +++ b/src/common/buildcraft/api/liquids/LiquidDictionary.java @@ -0,0 +1,57 @@ +package buildcraft.api.liquids; + +import java.util.HashMap; +import java.util.Map; + +/** + * When creating liquids you should register them with this class. + * + * @author CovertJaguar + */ +public abstract class LiquidDictionary +{ + + private static Map liquids = new HashMap(); + + /** + * When creating liquids you should call this function. + * + * Upon passing it a name and liquid item it will return either + * a preexisting implementation of that liquid or the liquid passed in. + * + * + * @param name the name of the liquid + * @param liquid the liquid to use if one doesn't exist + * @return + */ + public static LiquidStack getOrCreateLiquid(String name, LiquidStack liquid) + { + LiquidStack existing = liquids.get(name); + if(existing != null) { + return existing.copy(); + } + liquids.put(name, liquid.copy()); + return liquid; + } + + /** + * Returns the liquid matching the name, + * if such a liquid exists. + * + * Can return null. + * + * @param name the name of the liquid + * @param amount the amout of liquid + * @return + */ + public static LiquidStack getLiquid(String name, int amount) + { + LiquidStack liquid = liquids.get(name); + if(liquid == null) + return null; + + liquid = liquid.copy(); + liquid.amount = amount; + return liquid; + } +} diff --git a/src/common/buildcraft/api/liquids/LiquidManager.java b/src/common/buildcraft/api/liquids/LiquidManager.java new file mode 100644 index 00000000..a9494951 --- /dev/null +++ b/src/common/buildcraft/api/liquids/LiquidManager.java @@ -0,0 +1,64 @@ +package buildcraft.api.liquids; + +import java.util.LinkedList; + +import net.minecraft.src.ItemStack; + +public class LiquidManager { + + public static final int BUCKET_VOLUME = 1000; + public static LinkedList liquids = new LinkedList(); + + public static LiquidStack getLiquidForFilledItem(ItemStack filledItem) { + if (filledItem == null) + return null; + + for (LiquidData liquid : liquids) + if (liquid.filled.isItemEqual(filledItem)) + return liquid.stillLiquid; + + return null; + } + + public static int getLiquidIDForFilledItem(ItemStack filledItem) { + LiquidStack liquidForFilledItem = getLiquidForFilledItem(filledItem); + + if (liquidForFilledItem == null) + return 0; + + return liquidForFilledItem.itemID; + } + + public static ItemStack getFilledItemForLiquid(LiquidStack liquid) { + for (LiquidData data : liquids) + if(data.stillLiquid.isLiquidEqual(liquid)) + return data.filled.copy(); + + return null; + } + + public static ItemStack fillLiquidContainer(int liquidId, int quantity, ItemStack emptyContainer) { + return fillLiquidContainer(new LiquidStack(liquidId, quantity, 0), emptyContainer); + } + + public static ItemStack fillLiquidContainer(LiquidStack liquid, ItemStack emptyContainer) { + for(LiquidData data : liquids) + if(liquid.containsLiquid(data.stillLiquid) + && data.container.isItemEqual(emptyContainer)) + return data.filled.copy(); + return null; + } + + public static boolean isLiquid(ItemStack block) { + if (block.itemID == 0) + return false; + + for (LiquidData liquid : liquids) + if (liquid.stillLiquid.isLiquidEqual(block) || liquid.movingLiquid.isLiquidEqual(block)) + return true; + + return false; + } + + +} diff --git a/src/common/buildcraft/api/liquids/LiquidStack.java b/src/common/buildcraft/api/liquids/LiquidStack.java new file mode 100644 index 00000000..60ec6e06 --- /dev/null +++ b/src/common/buildcraft/api/liquids/LiquidStack.java @@ -0,0 +1,109 @@ +package buildcraft.api.liquids; + +import net.minecraft.src.Block; +import net.minecraft.src.Item; +import net.minecraft.src.ItemStack; +import net.minecraft.src.NBTTagCompound; + +/** + * ItemStack substitute for liquids + * @author SirSengir + */ +public class LiquidStack { + public int itemID; + public int amount; + public int itemMeta; + + private LiquidStack() { + } + + public LiquidStack(int itemID, int amount) { + this(itemID, amount, 0); + } + + public LiquidStack(Item item, int amount) { + this(item.shiftedIndex, amount, 0); + } + + public LiquidStack(Block block, int amount) { + this(block.blockID, amount, 0); + } + + public LiquidStack(int itemID, int amount, int itemDamage) { + this.itemID = itemID; + this.amount = amount; + this.itemMeta = itemDamage; + } + + public NBTTagCompound writeToNBT(NBTTagCompound nbttagcompound) { + nbttagcompound.setShort("Id", (short) itemID); + nbttagcompound.setInteger("Amount", amount); + nbttagcompound.setShort("Meta", (short) itemMeta); + return nbttagcompound; + } + + public void readFromNBT(NBTTagCompound nbttagcompound) { + itemID = nbttagcompound.getShort("Id"); + amount = nbttagcompound.getInteger("Amount"); + itemMeta = nbttagcompound.getShort("Meta"); + } + + /** + * @return A copy of this LiquidStack + */ + public LiquidStack copy() { + return new LiquidStack(itemID, amount, itemMeta); + } + + /** + * @param other + * @return true if this LiquidStack contains the same liquid as the one passed in. + */ + public boolean isLiquidEqual(LiquidStack other) { + if(other == null) + return false; + + return itemID == other.itemID && itemMeta == other.itemMeta; + } + + /** + * @param other + * @return true if this LiquidStack contains the other liquid (liquids are equal and amount >= other.amount). + */ + public boolean containsLiquid(LiquidStack other) { + if(!isLiquidEqual(other)) + return false; + + return amount >= other.amount; + } + + /** + * @param other ItemStack containing liquids. + * @return true if this LiquidStack contains the same liquid as the one passed in. + */ + public boolean isLiquidEqual(ItemStack other) { + if(other == null) + return false; + + return itemID == other.itemID && itemMeta == other.getItemDamage(); + } + + /** + * @return ItemStack representation of this LiquidStack + */ + public ItemStack asItemStack() { + return new ItemStack(itemID, 1, itemMeta); + } + + /** + * Reads a liquid stack from the passed nbttagcompound and returns it. + * + * @param nbttagcompound + * @return + */ + public static LiquidStack loadLiquidStackFromNBT(NBTTagCompound nbttagcompound) { + LiquidStack liquidstack = new LiquidStack(); + liquidstack.readFromNBT(nbttagcompound); + return liquidstack.itemID == 0 ? null : liquidstack; + } +} diff --git a/src/common/buildcraft/api/liquids/LiquidTank.java b/src/common/buildcraft/api/liquids/LiquidTank.java new file mode 100644 index 00000000..62f51755 --- /dev/null +++ b/src/common/buildcraft/api/liquids/LiquidTank.java @@ -0,0 +1,100 @@ +package buildcraft.api.liquids; + +/** + * Reference implementation of ILiquidTank. Use this or implement your own. + */ +public class LiquidTank implements ILiquidTank { + private LiquidStack liquid; + private int capacity; + + public LiquidTank(int capacity) { + this(null, capacity); + } + + public LiquidTank(int liquidId, int quantity, int capacity) { + this(new LiquidStack(liquidId, quantity), capacity); + } + public LiquidTank(LiquidStack liquid, int capacity) { + this.liquid = liquid; + this.capacity = capacity; + } + + @Override + public LiquidStack getLiquid() { + return this.liquid; + } + + @Override + public void setLiquid(LiquidStack liquid) { + this.liquid = liquid; + } + + @Override + public void setCapacity(int capacity) { + this.capacity = capacity; + } + + @Override + public int getCapacity() { + return this.capacity; + } + + @Override + public int fill(LiquidStack resource, boolean doFill) { + if(resource == null || resource.itemID <= 0) + return 0; + + if(liquid == null || liquid.itemID <= 0) { + if(resource.amount <= capacity) { + if(doFill) + this.liquid = resource.copy(); + return resource.amount; + } else { + if(doFill) { + this.liquid = resource.copy(); + this.liquid.amount = capacity; + } + return capacity; + } + } + + if(!liquid.isLiquidEqual(resource)) + return 0; + + int space = capacity - liquid.amount; + if(resource.amount <= space) { + if(doFill) + this.liquid.amount += resource.amount; + return resource.amount; + } else { + + if(doFill) + this.liquid.amount = capacity; + return space; + } + + } + @Override + public LiquidStack drain(int maxDrain, boolean doDrain) { + if(liquid == null || liquid.itemID <= 0) + return null; + if(liquid.amount <= 0) + return null; + + int used = maxDrain; + if(liquid.amount < used) + used = liquid.amount; + + if(doDrain) { + liquid.amount -= used; + } + + LiquidStack drained = new LiquidStack(liquid.itemID, used, liquid.itemMeta); + + // Reset liquid if emptied + if(liquid.amount <= 0) + liquid = null; + + return drained; + } +} diff --git a/src/common/buildcraft/api/power/IPowerProvider.java b/src/common/buildcraft/api/power/IPowerProvider.java new file mode 100644 index 00000000..97506496 --- /dev/null +++ b/src/common/buildcraft/api/power/IPowerProvider.java @@ -0,0 +1,41 @@ +package buildcraft.api.power; + +import buildcraft.api.core.Orientations; +import buildcraft.api.core.SafeTimeTracker; +import net.minecraft.src.NBTTagCompound; + +public interface IPowerProvider { + + int getLatency(); + + int getMinEnergyReceived(); + + int getMaxEnergyReceived(); + + int getMaxEnergyStored(); + + int getActivationEnergy(); + + float getEnergyStored(); + + void configure(int latency, int minEnergyReceived, int maxEnergyReceived, int minActivationEnergy, int maxStoredEnergy); + + void configurePowerPerdition(int powerLoss, int powerLossRegularity); + + boolean update(IPowerReceptor receptor); + + boolean preConditions(IPowerReceptor receptor); + + float useEnergy(float min, float max, boolean doUse); + + void readFromNBT(NBTTagCompound nbttagcompound); + + void writeToNBT(NBTTagCompound nbttagcompound); + + void receiveEnergy(float quantity, Orientations from); + + boolean isPowerSource(Orientations from); + + SafeTimeTracker getTimeTracker(); + +} diff --git a/src/common/buildcraft/api/power/IPowerReceptor.java b/src/common/buildcraft/api/power/IPowerReceptor.java new file mode 100644 index 00000000..f6150480 --- /dev/null +++ b/src/common/buildcraft/api/power/IPowerReceptor.java @@ -0,0 +1,23 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.power; + + +public interface IPowerReceptor { + + public void setPowerProvider(IPowerProvider provider); + + public IPowerProvider getPowerProvider(); + + public void doWork(); + + public int powerRequest(); + +} diff --git a/src/common/buildcraft/api/power/PowerFramework.java b/src/common/buildcraft/api/power/PowerFramework.java new file mode 100644 index 00000000..26cc4e4f --- /dev/null +++ b/src/common/buildcraft/api/power/PowerFramework.java @@ -0,0 +1,56 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.power; + +import net.minecraft.src.NBTTagCompound; + +public abstract class PowerFramework { + + static private String baseNBTName = "net.minecraft.src.buildcarft.Power"; + + public static PowerFramework currentFramework; + + public abstract IPowerProvider createPowerProvider(); + + public void loadPowerProvider(IPowerReceptor receptor, NBTTagCompound compound) { + + IPowerProvider provider = createPowerProvider(); + + if (compound.hasKey(baseNBTName)) { + NBTTagCompound cpt = compound.getCompoundTag(baseNBTName); + if (cpt.getString("class").equals(this.getClass().getName())) { + provider.readFromNBT(cpt.getCompoundTag("contents")); + } + } + + receptor.setPowerProvider(provider); + } + + public void savePowerProvider(IPowerReceptor receptor, NBTTagCompound compound) { + + IPowerProvider provider = receptor.getPowerProvider(); + + if (provider == null) { + return; + } + + NBTTagCompound cpt = new NBTTagCompound(); + + cpt.setString("class", this.getClass().getName()); + + NBTTagCompound contents = new NBTTagCompound(); + + provider.writeToNBT(contents); + + cpt.setTag("contents", contents); + compound.setTag(baseNBTName, cpt); + } + +} diff --git a/src/common/buildcraft/api/power/PowerProvider.java b/src/common/buildcraft/api/power/PowerProvider.java new file mode 100644 index 00000000..54acf335 --- /dev/null +++ b/src/common/buildcraft/api/power/PowerProvider.java @@ -0,0 +1,162 @@ +/** + * Copyright (c) SpaceToad, 2011 + * http://www.mod-buildcraft.com + * + * BuildCraft is distributed under the terms of the Minecraft Mod Public + * License 1.0, or MMPL. Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + */ + +package buildcraft.api.power; + +import buildcraft.api.core.Orientations; +import buildcraft.api.core.SafeTimeTracker; +import net.minecraft.src.NBTTagCompound; +import net.minecraft.src.TileEntity; + +public abstract class PowerProvider implements IPowerProvider { + + protected int latency; + protected int minEnergyReceived; + protected int maxEnergyReceived; + protected int maxEnergyStored; + protected int minActivationEnergy; + protected float energyStored = 0; + + protected int powerLoss = 1; + protected int powerLossRegularity = 100; + + public SafeTimeTracker timeTracker = new SafeTimeTracker(); + public SafeTimeTracker energyLossTracker = new SafeTimeTracker(); + + public int[] powerSources = { 0, 0, 0, 0, 0, 0 }; + + @Override public SafeTimeTracker getTimeTracker() { return this.timeTracker; } + + @Override public int getLatency() { return this.latency; } + @Override public int getMinEnergyReceived() { return this.minEnergyReceived; } + @Override public int getMaxEnergyReceived() { return this.maxEnergyReceived; } + @Override public int getMaxEnergyStored() { return this.maxEnergyStored; } + @Override public int getActivationEnergy() { return this.minActivationEnergy; } + @Override public float getEnergyStored() { return this.energyStored; } + + @Override + public void configure(int latency, int minEnergyReceived, int maxEnergyReceived, int minActivationEnergy, int maxStoredEnergy) { + this.latency = latency; + this.minEnergyReceived = minEnergyReceived; + this.maxEnergyReceived = maxEnergyReceived; + this.maxEnergyStored = maxStoredEnergy; + this.minActivationEnergy = minActivationEnergy; + } + + @Override + public void configurePowerPerdition(int powerLoss, int powerLossRegularity) { + this.powerLoss = powerLoss; + this.powerLossRegularity = powerLossRegularity; + } + + @Override + public boolean update(IPowerReceptor receptor) { + if (!preConditions(receptor)) { + return false; + } + + TileEntity tile = (TileEntity) receptor; + boolean result = false; + + if (energyStored >= minActivationEnergy) { + if (latency == 0) { + receptor.doWork(); + result = true; + } else { + if (timeTracker.markTimeIfDelay(tile.worldObj, latency)) { + receptor.doWork(); + result = true; + } + } + } + + if (powerLoss > 0 && energyLossTracker.markTimeIfDelay(tile.worldObj, powerLossRegularity)) { + + energyStored -= powerLoss; + if (energyStored < 0) { + energyStored = 0; + } + } + + for (int i = 0; i < 6; ++i) { + if (powerSources[i] > 0) { + powerSources[i]--; + } + } + + return result; + } + + @Override + public boolean preConditions(IPowerReceptor receptor) { + return true; + } + + @Override + public float useEnergy(float min, float max, boolean doUse) { + float result = 0; + + if (energyStored >= min) { + if (energyStored <= max) { + result = energyStored; + if (doUse) { + energyStored = 0; + } + } else { + result = max; + if (doUse) { + energyStored -= max; + } + } + } + + return result; + } + + @Override + public void readFromNBT(NBTTagCompound nbttagcompound) { + latency = nbttagcompound.getInteger("latency"); + minEnergyReceived = nbttagcompound.getInteger("minEnergyReceived"); + maxEnergyReceived = nbttagcompound.getInteger("maxEnergyReceived"); + maxEnergyStored = nbttagcompound.getInteger("maxStoreEnergy"); + minActivationEnergy = nbttagcompound.getInteger("minActivationEnergy"); + + try { + energyStored = nbttagcompound.getFloat("storedEnergy"); + } catch (Throwable c) { + energyStored = 0; + } + } + + @Override + public void writeToNBT(NBTTagCompound nbttagcompound) { + nbttagcompound.setInteger("latency", latency); + nbttagcompound.setInteger("minEnergyReceived", minEnergyReceived); + nbttagcompound.setInteger("maxEnergyReceived", maxEnergyReceived); + nbttagcompound.setInteger("maxStoreEnergy", maxEnergyStored); + nbttagcompound.setInteger("minActivationEnergy", minActivationEnergy); + nbttagcompound.setFloat("storedEnergy", energyStored); + } + + @Override + public void receiveEnergy(float quantity, Orientations from) { + powerSources[from.ordinal()] = 2; + + energyStored += quantity; + + if (energyStored > maxEnergyStored) { + energyStored = maxEnergyStored; + } + } + + @Override + public boolean isPowerSource(Orientations from) { + return powerSources[from.ordinal()] != 0; + } +} diff --git a/src/common/universalelectricity/prefab/TileEntityConductor.java b/src/common/universalelectricity/prefab/TileEntityConductor.java new file mode 100644 index 00000000..11123fbd --- /dev/null +++ b/src/common/universalelectricity/prefab/TileEntityConductor.java @@ -0,0 +1,171 @@ +package universalelectricity.prefab; + +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.INetworkManager; +import net.minecraft.src.Packet250CustomPayload; +import net.minecraft.src.TileEntity; +import net.minecraft.src.World; +import net.minecraftforge.common.ForgeDirection; +import universalelectricity.core.Vector3; +import universalelectricity.electricity.ElectricityManager; +import universalelectricity.electricity.ElectricityNetwork; +import universalelectricity.implement.IConductor; +import universalelectricity.implement.IConnector; +import universalelectricity.prefab.network.IPacketReceiver; + +import com.google.common.io.ByteArrayDataInput; + +/** + * This tile entity pre-fabricated for all + * conductors. + * + * @author Calclavia + * + */ +public abstract class TileEntityConductor extends TileEntityAdvanced implements IConductor, IPacketReceiver +{ + private ElectricityNetwork network; + + /** + * Stores information on the blocks that this + * conductor is connected to + */ + public TileEntity[] connectedBlocks = + { null, null, null, null, null, null }; + + public TileEntityConductor() + { + this.reset(); + } + + @Override + public ElectricityNetwork getNetwork() + { + return this.network; + } + + @Override + public void setNetwork(ElectricityNetwork network) + { + this.network = network; + } + + @Override + public TileEntity[] getConnectedBlocks() + { + return connectedBlocks; + } + + @Override + public void initiate() + { + this.refreshConnectedBlocks(); + } + + @Override + public void updateConnection(TileEntity tileEntity, ForgeDirection side) + { + if (tileEntity != null) + { + if (tileEntity instanceof IConnector) + { + this.connectedBlocks[side.ordinal()] = tileEntity; + + if (tileEntity.getClass() == this.getClass()) + { + ElectricityManager.instance.mergeConnection(this.getNetwork(), ((TileEntityConductor) tileEntity).getNetwork()); + } + + return; + } + } + + if (this.connectedBlocks[side.ordinal()] != null) + { + if (this.connectedBlocks[side.ordinal()] instanceof IConductor) + { + ElectricityManager.instance.splitConnection(this, (IConductor) this.getConnectedBlocks()[side.ordinal()]); + } + } + + this.connectedBlocks[side.ordinal()] = null; + } + + @Override + public void updateConnectionWithoutSplit(TileEntity tileEntity, ForgeDirection side) + { + if (tileEntity != null) + { + if (tileEntity instanceof IConnector) + { + this.connectedBlocks[side.ordinal()] = tileEntity; + + if (tileEntity.getClass() == this.getClass()) + { + ElectricityManager.instance.mergeConnection(this.getNetwork(), ((TileEntityConductor) tileEntity).getNetwork()); + } + + return; + } + } + + this.connectedBlocks[side.ordinal()] = null; + } + + @Override + public void handlePacketData(INetworkManager network, int type, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) + { + if (this.worldObj.isRemote) + { + this.refreshConnectedBlocks(); + } + } + + /** + * Determines if this TileEntity requires + * update calls. + * + * @return True if you want updateEntity() to + * be called, false if not + */ + @Override + public boolean canUpdate() + { + return false; + } + + @Override + public void reset() + { + this.network = null; + + if (ElectricityManager.instance != null) + { + ElectricityManager.instance.registerConductor(this); + } + } + + @Override + public void refreshConnectedBlocks() + { + if (this.worldObj != null) + { + for (byte i = 0; i < 6; i++) + { + this.updateConnection(Vector3.getConnectorFromSide(this.worldObj, Vector3.get(this), ForgeDirection.getOrientation(i)), ForgeDirection.getOrientation(i)); + } + } + } + + @Override + public World getWorld() + { + return this.worldObj; + } + + @Override + public boolean canConnect(ForgeDirection side) + { + return true; + } +} diff --git a/src/common/universalelectricity/prefab/multiblock/BlockMulti.java b/src/common/universalelectricity/prefab/multiblock/BlockMulti.java new file mode 100644 index 00000000..5eb1052a --- /dev/null +++ b/src/common/universalelectricity/prefab/multiblock/BlockMulti.java @@ -0,0 +1,99 @@ +package universalelectricity.prefab.multiblock; + +import java.util.Random; + +import net.minecraft.src.Block; +import net.minecraft.src.BlockContainer; +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.ItemStack; +import net.minecraft.src.MovingObjectPosition; +import net.minecraft.src.TileEntity; +import net.minecraft.src.World; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.Vector3; + +public class BlockMulti extends BlockContainer +{ + public BlockMulti(int id) + { + super(id, UniversalElectricity.machine); + this.setHardness(0.8F); + this.setBlockName("MultiBlock"); + } + + public void makeFakeBlock(World worldObj, Vector3 position, Vector3 mainBlock) + { + worldObj.setBlockWithNotify(position.intX(), position.intY(), position.intZ(), this.blockID); + ((TileEntityMulti) worldObj.getBlockTileEntity(position.intX(), position.intY(), position.intZ())).setMainBlock(mainBlock); + } + + @Override + public void breakBlock(World par1World, int x, int y, int z, int par5, int par6) + { + TileEntityMulti tileEntity = (TileEntityMulti) par1World.getBlockTileEntity(x, y, z); + tileEntity.onBlockRemoval(); + super.breakBlock(par1World, x, y, z, par5, par6); + } + + /** + * Called when the block is right clicked by the player. This modified + * version detects electric items and wrench actions on your machine block. + * Do not override this function. Use machineActivated instead! (It does the + * same thing) + */ + @Override + public boolean onBlockActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9) + { + TileEntityMulti tileEntity = (TileEntityMulti) par1World.getBlockTileEntity(x, y, z); + return tileEntity.onBlockActivated(par1World, x, y, z, par5EntityPlayer); + } + + /** + * Returns the quantity of items to drop on block destruction. + */ + @Override + public int quantityDropped(Random par1Random) + { + return 0; + } + + @Override + public int getRenderType() + { + return -1; + } + + @Override + public boolean isOpaqueCube() + { + return false; + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + + @Override + public TileEntity createNewTileEntity(World var1) + { + return new TileEntityMulti(); + } + + @Override + public ItemStack getPickBlock(MovingObjectPosition target, World par1World, int x, int y, int z) + { + TileEntity tileEntity = par1World.getBlockTileEntity(x, y, z); + Vector3 mainBlockPosition = ((TileEntityMulti) tileEntity).mainBlockPosition; + + if (mainBlockPosition != null) + { + int mainBlockID = par1World.getBlockId(mainBlockPosition.intX(), mainBlockPosition.intY(), mainBlockPosition.intZ()); + + if (mainBlockID > 0) { return Block.blocksList[mainBlockID].getPickBlock(target, par1World, mainBlockPosition.intX(), mainBlockPosition.intY(), mainBlockPosition.intZ()); } + } + + return null; + } +} \ No newline at end of file diff --git a/src/common/universalelectricity/prefab/multiblock/IBlockActivate.java b/src/common/universalelectricity/prefab/multiblock/IBlockActivate.java new file mode 100644 index 00000000..bbac0a96 --- /dev/null +++ b/src/common/universalelectricity/prefab/multiblock/IBlockActivate.java @@ -0,0 +1,17 @@ +package universalelectricity.prefab.multiblock; + +import net.minecraft.src.EntityPlayer; + +/** + * A general interface to be implemented by anything that needs it. + * + * @author Calclavia + * + */ +public interface IBlockActivate +{ + /** + * Called when activated + */ + public boolean onActivated(EntityPlayer entityPlayer); +} \ No newline at end of file diff --git a/src/common/universalelectricity/prefab/multiblock/IMultiBlock.java b/src/common/universalelectricity/prefab/multiblock/IMultiBlock.java new file mode 100644 index 00000000..8207bd62 --- /dev/null +++ b/src/common/universalelectricity/prefab/multiblock/IMultiBlock.java @@ -0,0 +1,30 @@ +package universalelectricity.prefab.multiblock; + +import net.minecraft.src.TileEntity; +import universalelectricity.core.Vector3; + +/** + * Interface to be applied to tile entity blocks that occupies more than one + * block space. Useful for large machines. + * + * @author Calclavia + * + */ +public interface IMultiBlock extends IBlockActivate +{ + /** + * Called when this multiblock is created + * + * @param placedPosition + * - The position the block was placed at + */ + public void onCreate(Vector3 placedPosition); + + /** + * Called when one of the multiblocks of this block is destroyed + * + * @param callingBlock + * - The tile entity who called the onDestroy function + */ + public void onDestroy(TileEntity callingBlock); +} diff --git a/src/common/universalelectricity/prefab/multiblock/TileEntityMulti.java b/src/common/universalelectricity/prefab/multiblock/TileEntityMulti.java new file mode 100644 index 00000000..aeb56258 --- /dev/null +++ b/src/common/universalelectricity/prefab/multiblock/TileEntityMulti.java @@ -0,0 +1,120 @@ +package universalelectricity.prefab.multiblock; + +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.INetworkManager; +import net.minecraft.src.NBTTagCompound; +import net.minecraft.src.Packet; +import net.minecraft.src.Packet250CustomPayload; +import net.minecraft.src.TileEntity; +import net.minecraft.src.World; +import universalelectricity.core.Vector3; +import universalelectricity.prefab.network.IPacketReceiver; +import universalelectricity.prefab.network.PacketManager; + +import com.google.common.io.ByteArrayDataInput; + +/** + * This is a multiblock to be used for blocks that are bigger than one block. + * + * @author Calclavia + * + */ +public class TileEntityMulti extends TileEntity implements IPacketReceiver +{ + // The the position of the main block + public Vector3 mainBlockPosition; + + public void setMainBlock(Vector3 mainBlock) + { + this.mainBlockPosition = mainBlock; + + if (!this.worldObj.isRemote) + { + PacketManager.sendPacketToClients(this.getDescriptionPacket()); + } + } + + @Override + public Packet getDescriptionPacket() + { + return PacketManager.getPacket("BasicComponents", this, this.mainBlockPosition.x, this.mainBlockPosition.y, this.mainBlockPosition.z); + } + + public void onBlockRemoval() + { + if (mainBlockPosition != null) + { + TileEntity tileEntity = this.worldObj.getBlockTileEntity((int) mainBlockPosition.x, (int) mainBlockPosition.y, (int) mainBlockPosition.z); + + if (tileEntity != null && tileEntity instanceof IMultiBlock) + { + IMultiBlock mainBlock = (IMultiBlock) tileEntity; + + if (mainBlock != null) + { + mainBlock.onDestroy(this); + } + } + } + } + + public boolean onBlockActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer) + { + if (mainBlockPosition != null) + { + TileEntity tileEntity = this.worldObj.getBlockTileEntity((int) mainBlockPosition.x, (int) mainBlockPosition.y, (int) mainBlockPosition.z); + + if (tileEntity != null) + { + if (tileEntity instanceof IMultiBlock) { return ((IMultiBlock) tileEntity).onActivated(par5EntityPlayer); } + } + } + + return false; + } + + /** + * Reads a tile entity from NBT. + */ + @Override + public void readFromNBT(NBTTagCompound par1NBTTagCompound) + { + super.readFromNBT(par1NBTTagCompound); + + this.mainBlockPosition = Vector3.readFromNBT("mainBlockPosition", par1NBTTagCompound); + } + + /** + * Writes a tile entity to NBT. + */ + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) + { + super.writeToNBT(par1NBTTagCompound); + + this.mainBlockPosition.writeToNBT("mainBlockPosition", par1NBTTagCompound); + } + + /** + * Determines if this TileEntity requires update calls. + * + * @return True if you want updateEntity() to be called, false if not + */ + public boolean canUpdate() + { + return false; + } + + @Override + public void handlePacketData(INetworkManager network, int packetType, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) + { + try + { + this.mainBlockPosition = new Vector3(dataStream.readDouble(), dataStream.readDouble(), dataStream.readDouble()); + } + catch (Exception e) + { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/src/common/universalelectricity/prefab/network/ConnectionHandler.java b/src/common/universalelectricity/prefab/network/ConnectionHandler.java new file mode 100644 index 00000000..c95f95ab --- /dev/null +++ b/src/common/universalelectricity/prefab/network/ConnectionHandler.java @@ -0,0 +1,88 @@ +package universalelectricity.prefab.network; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.server.MinecraftServer; +import net.minecraft.src.INetworkManager; +import net.minecraft.src.NetHandler; +import net.minecraft.src.NetLoginHandler; +import net.minecraft.src.Packet1Login; +import cpw.mods.fml.common.network.IConnectionHandler; +import cpw.mods.fml.common.network.Player; + +public class ConnectionHandler implements IConnectionHandler +{ + private static final List simpleConnectionHandlers = new ArrayList(); + + public static enum ConnectionType + { + LOGIN_SERVER, LOGIN_CLIENT, RECEIVED, OPEN_REMOTE, OPEN_LOCAL, CLOSED + } + + /** + * Registers a simple connection handler + * + * @param tileEntity + */ + public static void registerConnectionHandler(ISimpleConnectionHandler tileEntity) + { + simpleConnectionHandlers.add(tileEntity); + } + + @Override + public void playerLoggedIn(Player player, NetHandler netHandler, INetworkManager manager) + { + for (ISimpleConnectionHandler handler : simpleConnectionHandlers) + { + handler.handelConnection(ConnectionType.LOGIN_SERVER, player, netHandler, manager); + } + } + + @Override + public void clientLoggedIn(NetHandler clientHandler, INetworkManager manager, Packet1Login login) + { + for (ISimpleConnectionHandler handler : simpleConnectionHandlers) + { + handler.handelConnection(ConnectionType.LOGIN_CLIENT, clientHandler, manager, login); + } + } + + @Override + public String connectionReceived(NetLoginHandler netHandler, INetworkManager manager) + { + for (ISimpleConnectionHandler handler : simpleConnectionHandlers) + { + handler.handelConnection(ConnectionType.RECEIVED, netHandler, manager); + } + + return null; + } + + @Override + public void connectionOpened(NetHandler netClientHandler, String server, int port, INetworkManager manager) + { + for (ISimpleConnectionHandler handler : simpleConnectionHandlers) + { + handler.handelConnection(ConnectionType.OPEN_REMOTE, netClientHandler, server, port, manager); + } + } + + @Override + public void connectionOpened(NetHandler netClientHandler, MinecraftServer server, INetworkManager manager) + { + for (ISimpleConnectionHandler handler : simpleConnectionHandlers) + { + handler.handelConnection(ConnectionType.OPEN_LOCAL, netClientHandler, server, manager); + } + } + + @Override + public void connectionClosed(INetworkManager manager) + { + for (ISimpleConnectionHandler handler : simpleConnectionHandlers) + { + handler.handelConnection(ConnectionType.CLOSED, manager); + } + } +} diff --git a/src/common/universalelectricity/prefab/network/ISimpleConnectionHandler.java b/src/common/universalelectricity/prefab/network/ISimpleConnectionHandler.java new file mode 100644 index 00000000..472e8475 --- /dev/null +++ b/src/common/universalelectricity/prefab/network/ISimpleConnectionHandler.java @@ -0,0 +1,14 @@ +package universalelectricity.prefab.network; + +import universalelectricity.prefab.network.ConnectionHandler.ConnectionType; + +public interface ISimpleConnectionHandler +{ + /** + * Called when a player logs in. Use this to reset some tile entities + * variables if you need to. + * + * @param player + */ + public void handelConnection(ConnectionType type, Object... data); +} diff --git a/src/common/universalelectricity/prefab/ore/OreGenBase.java b/src/common/universalelectricity/prefab/ore/OreGenBase.java new file mode 100644 index 00000000..343f8edc --- /dev/null +++ b/src/common/universalelectricity/prefab/ore/OreGenBase.java @@ -0,0 +1,104 @@ +package universalelectricity.prefab.ore; + +import java.util.Random; + +import net.minecraft.src.Block; +import net.minecraft.src.IChunkProvider; +import net.minecraft.src.ItemStack; +import net.minecraft.src.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.oredict.OreDictionary; +import universalelectricity.core.UEConfig; +import universalelectricity.core.UniversalElectricity; + +/** + * This class is used for storing ore generation data. If you are too lazy to + * generate your own ores, you can do + * {@link #OreGenerator.ORES_TO_GENERATE.add()} to add your ore to the list of + * ores to generate. + * + * @author Calclavia + * + */ +public abstract class OreGenBase +{ + public String name; + + public String oreDictionaryName; + + public boolean shouldGenerate; + + public int blockIndexTexture; + + public ItemStack oreStack; + + public int oreID; + + public int oreMeta; + + /** + * What harvest level does this machine need to be acquired? + */ + public int harvestLevel; + + /** + * The predefined tool classes are "pickaxe", "shovel", "axe". You can add + * others for custom tools. + */ + public String harvestTool; + + /** + * @param name + * - The name of the ore for display + * @param textureFile + * - The 16x16 png texture of your ore to override + * @param minGenerateLevel + * - The highest generation level of your ore + * @param maxGenerateLevel + * - The lowest generation level of your ore + * @param amountPerChunk + * - The amount of ores to generate per chunk + * @param amountPerBranch + * - The amount of ores to generate in a clutter. E.g coal + * generates with a lot of other coal next to it. How much do you + * want? + */ + public OreGenBase(String name, String oreDiectionaryName, ItemStack stack, String harvestTool, int harvestLevel) + { + this.name = name; + this.shouldGenerate = false; + this.harvestTool = harvestTool; + this.harvestLevel = harvestLevel; + this.oreDictionaryName = oreDiectionaryName; + this.oreStack = stack; + this.oreID = stack.itemID; + this.oreMeta = stack.getItemDamage(); + + OreDictionary.registerOre(oreDictionaryName, stack); + MinecraftForge.setBlockHarvestLevel(Block.blocksList[stack.itemID], stack.getItemDamage(), harvestTool, harvestLevel); + } + + public OreGenBase enable() + { + this.shouldGenerate = shouldGenerateOre(name); + return this; + } + + // You may inherit from this class and change this function if you want a + // custom texture render for your ore. + public int getBlockTextureFromSide(int side) + { + return this.blockIndexTexture; + } + + // Checks the config file and see if Universal Electricity should generate + // this ore + private static boolean shouldGenerateOre(String oreName) + { + return UEConfig.getConfigData(UniversalElectricity.CONFIGURATION, "Generate " + oreName, true); + } + + public abstract void generate(World world, Random random, int varX, int varZ); + + public abstract boolean isOreGeneratedInWorld(World world, IChunkProvider chunkGenerator); +} diff --git a/src/common/universalelectricity/prefab/ore/OreGenReplace.java b/src/common/universalelectricity/prefab/ore/OreGenReplace.java new file mode 100644 index 00000000..3be688e7 --- /dev/null +++ b/src/common/universalelectricity/prefab/ore/OreGenReplace.java @@ -0,0 +1,134 @@ +package universalelectricity.prefab.ore; + +import java.util.Random; + +import net.minecraft.src.ChunkProviderEnd; +import net.minecraft.src.ChunkProviderGenerate; +import net.minecraft.src.ChunkProviderHell; +import net.minecraft.src.IChunkProvider; +import net.minecraft.src.ItemStack; +import net.minecraft.src.MathHelper; +import net.minecraft.src.World; + +/** + * This class is used for storing ore generation data. If you are too lazy to + * generate your own ores, you can do + * {@link #OreGenerator.ORES_TO_GENERATE.add()} to add your ore to the list of + * ores to generate. + * + * @author Calclavia + * + */ +public class OreGenReplace extends OreGenBase +{ + + public int minGenerateLevel; + public int maxGenerateLevel; + public int amountPerChunk; + public int amountPerBranch; + public int replaceID; + + public boolean generateSurface; + public boolean generateNether; + public boolean generateEnd; + + /** + * @param name + * - The name of the ore for display + * @param textureFile + * - The 16x16 png texture of your ore to override + * @param minGenerateLevel + * - The highest generation level of your ore + * @param maxGenerateLevel + * - The lowest generation level of your ore + * @param amountPerChunk + * - The amount of ores to generate per chunk + * @param amountPerBranch + * - The amount of ores to generate in a clutter. E.g coal + * generates with a lot of other coal next to it. How much do you + * want? + */ + public OreGenReplace(String name, String oreDiectionaryName, ItemStack stack, int replaceID, int minGenerateLevel, int maxGenerateLevel, int amountPerChunk, int amountPerBranch, String harvestTool, int harvestLevel) + { + super(name, oreDiectionaryName, stack, harvestTool, harvestLevel); + this.minGenerateLevel = minGenerateLevel; + this.maxGenerateLevel = maxGenerateLevel; + this.amountPerChunk = amountPerChunk; + this.amountPerBranch = amountPerBranch; + this.replaceID = replaceID; + } + + public void generate(World world, Random random, int varX, int varZ) + { + + for (int i = 0; i < this.amountPerChunk; i++) + { + int x = varX + random.nextInt(16); + int z = varZ + random.nextInt(16); + int y = random.nextInt(this.maxGenerateLevel - this.minGenerateLevel) + this.minGenerateLevel; + generateReplace(world, random, x, y, z); + } + } + + public boolean generateReplace(World par1World, Random par2Random, int par3, int par4, int par5) + { + float var6 = par2Random.nextFloat() * (float) Math.PI; + double var7 = (double) ((float) (par3 + 8) + MathHelper.sin(var6) * (float) this.amountPerBranch / 8.0F); + double var9 = (double) ((float) (par3 + 8) - MathHelper.sin(var6) * (float) this.amountPerBranch / 8.0F); + double var11 = (double) ((float) (par5 + 8) + MathHelper.cos(var6) * (float) this.amountPerBranch / 8.0F); + double var13 = (double) ((float) (par5 + 8) - MathHelper.cos(var6) * (float) this.amountPerBranch / 8.0F); + double var15 = (double) (par4 + par2Random.nextInt(3) - 2); + double var17 = (double) (par4 + par2Random.nextInt(3) - 2); + + for (int var19 = 0; var19 <= this.amountPerBranch; ++var19) + { + double var20 = var7 + (var9 - var7) * (double) var19 / (double) this.amountPerBranch; + double var22 = var15 + (var17 - var15) * (double) var19 / (double) this.amountPerBranch; + double var24 = var11 + (var13 - var11) * (double) var19 / (double) this.amountPerBranch; + double var26 = par2Random.nextDouble() * (double) this.amountPerBranch / 16.0D; + double var28 = (double) (MathHelper.sin((float) var19 * (float) Math.PI / (float) this.amountPerBranch) + 1.0F) * var26 + 1.0D; + double var30 = (double) (MathHelper.sin((float) var19 * (float) Math.PI / (float) this.amountPerBranch) + 1.0F) * var26 + 1.0D; + int var32 = MathHelper.floor_double(var20 - var28 / 2.0D); + int var33 = MathHelper.floor_double(var22 - var30 / 2.0D); + int var34 = MathHelper.floor_double(var24 - var28 / 2.0D); + int var35 = MathHelper.floor_double(var20 + var28 / 2.0D); + int var36 = MathHelper.floor_double(var22 + var30 / 2.0D); + int var37 = MathHelper.floor_double(var24 + var28 / 2.0D); + + for (int var38 = var32; var38 <= var35; ++var38) + { + double var39 = ((double) var38 + 0.5D - var20) / (var28 / 2.0D); + + if (var39 * var39 < 1.0D) + { + for (int var41 = var33; var41 <= var36; ++var41) + { + double var42 = ((double) var41 + 0.5D - var22) / (var30 / 2.0D); + + if (var39 * var39 + var42 * var42 < 1.0D) + { + for (int var44 = var34; var44 <= var37; ++var44) + { + double var45 = ((double) var44 + 0.5D - var24) / (var28 / 2.0D); + + int block = par1World.getBlockId(var38, var41, var44); + if (var39 * var39 + var42 * var42 + var45 * var45 < 1.0D && (this.replaceID == 0 || block == this.replaceID)) + { + par1World.setBlockAndMetadata(var38, var41, var44, this.oreID, this.oreMeta); + } + } + } + } + } + } + } + + return true; + } + + @Override + public boolean isOreGeneratedInWorld(World world, IChunkProvider chunkGenerator) + { + return ((this.generateSurface && chunkGenerator instanceof ChunkProviderGenerate) || (this.generateNether && chunkGenerator instanceof ChunkProviderHell) || (this.generateEnd && chunkGenerator instanceof ChunkProviderEnd)); + } +} diff --git a/src/common/universalelectricity/prefab/ore/OreGenReplaceStone.java b/src/common/universalelectricity/prefab/ore/OreGenReplaceStone.java new file mode 100644 index 00000000..463fa2bc --- /dev/null +++ b/src/common/universalelectricity/prefab/ore/OreGenReplaceStone.java @@ -0,0 +1,18 @@ +package universalelectricity.prefab.ore; + +import net.minecraft.src.ItemStack; + +public class OreGenReplaceStone extends OreGenReplace +{ + public OreGenReplaceStone(String name, String oreDiectionaryName, ItemStack stack, int replaceID, int minGenerateLevel, int maxGenerateLevel, int amountPerChunk, int amountPerBranch, String harvestTool, int harvestLevel) + { + super(name, oreDiectionaryName, stack, 1, minGenerateLevel, maxGenerateLevel, amountPerChunk, amountPerBranch, harvestTool, harvestLevel); + this.generateSurface = true; + } + + // A simplified version of the constructor + public OreGenReplaceStone(String name, String oreDiectionaryName, ItemStack stack, int replaceID, int maxGenerateLevel, int amountPerChunk, int amountPerBranch) + { + this(name, oreDiectionaryName, stack, 0, replaceID, maxGenerateLevel, amountPerChunk, amountPerBranch, "pickaxe", 1); + } +} \ No newline at end of file diff --git a/src/common/universalelectricity/prefab/ore/OreGenerator.java b/src/common/universalelectricity/prefab/ore/OreGenerator.java new file mode 100644 index 00000000..d116b8c4 --- /dev/null +++ b/src/common/universalelectricity/prefab/ore/OreGenerator.java @@ -0,0 +1,75 @@ +package universalelectricity.prefab.ore; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import net.minecraft.src.IChunkProvider; +import net.minecraft.src.World; +import cpw.mods.fml.common.IWorldGenerator; +import cpw.mods.fml.common.registry.GameRegistry; + +public class OreGenerator implements IWorldGenerator +{ + public static boolean isInitiated = false; + + /** + * Add your ore data to this list of ores for it to automatically generate! + * No hassle indeed! + */ + private static final List ORES_TO_GENERATE = new ArrayList(); + + /** + * Adds an ore to the ore generate list. Do this in pre-init. + */ + public static void addOre(OreGenBase data) + { + if (!isInitiated) + { + GameRegistry.registerWorldGenerator(new OreGenerator()); + } + + ORES_TO_GENERATE.add(data); + } + + /** + * Checks to see if this ore + * + * @param oreName + * @return + */ + public static boolean oreExists(String oreName) + { + for (OreGenBase ore : ORES_TO_GENERATE) + { + if (ore.oreDictionaryName == oreName) { return true; } + } + + return false; + } + + /** + * Removes an ore to the ore generate list. Do this in init. + */ + public static void removeOre(OreGenBase data) + { + ORES_TO_GENERATE.remove(data); + } + + @Override + public void generate(Random rand, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) + { + chunkX = chunkX << 4; + chunkZ = chunkZ << 4; + + // Checks to make sure this is the normal world + for (OreGenBase oreData : ORES_TO_GENERATE) + { + if (oreData.shouldGenerate && oreData.isOreGeneratedInWorld(world, chunkGenerator)) + { + oreData.generate(world, rand, chunkX, chunkZ); + } + + } + } +} diff --git a/src/common/universalelectricity/prefab/potion/CustomPotion.java b/src/common/universalelectricity/prefab/potion/CustomPotion.java new file mode 100644 index 00000000..fc13deb9 --- /dev/null +++ b/src/common/universalelectricity/prefab/potion/CustomPotion.java @@ -0,0 +1,41 @@ +package universalelectricity.prefab.potion; + +import net.minecraft.src.Potion; +import cpw.mods.fml.common.registry.LanguageRegistry; + +public abstract class CustomPotion extends Potion +{ + /** + * Creates a new type of potion + * + * @param id + * - The ID of this potion. Make it greater than 20. + * @param isBadEffect + * - Is this potion a good potion or a bad one? + * @param color + * - The color of this potion. + * @param name + * - The name of this potion. + */ + public CustomPotion(int id, boolean isBadEffect, int color, String name) + { + super(id, isBadEffect, color); + this.setPotionName("potion." + name); + LanguageRegistry.instance().addStringLocalization(this.getName(), name); + } + + @Override + public Potion setIconIndex(int par1, int par2) + { + super.setIconIndex(par1, par2); + return this; + } + + /** + * You must register all your potion effects during mod initialization! + */ + public void register() + { + Potion.potionTypes[this.getId()] = this; + } +} diff --git a/src/common/universalelectricity/prefab/potion/CustomPotionEffect.java b/src/common/universalelectricity/prefab/potion/CustomPotionEffect.java new file mode 100644 index 00000000..fedd88cc --- /dev/null +++ b/src/common/universalelectricity/prefab/potion/CustomPotionEffect.java @@ -0,0 +1,41 @@ +package universalelectricity.prefab.potion; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.src.ItemStack; +import net.minecraft.src.Potion; +import net.minecraft.src.PotionEffect; + +public class CustomPotionEffect extends PotionEffect +{ + public CustomPotionEffect(int potionID, int duration, int amplifier) + { + super(potionID, duration, amplifier); + } + + public CustomPotionEffect(Potion potion, int duration, int amplifier) + { + this(potion.getId(), duration, amplifier); + } + + /** + * Creates a potion effect with custom curable items. + * + * @param curativeItems + * - ItemStacks that can cure this potion effect + */ + public CustomPotionEffect(int potionID, int duration, int amplifier, List curativeItems) + { + super(potionID, duration, amplifier); + + if (curativeItems == null) + { + this.setCurativeItems(new ArrayList()); + } + else + { + this.setCurativeItems(curativeItems); + } + } +} diff --git a/src/minecraft/assemblyline/textures/BeltMid.png b/src/minecraft/assemblyline/textures/BeltMid.png new file mode 100644 index 0000000000000000000000000000000000000000..36c17346f2d97d20645603abe9a702cb9c1bbf9d GIT binary patch literal 373 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=jKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!octV$(qA@pf`q<$x;TbZ+1W;QH}liI*<9OlXP@3U z*YG-Dt3b#Ph7~KBCj?y*c4lA_XkcJbU|{5MaL{9X{p;?=%umyw|EXFNrgyz9smFCc z&)Ls!X3b+hx43rQ)QRp6D>oldT)1_j`+-7+q@HO(K^%_d@7~XIDt_bqGWcVCYWEqj z$o%)!FKQpKdw$z_a_>Efs!132He8%`+QwmT>Ao2oy4IhS2?%a5T_V8f!vFWrM!Sai w)}Qep>ycanVm7pMtk`GQu$9pT3`B1+rty7Qr`sY^2MhoPPgg&ebxsLQ09#s-rvLx| literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/BeltSingle.png b/src/minecraft/assemblyline/textures/BeltSingle.png new file mode 100644 index 0000000000000000000000000000000000000000..953cfb33f0fd02496c046e3f051eb5bdae8bbcde GIT binary patch literal 387 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=jKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!octVO5`XtpyaJlS?CIhdQgQ3; zOi#XM10Dw1Ba@xtt^~^+=@e)Em%^v36{9uLe6MCI={y~b()r1X!`E< z^Ee5o3Ej*J%a|qvO;T@QlmH`Dwlkl&oyg`@2(9KuVlf&`c8}GLBbDlrt+r5?PyF|>%TmLvC3srM>F44U5 z>tJD(h(_-DYsbP0 Hl+XkK12&Pe literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/BeltTexture.png b/src/minecraft/assemblyline/textures/BeltTexture.png new file mode 100644 index 0000000000000000000000000000000000000000..bf3561482d31064e946cb8d3d332f1972542e9fb GIT binary patch literal 791 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!Tug$>ip#cgEMs6`n(pc17*cWT z?On&9+Xf;Hi5DO8r5@ZR`|Z$l53xCi*-u&S(wJ_rli{#g_Y;vUsvF8+98{N=wk^- zdHnmsWySORmN%>PGAb|>{PjL?{<*yH)!Va7#Th2QzwX!ZL}D7ll!ONF+*ToB0|qXG z16jreYbPA3uIMp?2+|kVM7@2_BCbA7n@{8!#|8FiI@Q+GL!q-xai&q(C_|qBKR%kNF@E^bVWZs&{-&PF&wb>;Ch4MQZG+X!*s!k=GZ^jWz70N8!cRYtGE`h?hNUkF1E308iTB3uX>|aV;SQ+C8#4C7=aN4Ha+7EgH_Y3 zBbOc6BFxw?2p(bJNf2M4+yV3lAM*>2q=uX#dls$johdnNA0Gy{vM~HLpU0xbY%a%e z>HyCJJ|n2hBtWM5N;w#N>|McPbfCzxAx!}2@ZAh&6@U_7B@(PUuHWHNst|i7w7&gg fmIN?eVt_;X+t@M|HZS4i14((h`njxgN@xNA3a%|y literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/CoalGenerator.png b/src/minecraft/assemblyline/textures/CoalGenerator.png new file mode 100644 index 0000000000000000000000000000000000000000..ac81171315361eec20cf1f7eb53d5f6cdff48132 GIT binary patch literal 3762 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 WU59UubRrj*0?^SgRIgOC4f_YtG&Dv4 literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/ConveyorBelt.png b/src/minecraft/assemblyline/textures/ConveyorBelt.png new file mode 100644 index 0000000000000000000000000000000000000000..5666d206144b8bd6c5c5ff7b56627e217931d84e GIT binary patch literal 401 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=jKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!oE&UYT71)suL4aG^mK6yskrs_ zdSG9Zfk^Aa;K!3TXn$I{&V61)V5-uSS3O|=9vix52DSPSieWx#e-@Dp~G5BiT)aakSDhXPg#i4b^oIiXH z#Z0{)!sMkjtwEsasKnE~*Ujf!_Me~fdZ}65Qnozvm~*@T%B^}-^sMMyh{o0xwRgFm zpL>2QDtgH#$F$}(TYuYaiTly4^84nKbNvQernEd0F4*!gSJq+j+y}-C+Htc@6V9?k ixN52}0s{sP4(xentu)iz(Moz6NX*mK&t;ucLK6Tuv!KNQ literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/ConveyorBeltF.png b/src/minecraft/assemblyline/textures/ConveyorBeltF.png new file mode 100644 index 0000000000000000000000000000000000000000..96aac9bf6e2b96da9195c48d14570235b33ac9d4 GIT binary patch literal 402 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=jKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!oE&UY@)0WAzX44V@^o<+7^2Aq5+TE z@&9p7^)L2LH|CIIcz$P{xs~ta2@FCGOdbw}oICE%H!s_J>+0t^S$jvOW#^mAVt<$V z-RD0kG+CSR;Mvx#VbeqBg;%}ZeS*=zmG{6V;W^>ec{95%Sshg2jPQ1PRT*EyG|kf^ z^yhvrhiAD4=TA@A8aB81(cbC0^9^sOKlr+3NuxEd@aH`FTYS?)M1_r~Cogka=bHOj zO2B%4p_ot9hhbVqF{wXVt9y+%ZB^>lFzskrs_ znj>G6fk5lSl@C2`2=CN--YBZR>P}{i0!!z`3u0@&{19#ZRy2F3fy0r{%_Ww{Nx$mJOB<>?bk^1ynHg z6#MP{p0swV?(vA|>)dxgtb5(_;IxduFF$+d(4JzwiUplNwcnWD$jNIm!nsl_XP(_U`bR5PZFK8SmFx z`D;7gU93(z7g_yaUc;12Pkwy8?uQ&DNdR{FN<>mC5)8f{LEqn`3&Q0JvApZWW o)Q7Vy5w4mljKI)=g9DrD7!IdRN{m~iY!4FjboFyt=akR{079Rl%K!iX literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/Grey64.png b/src/minecraft/assemblyline/textures/Grey64.png new file mode 100644 index 0000000000000000000000000000000000000000..999e6c052e3a9128197b3e86f0919dbe4c916180 GIT binary patch literal 534 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1SEZ8zRdwrjKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1quc4XZs}978JN-d=X(WnkcGK47{2>&YGb#tuxc z*Dhx3yVSg%;Rh#I07DML<7fxQ4U9ecjI0OP4EC{#Fi0QxAvP*Ow;-`Nz|3prI;l$D R(hL}v44$rjF6*2UngIJipO63m literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/dropbox.png b/src/minecraft/assemblyline/textures/dropbox.png new file mode 100644 index 0000000000000000000000000000000000000000..02f2d9655fd3d33747e27e6c7ae010da0f6bf0f4 GIT binary patch literal 950 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!Tzu?;#;+KCpE58on|Zo8hE&{o zd)MCYv4cp%$LSqS&N(kty5!>$Nt)`sjiN$hgnxluweYMQn!$I)fqAA z_nZC%+q50oSU=yTv6J&tjm>`Z&qjSO7`r`}990QgV3<6;fkACpnwcN!e=B>ZY-zdWnKb5&;<|2(a+10B~ zo#1tBSfp`J=FRuM#q3NvY7<|{JpA^|Oi8J3Z^hZlP}e|_!asj4{N|n7wW*^c?dqAN zMM^JY_%4_@P6_yC!`{(hVeWTWWIa=w4Y=)l0^(XeaH?^V|y*Sp=0 z;IXRIvfuh|UAVEX0k25xLEY61e;Js?7RddXW3W%^j7$&Gn*1_8zmmwV<DrWUMzV|#!0 zcFx>yFV=1h&u3>j@s@SZt^Zeem7?^Y`=wvL;`HdC*NyII2kB0BdB%D5!RJo%N3SZq z^DU;KU+&0Te(5^+3$lZ-v566!ivqVi@{R;sZIV4 z?emhy)HwuZ%G&HaJLBmdl?E*|eJlskSXVs%I(uF+=g#UcWtKOXgf{rGRFpnBK1=Z7 z?OE?XT&`cFA^^1O!cm!oe~WgfZ+q7HGSp~eo}u9+;V*_vF>!jqUV@sgHg?p@4{*u?k7^*8_itq{F;eDUkosZ|vc+~1vh7}C>EmsGrX#An6i@s&-C r(a--sPt{-6&)`4?<{bpMA+VpZR$9eJ?d%3neq``;^>bP0l+XkK2Y7pe literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/ejector.png b/src/minecraft/assemblyline/textures/ejector.png new file mode 100644 index 0000000000000000000000000000000000000000..feba2e00164af67757833c7dcc1fc4d71ec8f3c4 GIT binary patch literal 1054 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sDEfH31!Z9ZuR2IkG4E{-7;ac^fkP7*fcab5nrAcpZAQ+J5i zomN$yhc+A9q+3cfx+Zw8GA+72>1+I|Wk8_&x_sEo5LgHRX~z3q#GmsgkS=sa`LI znHcQupXy<1Fk1SBlaXP5eySUz!_1&xEes9kw;L^HSm2{s>%?&2dGyRchJa;L>=YRu zd|rEIMQjdH#(#By)#k0Kf2TTr6>b_|;{(O8ccmrETy|AxrWAuS5 zPqY2^RSMpi$0VpE`#?RO?fYzA*MGzKXpJa?F{g6)Y-Wap&nw@AG6ZbfVwQ-Dt;pZBO-}1((EswQd)ou5 z&j$Wwy#C?rg1|PWhPSyXR{RCOZR=it|Mk9Cnzg~#E_@@KK>C6=x(<8RrTu*7y1-IN z-0vyF_J)laqJmXtRHrZZP@s=t$Gzr&D_z{}3Cz)kk97Q=zu z*xp8lfW>`zq6`nVtvlwxup-cXI~PMiba=7?!<7|_qgfettX*v=z>sz2;@YOY4BJah z+4$`FKb$Z#n~>CCB+I$m?`*YAjy4;^5rzX&3dg>iY-Vzp6?8;}iNSE+@|mIxm!>GG z2{Lqiv^~3~hQ}wkYlceNPpO0`3hZOR`-au?dTT@fw^cwb z&pt=}S^xgN-QPd|eja^qy0rTL@2`)&eYTysb+qyF&L7K*7smgwJOAxNefIMQru&&| zxL$mkH%nck`#@#ZRn_2P_8;FK-mT}{^Yh0_ZzmSn*9@`=Ywo{HV{Rx>m7FcW(DT*$ zZVtnQbt=iiObr|Bme1y8xHL5-$BDt<+WV5tj1Idd_4sly9Q!plZ(HhJmRB=H{duZ) z-Iklpcj4W`D}raL8G~1={A}mDz21s-{F#G;n%r#GR>NSfqAZ{i(^Q| zt+#hCPMmEZ;&8G3c<4;CI~>Me92GCH?a=vjRAq8XWX{^$NUP`i_W8#xc5$n8sMSR? zTP)Ii+q~v=*5AVmT`!v)b$O8T@o??5RLy5SJAYa;Y`=ZhoX5H?v7@7-P{#hB&x0?| z<#p;-oIa@t^aTrp0D}X_J4lQlF3-#VTv+#dQhLn#>ob;VuC~m*{Y$!)K_=Ef^Vh!q z%vqaeJx9eUYn9hEF)6s#!g@MI^ z1xh_g{HOk)T`%gtRf91@V4;9OLzE@+0ab^G-CtMV|0HIAj^PLk%YjGij2nJ9GU(I^ zFm%fUx$Wz33TnLJXkpkhMYeIlBZeGqHCJ70rp9Uphsbn>J| zgm=(=#=22CpdzcU%2aUUy4O;I4^J9eBuKP%bVwX8jCR&zL=8ctFnyp}HlOXyF1?@Z zIqUD69iQX=yyESz*-RU188wS)dbeB7H$5J_3XgsVVD!i^2{0^h+Wnhx$}g$>V!Ld< z^P7KH6<9OPoP2oBoiY}!mtP;0u^6fUwk%^Q;>Qx9aObcb0L8ghin~Jbrum0I-w-@8 z=gspQf-ij28E%VDIMiqUY{|Ke$`h)w#3?+M6&Uy!IT!*ILDv73nU`MfuJ9mU^)1H} zA%;85z+|-I)H`2?-AuE=Zev}i1~z%!cA&|H#kY_G7&GB;G&loOQpkyQ2cD(aw?E&g zZE)x0x&sX$*Ep0e|G(72-Q}{$*^u*nn`LrIgJ@{{T;MMBZ_G^5= ed_^1Zry*Y9mD|d-)6Y!WmF=d#Wzp$Pz&6Gct{ literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/gui_ejector.png b/src/minecraft/assemblyline/textures/gui_ejector.png new file mode 100644 index 0000000000000000000000000000000000000000..b9b396faae2b358afc0a6a55d85c64bb22cff4d5 GIT binary patch literal 3800 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 literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/injector.png b/src/minecraft/assemblyline/textures/injector.png new file mode 100644 index 0000000000000000000000000000000000000000..f63471e5ebd33701b52bd50a220a98f3c12f5cb0 GIT binary patch literal 957 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!TvFmZOzrQSsu>uVZ9QEaLn>~) zz3U%z+d!hNu=OF|+on?MyWH_gkxyiv*;%@azg1CpA+|yThcdz4aWqy!xRixo>UH*GR24({Wi3Uaq z2A%^9zETgqef!?Hb6;P6-Sc>RXIT~hbzf@ZOO!IU-=4{_YA2h8&29d|XT}W7TTHkl zd>@=iXJDJ*%o)L<(M0+ObyfY8SU%p>;v{Lj4Wof__43Vamld)P6u8# zi|YXy2~2DbtZW)(Y<`FcoVxP-^y}hJ+tik6aW}Lo_Oc(iWWbidz{bF= zbAVyzyQlttt)FX@%r-u7`0?LY4?ouZna3#Mz@R31;M0f7Wk;B zJrl-!=T1rePg_%m;Li-x+Rg2NVKJe4!T|>P5SA#pdu6;6Twa};b?Nq09j55W(AHMg z2S&%+^?$aRwuOi>1Rnxgo|_1<+<<`@81xN{2N;Zv8zT*r zZ!y$cfdkxOD_a0d-2n}UYzbzA12Q}x{xMv;CnuIHvy8`vq4|mA7f1FL(M5mLn4F!R0AEk!@v>>+U-h zJgaQbRAw-BILsJeZ@_TZ7@nqh7@!VuILS~FyIqRk?PS`7Dc8FV{VJ)efRm*sVLohUIEl-#j_n}va?AuVZ9QEaLn>~) zz3U%z+d!hNu=OF|+on?MyWH_gkxyiv*;%@azg1CpA+|yThcdz4aWqy!xRixo>UH*GR24({Wi3Uaq z2A%^9zETgqef!?Hb6;P6-Sc>RXIT~hbzf@ZOO!IU-=4{_YA2h8&29d|XT}W7TTHkl zd>@=iXJDJ*%o)L<(M0+ObyfY8SU%p>;v{Lj4Wof__43Vamld)P6u8# zi|YXy2~2DbtZW)(Y<`FcoVxP-^y}hJ+tik6aW}Lo_Oc(iWWbidz{bF= zbAVyzyQlttt)FX@%r-u7`0?LY4?ouZna3#Mz@R31;M0f7Wk;B zJrl-!=T1rePg_%m;Li-x+Rg2NVKJe4!T|>P5SA#pdu6;6Twa};b?Nq09j55W(AHMg z2S&%+^?$aRwuOi>1Rnxgo|_1<+<<`@81xN{2N;Zv8zT*r zZ!y$cfdkxOD_a0d-2n}UYzbzA12Q}x{xMv;CnuIHvy8`vq4|mA7f1FL(M5mLn4F!R0AEk!@v>>+U-h zJgaQbRAw-BILsJeZ@_TZ7@nqh7@!VuILS~FyIqRk?PS`7Dc8FV{VJ)efRm*sVLohUIEl-#j_n}va?Aml)EQCjyyRTlf-H& zPM1J4LAk{DIyv%9TteUReDE9BuZ;&k2G450sjXD(Vrzyd@l9b;XlRz278zt3<0(;_*fzN zset#AQ=ArXxd|$U?j&dfD=EO@Y|xi(`0OtL|M$W`x zHC&jR6d3oj*Vne7F868kA0H$-S2JqVg8a29%U!QO+GrO%tDl@)URs*C)d9Cf^;w3V zq1ztdEl=H!!cm>?nxc(`3cV$e}}$( zy_FctqA9a?vQ|#gu1q0+Jp8$6=e5yu$AvlZV{)}QdGP*`8YDPXqU4?f`7Z-uCM!Su z!T|s~4W6xEM5xFyE|K#?{^#53r@Hyq0LEGWxidFd#Em<_@?3@_6b%3$yDsw(T9AkdQj#>LEhdt7E^wMRCzsV zvjilsg&xn2st=h`>|LGDsW*Fo%+r&YMqTL_5!I%uU+8KP^(Bg2Q97?_haLT-b5hvy zbBBFCa;YXM6s!!FyD(0rs3E$g@T(k@vK?+xl3nfa4>!cA(;WIg@K?~4cX7SHQ$gMk zzwa>g!5_*Tp^c|jfcnFEQCBqetPHJ;C-h2qFAK_DoT65wCXX_06Xs7VG59F-`QlLr zhrNt+td*X)z*pv!OE9M3I7Ek{AaguIM!5bNnf`~j$Wi7|oly@nfi>~cTsb{1fwbN! zN7rgfr5ED7*L$LuuuJVrvP;}cd^@%@SbGicw}<8nB4&M$ZgDO%Ez2!aIAzIbTD-|I zn<*(kUX)L2AFRlm;{XVR}2XAWDA z_OI!#X0DR&`P0$Iuts*rp+z`zIVd^MocyJ5Qt;;m`^hX;#|UA(jooHYUBe6IB6F^?nUJA^(APKG=Y zYsfm~X-HHpD=kn$$lj8*tTEet;jB)%nB{%=($AQBMWi@$H!NY6Wm|MXl)FgIuwL5f zu4`FFW`n}*$k1B0&zzh=wls!D&8S;<|={gyjdXJ->&BaSP0f{ZCvkuC$Kx{qh6_u?pvo z3q_&r+0k{KRqb18O=+Q@L;pHerKFFYWGLsc;R*Bo=)MYE&peIs|{65|b?_Dg1}N#=5Q&Ga-a-SXS_zBeByE*m}4XJN;@v?v-eswXE-Odk^Bf>GFs=?W=St*SU%?6NE_wx^_hX<^W5z zto-)AuF${i0JY7o_Djv@)uP&>isG!yto4HdMSNXPUB5}YXWoP8IYhX?x#M}z`3NY+ zT!Wy=<0CX9Y{`xfgF^UPlGT-oPQR)rH#L*;>or+5Q=V2nU2d)9bLsi}StZ}WN){oN z@Q@+;cG&9IVM^2wRAPG=op5w)v}KHXvR9lH*NAkcy#L5F!go&Vw^oMMY%W^bMCqNx zEqO7uGRa3OQ;MJEKC5?0I$IBnTVbvA-3%@(Ns3h|c(^ssoow#LE?^gE7lYZeU_JM| z0t*Ojd(p*grIO6z${8AlamF`Z{G-VvR>GEaZRe8zwPc#WHl8*#KWs!{ByIw6SL}-M zj-HrN(DT1j8|4E9J7o*Sm+Pa1OP@6w(i_g?D(A7~JmGbhQB`h|j(nc_%o|?DXOxCR zucLoBKk2VLdN!osXOQ zzqE<4%s~-iLnIDS|E5LdQ=?OHFJbVeI`S=Y5BVFZur)eUi~4rxF|x%S-1tlG?{T7S z zp0ksqlWU%HY-?}(*uu(1|YbD&tEz73;uTyU5;$Q)^Gh($G6YN!WC3Xqe>D zv>ov^E_lU(F!zYjbNe%s-~6cddE&~=#+!t@JD>b^s)@^&EI(Q1yi$CnUb~aep;rPZk!bsLgLFP_oT8n!~;psYl zgYzA+tF7xwb8mpG^!>d%$D6JG)BZf$Z{`?HmO^;LMb2H0KJ1$h7ayl_rlp-j$+LD( z9AqVkq?)I- zMp;==cxcGmyai)2>8=~SJ@a0xZy_)Hl`BSLueemE4?vhiM8KGwbdUrkAh!cLj3h?~ zI7l&OZeaJF;`+}Ksn0Z2vv)aT_%@O|ZzQ`x)7?P$GOQI!O8Vl4*|;7aSbM&K#z3Sr zAQY=HD6cWO_}V)jN3zaG96rs%PQ|$Ij*Ni$Ed^C`-CUoA^<#P_+01Uk3zc#KES{K& zBNcwoNX)T>+>V7PoN+rO_0O!-u{CVYZsLv|-&yQVxZ5ekn4_g=%MF0xp3x0fC{-W~v4?KghhA$WYXMEP$TNuCnl1JBcif zlm_nl@V3&4bpTvc`@2z;TWB7v_`AbomY6tD;TR170djQz?LME3{O#w=tH;|FrmG5Q z%;K@Fe@OW5oCBcK0MEHF-R+NC-=Lyf7w2hycE0MG>2s9FkENY1ZJUxK?~(r#a6?{W zS6-t}l$6M-cBM)g@KHw3ej5tCOz~-v1w4l4o9r+6YC7nlAa(|yegZFBj{l1e@PD)i z6t|s04t(1V*tBygVmz7jC8!=@+UW7Zv8((+gaT6vmlcd=5WKY)_Jw zbYAO4vkJ=LZ6xl?pOi{${nx{(g-8VQoymtUMv>mu`4^v3Zw^qq^Zy*=^@Fl9V^AE`XXtM4in9cy1+<#J z;+2}e$=vwK)k;rX^d&<`7l;3b23MM+Xr|*?l>~JC7sUP!_yR5%LR_&~zYBhXC=QI$ zRZ@%p5|AR1!UGJ1mmhqcBD8QS)kBN{Ody}?q$RK+;Q?h`2u~qa*#BZ2B#R6K00fW$D4-%`@Pc8g z85_pfqPFe#GslmYl!sJ?cqlM#d$r+ET07G9KMyZXXfbmA2{r!w4gXuJr4_~i98EP! Tjq$33fOPb=jkT)ac2EBUX2_Y1 literal 0 HcmV?d00001 diff --git a/src/minecraft/assemblyline/textures/sorter.png b/src/minecraft/assemblyline/textures/sorter.png new file mode 100644 index 0000000000000000000000000000000000000000..feba2e00164af67757833c7dcc1fc4d71ec8f3c4 GIT binary patch literal 1054 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sDEfH31!Z9ZuR2IkG4E{-7;ac^fkP7*fcab5nrAcpZAQ+J5i zomN$yhc+A9q+3cfx+Zw8GA+72>1+I|Wk8_&x_sEo5LgHRX~z3q#GmsgkS=sa`LI znHcQupXy<1Fk1SBlaXP5eySUz!_1&xEes9kw;L^HSm2{s>%?&2dGyRchJa;L>=YRu zd|rEIMQjdH#(#By)#k0Kf2TTr6>b_|;{(O8ccmrETy|AxrWAuS5 zPqY2^RSMpi$0VpE`#?RO?fYzA*MGzKXpJa?F{g6)Y-Wap&nw@AG6ZbfVwQ-Dt;pZBO-}1((EswQd)ou5 z&j$Wwy#C?rg1|PWhPSyXR{RCOZR=it|Mk9Cnzg~#E_@@KK>C6=x(<8RrTu*7y1-IN z-0vyF_J)laqJmXtRHrZZP@s=t$Gzr&D_z{}3Cz)kk97Q=zu z*xp8lfW>`zq6`nVtvlwxup-cXI~PMiba=7?!<7|_qgfettX*v=z>sz2;@YOY4BJah z+4$`FKb$Z#n~>CCB+I$m?`*YAjy4;^5rzX&3dg>iY-Vzp6?8;}iNSE+@|mIxm!>GG z2{Lqiv^~3~hQ}wkYlceNPpO0`3hZOR`-au?dTT@fw^cwb z&pt=}S^xgN-QPd|eja^qy0rTL@2`)&eYTysb+qyF&L7K*7smgwJOAxNefIMQru&&| zxL$mkH%nck`#@#ZRn_2P_8;FK-mT}{^Yh0_ZzmSn*9@`=Ywo{HV{Rx>m7FcW(DT*$ zZVtnQbt=iiObr|Bme1y8xHL5-$BDt<+WV5tj1Idd_4sly9Q!plZ(HhJmRB=H{duZ) z-Iklpcj4W`D}raL8G~1={A}mDz