From 869c206c4fcc8001bd2e1d66f704290331813835 Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Wed, 20 Jan 2016 14:24:34 +1000 Subject: Initial Commit --- src/Java/binnie/core/machines/BlockMachine.java | 181 +++++++ src/Java/binnie/core/machines/IBlockMachine.java | 8 + src/Java/binnie/core/machines/IMachine.java | 25 + src/Java/binnie/core/machines/IMachineType.java | 11 + src/Java/binnie/core/machines/IOwnable.java | 10 + src/Java/binnie/core/machines/ItemMachine.java | 29 + src/Java/binnie/core/machines/Machine.java | 320 +++++++++++ .../binnie/core/machines/MachineComponent.java | 61 +++ src/Java/binnie/core/machines/MachineGroup.java | 113 ++++ src/Java/binnie/core/machines/MachinePackage.java | 74 +++ .../binnie/core/machines/MachineRendererBlock.java | 41 ++ src/Java/binnie/core/machines/MachineUtil.java | 216 ++++++++ src/Java/binnie/core/machines/ManagerMachine.java | 108 ++++ src/Java/binnie/core/machines/ModelBlock.java | 42 ++ src/Java/binnie/core/machines/RendererMachine.java | 68 +++ .../binnie/core/machines/TileEntityMachine.java | 112 ++++ .../core/machines/base/DefaultInventory.java | 82 +++ .../binnie/core/machines/base/DefaultPower.java | 71 +++ .../core/machines/base/DefaultTankContainer.java | 79 +++ .../core/machines/base/TileEntityMachineBase.java | 262 +++++++++ .../core/machines/component/ComponentRecipe.java | 14 + .../core/machines/component/IBuildcraft.java | 20 + .../core/machines/component/IComponentRecipe.java | 12 + .../core/machines/component/IInteraction.java | 22 + .../binnie/core/machines/component/IRender.java | 28 + .../core/machines/inventory/AccessDirection.java | 97 ++++ .../binnie/core/machines/inventory/BaseSlot.java | 148 +++++ .../machines/inventory/ComponentChargedSlots.java | 117 ++++ .../machines/inventory/ComponentInventory.java | 22 + .../inventory/ComponentInventorySlots.java | 247 +++++++++ .../inventory/ComponentInventoryTransfer.java | 161 ++++++ .../machines/inventory/ComponentTankContainer.java | 207 +++++++ .../core/machines/inventory/IChargedSlots.java | 10 + .../core/machines/inventory/IInventoryMachine.java | 8 + .../core/machines/inventory/IInventorySlots.java | 14 + .../machines/inventory/IValidatedInventory.java | 9 + .../inventory/IValidatedTankContainer.java | 10 + .../core/machines/inventory/InventorySlot.java | 115 ++++ .../core/machines/inventory/MachineSide.java | 79 +++ .../binnie/core/machines/inventory/SetList.java | 36 ++ .../core/machines/inventory/SidedAccess.java | 106 ++++ .../core/machines/inventory/SlotValidator.java | 68 +++ .../binnie/core/machines/inventory/TankSlot.java | 58 ++ .../core/machines/inventory/TankValidator.java | 33 ++ .../core/machines/inventory/TransferHandler.java | 227 ++++++++ .../binnie/core/machines/inventory/Validator.java | 9 + .../core/machines/inventory/ValidatorIcon.java | 25 + .../binnie/core/machines/network/INetwork.java | 30 ++ .../machines/power/ComponentPowerReceptor.java | 191 +++++++ .../core/machines/power/ComponentProcess.java | 90 ++++ .../machines/power/ComponentProcessIndefinate.java | 120 +++++ .../machines/power/ComponentProcessSetCost.java | 27 + .../binnie/core/machines/power/ErrorState.java | 187 +++++++ .../core/machines/power/IErrorStateSource.java | 8 + .../core/machines/power/IPoweredMachine.java | 14 + src/Java/binnie/core/machines/power/IProcess.java | 13 + .../binnie/core/machines/power/IProcessTimed.java | 13 + .../binnie/core/machines/power/ITankMachine.java | 20 + src/Java/binnie/core/machines/power/PowerInfo.java | 41 ++ .../binnie/core/machines/power/PowerInterface.java | 90 ++++ .../binnie/core/machines/power/PowerSystem.java | 44 ++ .../binnie/core/machines/power/ProcessInfo.java | 67 +++ src/Java/binnie/core/machines/power/TankInfo.java | 76 +++ .../binnie/core/machines/storage/Compartment.java | 65 +++ .../core/machines/storage/CompartmentTab.java | 77 +++ .../machines/storage/ComponentBinnieCoreGUI.java | 28 + .../storage/ComponentCompartmentInventory.java | 128 +++++ .../machines/storage/ControlColourSelector.java | 47 ++ .../storage/MachineRendererCompartment.java | 50 ++ .../core/machines/storage/ModelCompartment.java | 171 ++++++ .../core/machines/storage/ModuleStorage.java | 39 ++ .../core/machines/storage/StandardCompartment.java | 142 +++++ .../core/machines/storage/WindowCompartment.java | 594 +++++++++++++++++++++ .../binnie/core/machines/storage/WindowTest.java | 40 ++ .../core/machines/transfer/TransferHandler.java | 3 + .../core/machines/transfer/TransferRequest.java | 419 +++++++++++++++ 76 files changed, 6649 insertions(+) create mode 100644 src/Java/binnie/core/machines/BlockMachine.java create mode 100644 src/Java/binnie/core/machines/IBlockMachine.java create mode 100644 src/Java/binnie/core/machines/IMachine.java create mode 100644 src/Java/binnie/core/machines/IMachineType.java create mode 100644 src/Java/binnie/core/machines/IOwnable.java create mode 100644 src/Java/binnie/core/machines/ItemMachine.java create mode 100644 src/Java/binnie/core/machines/Machine.java create mode 100644 src/Java/binnie/core/machines/MachineComponent.java create mode 100644 src/Java/binnie/core/machines/MachineGroup.java create mode 100644 src/Java/binnie/core/machines/MachinePackage.java create mode 100644 src/Java/binnie/core/machines/MachineRendererBlock.java create mode 100644 src/Java/binnie/core/machines/MachineUtil.java create mode 100644 src/Java/binnie/core/machines/ManagerMachine.java create mode 100644 src/Java/binnie/core/machines/ModelBlock.java create mode 100644 src/Java/binnie/core/machines/RendererMachine.java create mode 100644 src/Java/binnie/core/machines/TileEntityMachine.java create mode 100644 src/Java/binnie/core/machines/base/DefaultInventory.java create mode 100644 src/Java/binnie/core/machines/base/DefaultPower.java create mode 100644 src/Java/binnie/core/machines/base/DefaultTankContainer.java create mode 100644 src/Java/binnie/core/machines/base/TileEntityMachineBase.java create mode 100644 src/Java/binnie/core/machines/component/ComponentRecipe.java create mode 100644 src/Java/binnie/core/machines/component/IBuildcraft.java create mode 100644 src/Java/binnie/core/machines/component/IComponentRecipe.java create mode 100644 src/Java/binnie/core/machines/component/IInteraction.java create mode 100644 src/Java/binnie/core/machines/component/IRender.java create mode 100644 src/Java/binnie/core/machines/inventory/AccessDirection.java create mode 100644 src/Java/binnie/core/machines/inventory/BaseSlot.java create mode 100644 src/Java/binnie/core/machines/inventory/ComponentChargedSlots.java create mode 100644 src/Java/binnie/core/machines/inventory/ComponentInventory.java create mode 100644 src/Java/binnie/core/machines/inventory/ComponentInventorySlots.java create mode 100644 src/Java/binnie/core/machines/inventory/ComponentInventoryTransfer.java create mode 100644 src/Java/binnie/core/machines/inventory/ComponentTankContainer.java create mode 100644 src/Java/binnie/core/machines/inventory/IChargedSlots.java create mode 100644 src/Java/binnie/core/machines/inventory/IInventoryMachine.java create mode 100644 src/Java/binnie/core/machines/inventory/IInventorySlots.java create mode 100644 src/Java/binnie/core/machines/inventory/IValidatedInventory.java create mode 100644 src/Java/binnie/core/machines/inventory/IValidatedTankContainer.java create mode 100644 src/Java/binnie/core/machines/inventory/InventorySlot.java create mode 100644 src/Java/binnie/core/machines/inventory/MachineSide.java create mode 100644 src/Java/binnie/core/machines/inventory/SetList.java create mode 100644 src/Java/binnie/core/machines/inventory/SidedAccess.java create mode 100644 src/Java/binnie/core/machines/inventory/SlotValidator.java create mode 100644 src/Java/binnie/core/machines/inventory/TankSlot.java create mode 100644 src/Java/binnie/core/machines/inventory/TankValidator.java create mode 100644 src/Java/binnie/core/machines/inventory/TransferHandler.java create mode 100644 src/Java/binnie/core/machines/inventory/Validator.java create mode 100644 src/Java/binnie/core/machines/inventory/ValidatorIcon.java create mode 100644 src/Java/binnie/core/machines/network/INetwork.java create mode 100644 src/Java/binnie/core/machines/power/ComponentPowerReceptor.java create mode 100644 src/Java/binnie/core/machines/power/ComponentProcess.java create mode 100644 src/Java/binnie/core/machines/power/ComponentProcessIndefinate.java create mode 100644 src/Java/binnie/core/machines/power/ComponentProcessSetCost.java create mode 100644 src/Java/binnie/core/machines/power/ErrorState.java create mode 100644 src/Java/binnie/core/machines/power/IErrorStateSource.java create mode 100644 src/Java/binnie/core/machines/power/IPoweredMachine.java create mode 100644 src/Java/binnie/core/machines/power/IProcess.java create mode 100644 src/Java/binnie/core/machines/power/IProcessTimed.java create mode 100644 src/Java/binnie/core/machines/power/ITankMachine.java create mode 100644 src/Java/binnie/core/machines/power/PowerInfo.java create mode 100644 src/Java/binnie/core/machines/power/PowerInterface.java create mode 100644 src/Java/binnie/core/machines/power/PowerSystem.java create mode 100644 src/Java/binnie/core/machines/power/ProcessInfo.java create mode 100644 src/Java/binnie/core/machines/power/TankInfo.java create mode 100644 src/Java/binnie/core/machines/storage/Compartment.java create mode 100644 src/Java/binnie/core/machines/storage/CompartmentTab.java create mode 100644 src/Java/binnie/core/machines/storage/ComponentBinnieCoreGUI.java create mode 100644 src/Java/binnie/core/machines/storage/ComponentCompartmentInventory.java create mode 100644 src/Java/binnie/core/machines/storage/ControlColourSelector.java create mode 100644 src/Java/binnie/core/machines/storage/MachineRendererCompartment.java create mode 100644 src/Java/binnie/core/machines/storage/ModelCompartment.java create mode 100644 src/Java/binnie/core/machines/storage/ModuleStorage.java create mode 100644 src/Java/binnie/core/machines/storage/StandardCompartment.java create mode 100644 src/Java/binnie/core/machines/storage/WindowCompartment.java create mode 100644 src/Java/binnie/core/machines/storage/WindowTest.java create mode 100644 src/Java/binnie/core/machines/transfer/TransferHandler.java create mode 100644 src/Java/binnie/core/machines/transfer/TransferRequest.java (limited to 'src/Java/binnie/core/machines') diff --git a/src/Java/binnie/core/machines/BlockMachine.java b/src/Java/binnie/core/machines/BlockMachine.java new file mode 100644 index 0000000000..042e213aec --- /dev/null +++ b/src/Java/binnie/core/machines/BlockMachine.java @@ -0,0 +1,181 @@ +package binnie.core.machines; + +import binnie.Binnie; +import binnie.core.BinnieCore; +import binnie.core.machines.component.IRender.RandomDisplayTick; +import binnie.core.proxy.BinnieProxy; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.PlayerCapabilities; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +class BlockMachine + extends BlockContainer + implements IBlockMachine +{ + private MachineGroup group; + + public BlockMachine(MachineGroup group, String blockName) + { + super(Material.iron); + this.group = group; + setHardness(1.5F); + setBlockName(blockName); + } + + public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List itemList) + { + for (MachinePackage pack : this.group.getPackages()) { + if (pack.isActive()) { + itemList.add(new ItemStack(this, 1, pack.getMetadata().intValue())); + } + } + } + + public boolean isOpaqueCube() + { + return false; + } + + public boolean renderAsNormalBlock() + { + return !this.group.customRenderer; + } + + public int getRenderType() + { + return Binnie.Machine.getMachineRenderID(); + } + + public TileEntity createTileEntity(World world, int metadata) + { + if (this.group.getPackage(metadata) == null) { + return null; + } + return this.group.getPackage(metadata).createTileEntity(); + } + + public MachinePackage getPackage(int meta) + { + return this.group.getPackage(meta); + } + + public String getMachineName(int meta) + { + return getPackage(meta) == null ? "Unnamed Machine" : getPackage(meta).getDisplayName(); + } + + public int damageDropped(int par1) + { + return par1; + } + + public TileEntity createNewTileEntity(World var1, int meta) + { + return createTileEntity(var1, meta); + } + + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7, float par8, float par9) + { + if (!BinnieCore.proxy.isSimulating(world)) { + return true; + } + if (player.isSneaking()) { + return true; + } + TileEntity entity = world.getTileEntity(x, y, z); + if ((entity instanceof TileEntityMachine)) { + ((TileEntityMachine)entity).getMachine().onRightClick(world, player, x, y, z); + } + return true; + } + + public void onBlockPlacedBy(World world, int i, int j, int k, EntityLivingBase entityliving, ItemStack stack) + { + super.onBlockPlacedBy(world, i, j, k, entityliving, stack); + if (!BinnieCore.proxy.isSimulating(world)) { + return; + } + IMachine machine = Machine.getMachine(world.getTileEntity(i, j, k)); + if (machine == null) { + return; + } + if ((entityliving instanceof EntityPlayer)) { + machine.setOwner(((EntityPlayer)entityliving).getGameProfile()); + } + } + + public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) + { + TileEntity entity = world.getTileEntity(x, y, z); + if (((entity instanceof TileEntityMachine)) && (((TileEntityMachine)entity).getMachine().hasInterface(IMachineTexturedFaces.class))) { + return ((IMachineTexturedFaces)((TileEntityMachine)entity).getMachine().getInterface(IMachineTexturedFaces.class)).getIcon(side); + } + return Blocks.dirt.getIcon(0, 0); + } + + public void breakBlock(World world, int x, int y, int z, Block par5, int par6) + { + TileEntity tileentity = world.getTileEntity(x, y, z); + if (!(tileentity instanceof TileEntityMachine)) { + return; + } + TileEntityMachine entity = (TileEntityMachine)tileentity; + if (entity != null) { + entity.onBlockDestroy(); + } + super.breakBlock(world, x, y, z, par5, par6); + } + + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister register) {} + + @SideOnly(Side.CLIENT) + public void randomDisplayTick(World world, int x, int y, int z, Random rand) + { + IMachine machine = Machine.getMachine(world.getTileEntity(x, y, z)); + if (machine != null) { + for (IRender.RandomDisplayTick renders : machine.getInterfaces(IRender.RandomDisplayTick.class)) { + renders.onRandomDisplayTick(world, x, y, z, rand); + } + } + } + + public ArrayList getDrops(World world, int x, int y, int z, int metadata, int fortune) + { + return new ArrayList(); + } + + public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z, boolean willHarvest) + { + if ((BinnieCore.proxy.isSimulating(world)) && (canHarvestBlock(player, world.getBlockMetadata(x, y, z))) && + (!player.capabilities.isCreativeMode)) + { + int metadata = world.getBlockMetadata(x, y, z); + ItemStack stack = new ItemStack(Item.getItemFromBlock(this), 1, damageDropped(metadata)); + dropBlockAsItem(world, x, y, z, stack); + } + return world.setBlockToAir(x, y, z); + } + + public static abstract interface IMachineTexturedFaces + { + public abstract IIcon getIcon(int paramInt); + } +} diff --git a/src/Java/binnie/core/machines/IBlockMachine.java b/src/Java/binnie/core/machines/IBlockMachine.java new file mode 100644 index 0000000000..01b7e321a1 --- /dev/null +++ b/src/Java/binnie/core/machines/IBlockMachine.java @@ -0,0 +1,8 @@ +package binnie.core.machines; + +abstract interface IBlockMachine +{ + public abstract MachinePackage getPackage(int paramInt); + + public abstract String getMachineName(int paramInt); +} diff --git a/src/Java/binnie/core/machines/IMachine.java b/src/Java/binnie/core/machines/IMachine.java new file mode 100644 index 0000000000..9a57b0e019 --- /dev/null +++ b/src/Java/binnie/core/machines/IMachine.java @@ -0,0 +1,25 @@ +package binnie.core.machines; + +import java.util.Collection; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public abstract interface IMachine + extends IOwnable +{ + public abstract void addComponent(MachineComponent paramMachineComponent); + + public abstract MachineUtil getMachineUtil(); + + public abstract T getInterface(Class paramClass); + + public abstract void markDirty(); + + public abstract World getWorld(); + + public abstract TileEntity getTileEntity(); + + public abstract Collection getInterfaces(Class paramClass); + + public abstract MachinePackage getPackage(); +} diff --git a/src/Java/binnie/core/machines/IMachineType.java b/src/Java/binnie/core/machines/IMachineType.java new file mode 100644 index 0000000000..06c02218a0 --- /dev/null +++ b/src/Java/binnie/core/machines/IMachineType.java @@ -0,0 +1,11 @@ +package binnie.core.machines; + +import binnie.core.network.IOrdinaled; + +public abstract interface IMachineType + extends IOrdinaled +{ + public abstract Class getPackageClass(); + + public abstract boolean isActive(); +} diff --git a/src/Java/binnie/core/machines/IOwnable.java b/src/Java/binnie/core/machines/IOwnable.java new file mode 100644 index 0000000000..78aa1a76f9 --- /dev/null +++ b/src/Java/binnie/core/machines/IOwnable.java @@ -0,0 +1,10 @@ +package binnie.core.machines; + +import com.mojang.authlib.GameProfile; + +abstract interface IOwnable +{ + public abstract GameProfile getOwner(); + + public abstract void setOwner(GameProfile paramGameProfile); +} diff --git a/src/Java/binnie/core/machines/ItemMachine.java b/src/Java/binnie/core/machines/ItemMachine.java new file mode 100644 index 0000000000..08426cdb7a --- /dev/null +++ b/src/Java/binnie/core/machines/ItemMachine.java @@ -0,0 +1,29 @@ +package binnie.core.machines; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class ItemMachine + extends ItemBlock +{ + private IBlockMachine associatedBlock; + + public ItemMachine(Block block) + { + super(block); + setMaxDamage(0); + setHasSubtypes(true); + this.associatedBlock = ((IBlockMachine)block); + } + + public int getMetadata(int i) + { + return i; + } + + public String getItemStackDisplayName(ItemStack itemstack) + { + return this.associatedBlock.getMachineName(itemstack.getItemDamage()); + } +} diff --git a/src/Java/binnie/core/machines/Machine.java b/src/Java/binnie/core/machines/Machine.java new file mode 100644 index 0000000000..474b32c627 --- /dev/null +++ b/src/Java/binnie/core/machines/Machine.java @@ -0,0 +1,320 @@ +package binnie.core.machines; + +import binnie.core.BinnieCore; +import binnie.core.machines.component.IInteraction.RightClick; +import binnie.core.machines.component.IRender.DisplayTick; +import binnie.core.machines.network.INetwork.GuiNBT; +import binnie.core.machines.network.INetwork.RecieveGuiNBT; +import binnie.core.machines.network.INetwork.SendGuiNBT; +import binnie.core.machines.network.INetwork.TilePacketSync; +import binnie.core.machines.power.ITankMachine; +import binnie.core.network.BinnieCorePacketID; +import binnie.core.network.INetworkedEntity; +import binnie.core.network.packet.MessageTileNBT; +import binnie.core.network.packet.PacketPayload; +import binnie.core.proxy.BinnieProxy; +import com.mojang.authlib.GameProfile; +import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper; +import cpw.mods.fml.relauncher.Side; +import forestry.api.core.INBTTagable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTUtil; +import net.minecraft.network.Packet; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class Machine + implements INetworkedEntity, INBTTagable, INetwork.TilePacketSync, IMachine, INetwork.GuiNBT +{ + private MachinePackage machinePackage; + private Map> componentInterfaceMap = new LinkedHashMap(); + private Map, MachineComponent> componentMap = new LinkedHashMap(); + private TileEntity tile; + + public Machine(MachinePackage pack, TileEntity tile) + { + this.tile = tile; + + pack.createMachine(this); + this.machinePackage = pack; + } + + public void addComponent(MachineComponent component) + { + if (component == null) { + throw new NullPointerException("Can't have a null machine component!"); + } + component.setMachine(this); + this.componentMap.put(component.getClass(), component); + for (Class inter : component.getComponentInterfaces()) + { + if (!this.componentInterfaceMap.containsKey(inter)) { + this.componentInterfaceMap.put(inter, new ArrayList()); + } + ((List)this.componentInterfaceMap.get(inter)).add(component); + } + } + + public Collection getComponents() + { + return this.componentMap.values(); + } + + public T getComponent(Class componentClass) + { + return hasComponent(componentClass) ? (MachineComponent)componentClass.cast(this.componentMap.get(componentClass)) : null; + } + + public T getInterface(Class interfaceClass) + { + if (hasInterface(interfaceClass)) { + return getInterfaces(interfaceClass).get(0); + } + if (interfaceClass.isInstance(getPackage())) { + return interfaceClass.cast(getPackage()); + } + for (MachineComponent component : getComponents()) { + if (interfaceClass.isInstance(component)) { + return interfaceClass.cast(component); + } + } + return null; + } + + public List getInterfaces(Class interfaceClass) + { + ArrayList interfaces = new ArrayList(); + if (!hasInterface(interfaceClass)) { + return interfaces; + } + for (MachineComponent component : (List)this.componentInterfaceMap.get(interfaceClass)) { + interfaces.add(interfaceClass.cast(component)); + } + return interfaces; + } + + public boolean hasInterface(Class interfaceClass) + { + return this.componentInterfaceMap.containsKey(interfaceClass); + } + + public boolean hasComponent(Class componentClass) + { + return this.componentMap.containsKey(componentClass); + } + + public TileEntity getTileEntity() + { + return this.tile; + } + + public void sendPacket() + { + if (!BinnieCore.proxy.isSimulating(getTileEntity().getWorldObj())) { + return; + } + BinnieCore.proxy.sendNetworkEntityPacket((INetworkedEntity)getTileEntity()); + } + + public Side getSide() + { + return BinnieCore.proxy.isSimulating(getTileEntity().getWorldObj()) ? Side.SERVER : Side.CLIENT; + } + + public void writeToPacket(PacketPayload payload) + { + for (MachineComponent component : getComponents()) { + if ((component instanceof INetworkedEntity)) { + ((INetworkedEntity)component).writeToPacket(payload); + } + } + } + + public void readFromPacket(PacketPayload payload) + { + for (MachineComponent component : getComponents()) { + if ((component instanceof INetworkedEntity)) { + ((INetworkedEntity)component).readFromPacket(payload); + } + } + } + + public void onRightClick(World world, EntityPlayer player, int x, int y, int z) + { + for (IInteraction.RightClick component : getInterfaces(IInteraction.RightClick.class)) { + component.onRightClick(world, player, x, y, z); + } + } + + public void markDirty() + { + this.queuedInventoryUpdate = true; + } + + private boolean queuedInventoryUpdate = false; + + public void onUpdate() + { + if (BinnieCore.proxy.isSimulating(getWorld())) { + for (MachineComponent component : getComponents()) { + component.onUpdate(); + } + } else { + for (IRender.DisplayTick renders : getInterfaces(IRender.DisplayTick.class)) { + renders.onDisplayTick(getWorld(), getTileEntity().xCoord, getTileEntity().yCoord, getTileEntity().zCoord, getWorld().rand); + } + } + if (this.queuedInventoryUpdate) + { + for (MachineComponent component : getComponents()) { + component.onInventoryUpdate(); + } + this.queuedInventoryUpdate = false; + } + } + + public IInventory getInventory() + { + return (IInventory)getInterface(IInventory.class); + } + + public ITankMachine getTankContainer() + { + return (ITankMachine)getInterface(ITankMachine.class); + } + + public void readFromNBT(NBTTagCompound nbttagcompound) + { + for (MachineComponent component : getComponents()) { + component.readFromNBT(nbttagcompound); + } + this.owner = NBTUtil.func_152459_a(nbttagcompound.getCompoundTag("owner")); + markDirty(); + } + + public void writeToNBT(NBTTagCompound nbttagcompound) + { + for (MachineComponent component : getComponents()) { + component.writeToNBT(nbttagcompound); + } + if (this.owner != null) + { + NBTTagCompound nbt = new NBTTagCompound(); + NBTUtil.func_152460_a(nbt, this.owner); + nbttagcompound.setTag("owner", nbt); + } + } + + public MachinePackage getPackage() + { + return this.machinePackage; + } + + public static IMachine getMachine(Object inventory) + { + if ((inventory != null) && ((inventory instanceof IMachine))) { + return (IMachine)inventory; + } + if ((inventory != null) && ((inventory instanceof TileEntityMachine))) { + return ((TileEntityMachine)inventory).getMachine(); + } + if ((inventory != null) && ((inventory instanceof MachineComponent))) { + return ((MachineComponent)inventory).getMachine(); + } + return null; + } + + public static T getInterface(Class interfac, Object inventory) + { + IMachine machine = getMachine(inventory); + if (machine != null) { + return machine.getInterface(interfac); + } + if (interfac.isInstance(inventory)) { + return interfac.cast(inventory); + } + return null; + } + + public MachineUtil getMachineUtil() + { + return new MachineUtil(this); + } + + public World getWorld() + { + return getTileEntity().getWorldObj(); + } + + public void onBlockDestroy() + { + for (MachineComponent component : getComponents()) { + component.onDestruction(); + } + } + + private int nextProgressBarID = 0; + + public int getUniqueProgressBarID() + { + return this.nextProgressBarID++; + } + + private GameProfile owner = null; + + public GameProfile getOwner() + { + return this.owner; + } + + public void setOwner(GameProfile owner) + { + this.owner = owner; + } + + public Packet getDescriptionPacket() + { + NBTTagCompound nbt = new NBTTagCompound(); + + syncToNBT(nbt); + if (nbt.hasNoTags()) { + return null; + } + return BinnieCore.instance.getNetworkWrapper().getPacketFrom(new MessageTileNBT(BinnieCorePacketID.TileDescriptionSync.ordinal(), getTileEntity(), nbt).GetMessage()); + } + + public void syncToNBT(NBTTagCompound nbt) + { + for (INetwork.TilePacketSync comp : getInterfaces(INetwork.TilePacketSync.class)) { + comp.syncToNBT(nbt); + } + } + + public void syncFromNBT(NBTTagCompound nbt) + { + for (INetwork.TilePacketSync comp : getInterfaces(INetwork.TilePacketSync.class)) { + comp.syncFromNBT(nbt); + } + } + + public void recieveGuiNBT(Side side, EntityPlayer player, String name, NBTTagCompound nbt) + { + for (INetwork.RecieveGuiNBT recieve : getInterfaces(INetwork.RecieveGuiNBT.class)) { + recieve.recieveGuiNBT(side, player, name, nbt); + } + } + + public void sendGuiNBT(Map nbt) + { + for (INetwork.SendGuiNBT recieve : getInterfaces(INetwork.SendGuiNBT.class)) { + recieve.sendGuiNBT(nbt); + } + } +} diff --git a/src/Java/binnie/core/machines/MachineComponent.java b/src/Java/binnie/core/machines/MachineComponent.java new file mode 100644 index 0000000000..3b90497fc3 --- /dev/null +++ b/src/Java/binnie/core/machines/MachineComponent.java @@ -0,0 +1,61 @@ +package binnie.core.machines; + +import binnie.Binnie; +import binnie.core.network.packet.MachinePayload; +import forestry.api.core.INBTTagable; +import net.minecraft.inventory.IInventory; +import net.minecraft.nbt.NBTTagCompound; + +public class MachineComponent + implements INBTTagable +{ + private IMachine machine; + + public MachineComponent(IMachine machine) + { + setMachine(machine); + machine.addComponent(this); + } + + public void setMachine(IMachine machine) + { + this.machine = machine; + } + + public IMachine getMachine() + { + return this.machine; + } + + public void readFromNBT(NBTTagCompound nbttagcompound) {} + + public void writeToNBT(NBTTagCompound nbttagcompound) {} + + public void onUpdate() {} + + public Class[] getComponentInterfaces() + { + return Binnie.Machine.getComponentInterfaces(getClass()); + } + + public void onInventoryUpdate() {} + + public final MachinePayload getPayload() + { + return new MachinePayload(Binnie.Machine.getNetworkID(getClass())); + } + + public void recieveData(MachinePayload payload) {} + + public MachineUtil getUtil() + { + return getMachine().getMachineUtil(); + } + + public void onDestruction() {} + + public IInventory getInventory() + { + return (IInventory)getMachine().getInterface(IInventory.class); + } +} diff --git a/src/Java/binnie/core/machines/MachineGroup.java b/src/Java/binnie/core/machines/MachineGroup.java new file mode 100644 index 0000000000..03984f1f10 --- /dev/null +++ b/src/Java/binnie/core/machines/MachineGroup.java @@ -0,0 +1,113 @@ +package binnie.core.machines; + +import binnie.Binnie; +import binnie.core.AbstractMod; +import cpw.mods.fml.common.registry.GameRegistry; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; +import net.minecraft.creativetab.CreativeTabs; + +public class MachineGroup +{ + private AbstractMod mod; + private String blockName; + private String uid; + + public MachineGroup(AbstractMod mod, String uid, String blockName, IMachineType[] types) + { + this.mod = mod; + this.uid = uid; + this.blockName = blockName; + for (IMachineType type : types) { + if ((type.getPackageClass() != null) && (type.isActive())) { + try + { + MachinePackage pack = (MachinePackage)type.getPackageClass().newInstance(); + pack.assignMetadata(type.ordinal()); + pack.setActive(type.isActive()); + addPackage(pack); + } + catch (Exception e) + { + throw new RuntimeException("Failed to create machine package " + type.toString(), e); + } + } + } + Binnie.Machine.registerMachineGroup(this); + + this.block = new BlockMachine(this, blockName); + if (this.block != null) + { + GameRegistry.registerBlock(this.block, ItemMachine.class, blockName); + for (MachinePackage pack : getPackages()) { + pack.register(); + } + } + } + + private Map packages = new LinkedHashMap(); + private Map packagesID = new LinkedHashMap(); + private BlockMachine block; + + private void addPackage(MachinePackage pack) + { + this.packages.put(pack.getUID(), pack); + this.packagesID.put(pack.getMetadata(), pack); + pack.setGroup(this); + } + + public Collection getPackages() + { + return this.packages.values(); + } + + public boolean customRenderer = true; + + public BlockMachine getBlock() + { + return this.block; + } + + public MachinePackage getPackage(int metadata) + { + return (MachinePackage)this.packagesID.get(Integer.valueOf(metadata)); + } + + public MachinePackage getPackage(String name) + { + return (MachinePackage)this.packages.get(name); + } + + public String getUID() + { + return this.mod.getModID() + "." + this.uid; + } + + public String getShortUID() + { + return this.uid; + } + + private boolean renderedTileEntity = true; + + boolean isTileEntityRenderered() + { + return this.renderedTileEntity; + } + + public void renderAsBlock() + { + this.renderedTileEntity = false; + } + + public void setCreativeTab(CreativeTabs tab) + { + this.block.setCreativeTab(tab); + } + + public AbstractMod getMod() + { + return this.mod; + } +} diff --git a/src/Java/binnie/core/machines/MachinePackage.java b/src/Java/binnie/core/machines/MachinePackage.java new file mode 100644 index 0000000000..943db084b6 --- /dev/null +++ b/src/Java/binnie/core/machines/MachinePackage.java @@ -0,0 +1,74 @@ +package binnie.core.machines; + +import binnie.Binnie; +import binnie.core.language.ManagerLanguage; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.tileentity.TileEntity; + +public abstract class MachinePackage +{ + private String uid; + private boolean active = true; + boolean powered = false; + private int metadata = -1; + private MachineGroup group; + + public String getUID() + { + return this.uid; + } + + protected MachinePackage(String uid, boolean powered) + { + this.uid = uid; + this.powered = powered; + } + + public abstract void createMachine(Machine paramMachine); + + public abstract TileEntity createTileEntity(); + + public abstract void register(); + + public final String getDisplayName() + { + return Binnie.Language.localise(this.group.getMod(), "machine." + this.group.getShortUID() + "." + getUID()); + } + + public final Integer getMetadata() + { + return Integer.valueOf(this.metadata); + } + + public void assignMetadata(int meta) + { + this.metadata = meta; + } + + public MachineGroup getGroup() + { + return this.group; + } + + public void setGroup(MachineGroup group) + { + this.group = group; + } + + public abstract void renderMachine(Machine paramMachine, double paramDouble1, double paramDouble2, double paramDouble3, float paramFloat, RenderBlocks paramRenderBlocks); + + public boolean isActive() + { + return this.active; + } + + public void setActive(boolean active) + { + this.active = active; + } + + public final String getInformation() + { + return Binnie.Language.localise(this.group.getMod(), "machine." + this.group.getShortUID() + "." + getUID() + ".info"); + } +} diff --git a/src/Java/binnie/core/machines/MachineRendererBlock.java b/src/Java/binnie/core/machines/MachineRendererBlock.java new file mode 100644 index 0000000000..9506746df4 --- /dev/null +++ b/src/Java/binnie/core/machines/MachineRendererBlock.java @@ -0,0 +1,41 @@ +package binnie.core.machines; + +import binnie.core.BinnieCore; +import binnie.core.proxy.BinnieProxy; +import binnie.core.resource.BinnieResource; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class MachineRendererBlock +{ + public static MachineRendererBlock instance = new MachineRendererBlock(); + private BinnieResource texture; + private ModelBlock model; + + public MachineRendererBlock() + { + this.model = new ModelBlock(); + } + + public void renderMachine(BinnieResource texture, double x, double y, double z, float var8) + { + this.texture = texture; + + GL11.glPushMatrix(); + + GL11.glTranslated(x + 0.5D, y + 1.5D, z + 0.5D); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + + BinnieCore.proxy.bindTexture(texture); + + GL11.glPushMatrix(); + + this.model.render((float)x, (float)y, (float)z, 0.0625F, 0.0625F, 0.0625F); + + GL11.glPopMatrix(); + + GL11.glPopMatrix(); + } +} diff --git a/src/Java/binnie/core/machines/MachineUtil.java b/src/Java/binnie/core/machines/MachineUtil.java new file mode 100644 index 0000000000..97ff515061 --- /dev/null +++ b/src/Java/binnie/core/machines/MachineUtil.java @@ -0,0 +1,216 @@ +package binnie.core.machines; + +import binnie.core.BinnieCore; +import binnie.core.machines.inventory.IChargedSlots; +import binnie.core.machines.power.IPoweredMachine; +import binnie.core.machines.power.IProcess; +import binnie.core.machines.power.ITankMachine; +import binnie.core.machines.power.PowerInterface; +import binnie.core.machines.power.PowerSystem; +import binnie.core.proxy.BinnieProxy; +import binnie.core.util.ItemStackSet; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidTank; + +public class MachineUtil +{ + private IMachine machine; + + public MachineUtil(IMachine machine) + { + this.machine = machine; + } + + public IInventory getInventory() + { + return (IInventory)this.machine.getInterface(IInventory.class); + } + + public ITankMachine getTankContainer() + { + return (ITankMachine)this.machine.getInterface(ITankMachine.class); + } + + public IPoweredMachine getPoweredMachine() + { + return (IPoweredMachine)this.machine.getInterface(IPoweredMachine.class); + } + + public boolean isSlotEmpty(int slot) + { + return getInventory().getStackInSlot(slot) == null; + } + + public IFluidTank getTank(int id) + { + return getTankContainer().getTanks()[id]; + } + + public boolean spaceInTank(int id, int amount) + { + IFluidTank tank = getTank(id); + int space = tank.getCapacity() - tank.getFluidAmount(); + return amount <= space; + } + + public ItemStack getStack(int slot) + { + return getInventory().getStackInSlot(slot); + } + + public void deleteStack(int slot) + { + setStack(slot, null); + } + + public ItemStack decreaseStack(int slotWood, int amount) + { + return getInventory().decrStackSize(slotWood, amount); + } + + public void setStack(int slot, ItemStack stack) + { + getInventory().setInventorySlotContents(slot, stack); + } + + public void fillTank(int id, FluidStack liquidStack) + { + IFluidTank tank = getTank(id); + tank.fill(liquidStack, true); + } + + public void addStack(int slot, ItemStack addition) + { + if (isSlotEmpty(slot)) + { + setStack(slot, addition); + } + else + { + ItemStack merge = getStack(slot); + if ((merge.isItemEqual(addition)) && (merge.stackSize + addition.stackSize <= merge.getMaxStackSize())) + { + merge.stackSize += addition.stackSize; + setStack(slot, merge); + } + } + } + + public FluidStack drainTank(int tank, int amount) + { + return getTank(tank).drain(amount, true); + } + + public boolean liquidInTank(int tank, int amount) + { + return (getTank(tank).drain(amount, false) != null) && (getTank(tank).drain(amount, false).amount == amount); + } + + public void damageItem(int slot, int damage) + { + ItemStack item = getStack(slot); + if (damage < 0) { + item.setItemDamage(Math.max(0, item.getItemDamage() + damage)); + } else if (item.attemptDamageItem(damage, new Random())) { + setStack(slot, null); + } + setStack(slot, item); + } + + public boolean isTankEmpty(int tankInput) + { + return getTank(tankInput).getFluidAmount() == 0; + } + + public FluidStack getFluid(int tankInput) + { + return getTank(tankInput).getFluid() == null ? null : getTank(tankInput).getFluid(); + } + + public ItemStack[] getStacks(int[] slotGrains) + { + ItemStack[] stacks = new ItemStack[slotGrains.length]; + for (int i = 0; i < slotGrains.length; i++) { + stacks[i] = getStack(slotGrains[i]); + } + return stacks; + } + + public ItemStack hasIngredients(int recipe, int[] inventory) + { + return null; + } + + public boolean hasIngredients(int[] recipe, int[] inventory) + { + ItemStackSet requiredStacks = new ItemStackSet(); + for (ItemStack stack : getStacks(recipe)) { + requiredStacks.add(stack); + } + ItemStackSet inventoryStacks = new ItemStackSet(); + for (ItemStack stack : getStacks(inventory)) { + inventoryStacks.add(stack); + } + requiredStacks.removeAll(inventoryStacks); + + return requiredStacks.isEmpty(); + } + + public void useEnergyMJ(float powerUsage) + { + getPoweredMachine().getInterface().useEnergy(PowerSystem.MJ, powerUsage, true); + } + + public boolean hasEnergyMJ(float powerUsage) + { + return getPoweredMachine().getInterface().useEnergy(PowerSystem.MJ, powerUsage, false) >= powerUsage; + } + + public float getSlotCharge(int slot) + { + return ((IChargedSlots)this.machine.getInterface(IChargedSlots.class)).getCharge(slot); + } + + public void useCharge(int slot, float loss) + { + ((IChargedSlots)this.machine.getInterface(IChargedSlots.class)).alterCharge(slot, -loss); + } + + public Random getRandom() + { + return new Random(); + } + + public void refreshBlock() + { + this.machine.getWorld().markBlockForUpdate(this.machine.getTileEntity().xCoord, this.machine.getTileEntity().yCoord, this.machine.getTileEntity().zCoord); + } + + public IProcess getProcess() + { + return (IProcess)this.machine.getInterface(IProcess.class); + } + + public List getNonNullStacks(int[] slotacclimatiser) + { + List stacks = new ArrayList(); + for (ItemStack stack : getStacks(slotacclimatiser)) { + if (stack != null) { + stacks.add(stack); + } + } + return stacks; + } + + public boolean isServer() + { + return BinnieCore.proxy.isSimulating(this.machine.getWorld()); + } +} diff --git a/src/Java/binnie/core/machines/ManagerMachine.java b/src/Java/binnie/core/machines/ManagerMachine.java new file mode 100644 index 0000000000..53920e5496 --- /dev/null +++ b/src/Java/binnie/core/machines/ManagerMachine.java @@ -0,0 +1,108 @@ +package binnie.core.machines; + +import binnie.core.BinnieCore; +import binnie.core.ManagerBase; +import binnie.core.machines.inventory.ValidatorIcon; +import binnie.core.proxy.BinnieProxy; +import forestry.api.core.INBTTagable; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +public class ManagerMachine + extends ManagerBase +{ + private Map, Class[]> componentInterfaceMap = new HashMap(); + private Map machineGroups = new HashMap(); + private Map> networkIDToComponent = new HashMap(); + private Map, Integer> componentToNetworkID = new HashMap(); + private int nextNetworkID = 0; + private int machineRenderID; + + public void registerMachineGroup(MachineGroup group) + { + this.machineGroups.put(group.getUID(), group); + } + + public MachineGroup getGroup(String name) + { + return (MachineGroup)this.machineGroups.get(name); + } + + public MachinePackage getPackage(String group, String name) + { + MachineGroup machineGroup = getGroup(group); + return machineGroup == null ? null : machineGroup.getPackage(name); + } + + private void registerComponentClass(Class component) + { + if (this.componentInterfaceMap.containsKey(component)) { + return; + } + Set> interfaces = new HashSet(); + + Class currentClass = component; + while (currentClass != null) + { + for (Class clss : currentClass.getInterfaces()) { + interfaces.add(clss); + } + currentClass = currentClass.getSuperclass(); + if (currentClass == Object.class) { + currentClass = null; + } + } + interfaces.remove(INBTTagable.class); + + this.componentInterfaceMap.put(component, interfaces.toArray(new Class[0])); + + int networkID = this.nextNetworkID++; + + this.networkIDToComponent.put(Integer.valueOf(networkID), component); + this.componentToNetworkID.put(component, Integer.valueOf(networkID)); + } + + public int getNetworkID(Class component) + { + return ((Integer)this.componentToNetworkID.get(component)).intValue(); + } + + public Class getComponentClass(int networkID) + { + return (Class)this.networkIDToComponent.get(Integer.valueOf(networkID)); + } + + public int getMachineRenderID() + { + return this.machineRenderID; + } + + public void init() + { + this.machineRenderID = BinnieCore.proxy.getUniqueRenderID(); + + binnie.core.machines.inventory.SlotValidator.IconBee = new ValidatorIcon(BinnieCore.instance, "validator/bee.0", "validator/bee.1"); + + binnie.core.machines.inventory.SlotValidator.IconFrame = new ValidatorIcon(BinnieCore.instance, "validator/frame.0", "validator/frame.1"); + + binnie.core.machines.inventory.SlotValidator.IconCircuit = new ValidatorIcon(BinnieCore.instance, "validator/circuit.0", "validator/circuit.1"); + + binnie.core.machines.inventory.SlotValidator.IconBlock = new ValidatorIcon(BinnieCore.instance, "validator/block.0", "validator/block.1"); + } + + public void postInit() + { + BinnieCore.proxy.registerBlockRenderer(BinnieCore.proxy.createObject("binnie.core.machines.RendererMachine")); + BinnieCore.proxy.registerTileEntity(TileEntityMachine.class, "binnie.tile.machine", BinnieCore.proxy.createObject("binnie.core.machines.RendererMachine")); + } + + public Class[] getComponentInterfaces(Class clss) + { + if (!this.componentInterfaceMap.containsKey(clss)) { + registerComponentClass(clss); + } + return (Class[])this.componentInterfaceMap.get(clss); + } +} diff --git a/src/Java/binnie/core/machines/ModelBlock.java b/src/Java/binnie/core/machines/ModelBlock.java new file mode 100644 index 0000000000..7258ec8654 --- /dev/null +++ b/src/Java/binnie/core/machines/ModelBlock.java @@ -0,0 +1,42 @@ +package binnie.core.machines; + +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +class ModelBlock + extends ModelBase +{ + private ModelRenderer Block; + + public ModelBlock() + { + this.textureWidth = 64; + this.textureHeight = 32; + + this.Block = new ModelRenderer(this, 0, 0); + this.Block.addBox(0.0F, 0.0F, 0.0F, 16, 16, 16); + this.Block.setRotationPoint(-8.0F, 8.0F, -8.0F); + this.Block.setTextureSize(64, 32); + this.Block.mirror = true; + setRotation(this.Block, 0.0F, 0.0F, 0.0F); + } + + public void render(float f, float f1, float f2, float f3, float f4, float f5) + { + super.render(null, f, f1, f2, f3, f4, f5); + setRotationAngles(f, f1, f2, f3, f4, f5); + this.Block.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) + { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } + + public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) + { + super.setRotationAngles(f, f1, f2, f3, f4, f5, null); + } +} diff --git a/src/Java/binnie/core/machines/RendererMachine.java b/src/Java/binnie/core/machines/RendererMachine.java new file mode 100644 index 0000000000..18ad4afe92 --- /dev/null +++ b/src/Java/binnie/core/machines/RendererMachine.java @@ -0,0 +1,68 @@ +package binnie.core.machines; + +import binnie.Binnie; +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +public class RendererMachine + extends TileEntitySpecialRenderer + implements ISimpleBlockRenderingHandler +{ + RenderBlocks blockRenderer; + + public void renderTileEntityAt(TileEntity entity, double x, double y, double z, float var8) + { + renderTileEntity((TileEntityMachine)entity, x, y, z, var8, this.blockRenderer); + } + + public void renderTileEntity(TileEntityMachine entity, double x, double y, double z, float var8, RenderBlocks renderer) + { + if ((entity != null) && (entity.getMachine() != null)) + { + MachinePackage machinePackage = entity.getMachine().getPackage(); + machinePackage.renderMachine(entity.getMachine(), x, y, z, var8, renderer); + } + } + + public void renderInvBlock(RenderBlocks renderblocks, Block block, int i, int j) + { + TileEntity entity = block.createTileEntity(null, i); + renderTileEntity((TileEntityMachine)entity, 0.0D, -0.1D, 0.0D, 0.0625F, renderblocks); + } + + public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) + { + if (modelID == Binnie.Machine.getMachineRenderID()) { + renderInvBlock(renderer, block, metadata, modelID); + } + } + + public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) + { + TileEntityMachine tile = (TileEntityMachine)world.getTileEntity(x, y, z); + if ((tile != null) && (tile.getMachine() != null) && (tile.getMachine().getPackage() != null) && (tile.getMachine().getPackage().getGroup() != null) && (!tile.getMachine().getPackage().getGroup().customRenderer)) { + renderTileEntity(tile, x, y, z, 1.0F, renderer); + } + return true; + } + + public boolean shouldRender3DInInventory(int i) + { + return true; + } + + public int getRenderId() + { + return Binnie.Machine.getMachineRenderID(); + } + + public void func_147496_a(World par1World) + { + this.blockRenderer = new RenderBlocks(par1World); + } +} diff --git a/src/Java/binnie/core/machines/TileEntityMachine.java b/src/Java/binnie/core/machines/TileEntityMachine.java new file mode 100644 index 0000000000..c6acf1fda8 --- /dev/null +++ b/src/Java/binnie/core/machines/TileEntityMachine.java @@ -0,0 +1,112 @@ +package binnie.core.machines; + +import binnie.Binnie; +import binnie.core.machines.base.TileEntityMachineBase; +import binnie.core.machines.component.IInteraction.ChunkUnload; +import binnie.core.machines.component.IInteraction.Invalidation; +import binnie.core.network.INetworkedEntity; +import binnie.core.network.packet.PacketPayload; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.Packet; + +public class TileEntityMachine + extends TileEntityMachineBase + implements INetworkedEntity +{ + private Machine machine; + + public void updateEntity() + { + super.updateEntity(); + if (this.machine != null) { + this.machine.onUpdate(); + } + } + + public boolean canUpdate() + { + return super.canUpdate(); + } + + public TileEntityMachine(MachinePackage pack) + { + setMachine(pack); + } + + public TileEntityMachine() {} + + public void setMachine(MachinePackage pack) + { + if (pack != null) { + this.machine = new Machine(pack, this); + } + } + + public void readFromNBT(NBTTagCompound nbtTagCompound) + { + super.readFromNBT(nbtTagCompound); + String name = nbtTagCompound.getString("name"); + String group = nbtTagCompound.getString("group"); + MachinePackage pack = Binnie.Machine.getPackage(group, name); + if (pack == null) + { + invalidate(); + return; + } + setMachine(pack); + getMachine().readFromNBT(nbtTagCompound); + } + + public void writeToNBT(NBTTagCompound nbtTagCompound) + { + super.writeToNBT(nbtTagCompound); + String name = this.machine.getPackage().getUID(); + String group = this.machine.getPackage().getGroup().getUID(); + nbtTagCompound.setString("group", group); + nbtTagCompound.setString("name", name); + getMachine().writeToNBT(nbtTagCompound); + } + + public void writeToPacket(PacketPayload payload) + { + this.machine.writeToPacket(payload); + } + + public void readFromPacket(PacketPayload payload) + { + this.machine.readFromPacket(payload); + } + + public Machine getMachine() + { + return this.machine; + } + + public void onBlockDestroy() + { + if (getMachine() != null) { + getMachine().onBlockDestroy(); + } + } + + public final Packet getDescriptionPacket() + { + return getMachine() != null ? getMachine().getDescriptionPacket() : null; + } + + public void invalidate() + { + super.invalidate(); + for (IInteraction.Invalidation c : getMachine().getInterfaces(IInteraction.Invalidation.class)) { + c.onInvalidation(); + } + } + + public void onChunkUnload() + { + super.onChunkUnload(); + for (IInteraction.ChunkUnload c : getMachine().getInterfaces(IInteraction.ChunkUnload.class)) { + c.onChunkUnload(); + } + } +} diff --git a/src/Java/binnie/core/machines/base/DefaultInventory.java b/src/Java/binnie/core/machines/base/DefaultInventory.java new file mode 100644 index 0000000000..b72ebd3b57 --- /dev/null +++ b/src/Java/binnie/core/machines/base/DefaultInventory.java @@ -0,0 +1,82 @@ +package binnie.core.machines.base; + +import binnie.core.machines.inventory.IInventoryMachine; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; + +class DefaultInventory + implements IInventoryMachine +{ + public int getSizeInventory() + { + return 0; + } + + public ItemStack getStackInSlot(int i) + { + return null; + } + + public ItemStack decrStackSize(int i, int j) + { + return null; + } + + public ItemStack getStackInSlotOnClosing(int i) + { + return null; + } + + public void setInventorySlotContents(int i, ItemStack itemstack) {} + + public int getInventoryStackLimit() + { + return 64; + } + + public boolean isUseableByPlayer(EntityPlayer entityplayer) + { + return false; + } + + public boolean isItemValidForSlot(int i, ItemStack itemstack) + { + return false; + } + + public int[] getAccessibleSlotsFromSide(int var1) + { + return new int[0]; + } + + public boolean canInsertItem(int i, ItemStack itemstack, int j) + { + return false; + } + + public boolean canExtractItem(int i, ItemStack itemstack, int j) + { + return false; + } + + public boolean isReadOnly(int slot) + { + return false; + } + + public String getInventoryName() + { + return ""; + } + + public boolean hasCustomInventoryName() + { + return false; + } + + public void markDirty() {} + + public void openInventory() {} + + public void closeInventory() {} +} diff --git a/src/Java/binnie/core/machines/base/DefaultPower.java b/src/Java/binnie/core/machines/base/DefaultPower.java new file mode 100644 index 0000000000..5d3e143b2b --- /dev/null +++ b/src/Java/binnie/core/machines/base/DefaultPower.java @@ -0,0 +1,71 @@ +package binnie.core.machines.base; + +import binnie.core.machines.power.IPoweredMachine; +import binnie.core.machines.power.PowerInfo; +import binnie.core.machines.power.PowerInterface; +import cpw.mods.fml.common.Optional.Method; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +class DefaultPower + implements IPoweredMachine +{ + public PowerInfo getPowerInfo() + { + return new PowerInfo(this, 0.0F); + } + + @Optional.Method(modid="IC2") + public double getDemandedEnergy() + { + return 0.0D; + } + + @Optional.Method(modid="IC2") + public int getSinkTier() + { + return 0; + } + + @Optional.Method(modid="IC2") + public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage) + { + return 0.0D; + } + + @Optional.Method(modid="IC2") + public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) + { + return false; + } + + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) + { + return 0; + } + + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) + { + return 0; + } + + public int getEnergyStored(ForgeDirection from) + { + return 0; + } + + public int getMaxEnergyStored(ForgeDirection from) + { + return 0; + } + + public boolean canConnectEnergy(ForgeDirection from) + { + return false; + } + + public PowerInterface getInterface() + { + return null; + } +} diff --git a/src/Java/binnie/core/machines/base/DefaultTankContainer.java b/src/Java/binnie/core/machines/base/DefaultTankContainer.java new file mode 100644 index 0000000000..a0c93b1168 --- /dev/null +++ b/src/Java/binnie/core/machines/base/DefaultTankContainer.java @@ -0,0 +1,79 @@ +package binnie.core.machines.base; + +import binnie.core.machines.inventory.TankSlot; +import binnie.core.machines.power.ITankMachine; +import binnie.core.machines.power.TankInfo; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; + +class DefaultTankContainer + implements ITankMachine +{ + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) + { + return 0; + } + + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) + { + return null; + } + + public TankInfo[] getTankInfos() + { + return new TankInfo[0]; + } + + public boolean isTankReadOnly(int tank) + { + return false; + } + + public boolean isLiquidValidForTank(FluidStack liquid, int tank) + { + return false; + } + + public TankSlot addTank(int index, String name, int capacity) + { + return null; + } + + public IFluidTank getTank(int index) + { + return null; + } + + public TankSlot getTankSlot(int slot) + { + return null; + } + + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) + { + return null; + } + + public boolean canFill(ForgeDirection from, Fluid fluid) + { + return false; + } + + public boolean canDrain(ForgeDirection from, Fluid fluid) + { + return false; + } + + public FluidTankInfo[] getTankInfo(ForgeDirection from) + { + return new FluidTankInfo[0]; + } + + public IFluidTank[] getTanks() + { + return new IFluidTank[0]; + } +} diff --git a/src/Java/binnie/core/machines/base/TileEntityMachineBase.java b/src/Java/binnie/core/machines/base/TileEntityMachineBase.java new file mode 100644 index 0000000000..927671b67a --- /dev/null +++ b/src/Java/binnie/core/machines/base/TileEntityMachineBase.java @@ -0,0 +1,262 @@ +package binnie.core.machines.base; + +import binnie.core.machines.Machine; +import binnie.core.machines.inventory.IInventoryMachine; +import binnie.core.machines.inventory.TankSlot; +import binnie.core.machines.power.IPoweredMachine; +import binnie.core.machines.power.ITankMachine; +import binnie.core.machines.power.PowerInfo; +import binnie.core.machines.power.PowerInterface; +import binnie.core.machines.power.TankInfo; +import cpw.mods.fml.common.Optional.Method; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; + +public class TileEntityMachineBase + extends TileEntity + implements IInventoryMachine, ITankMachine, IPoweredMachine +{ + public IInventoryMachine getInventory() + { + IInventoryMachine inv = (IInventoryMachine)Machine.getInterface(IInventoryMachine.class, this); + return (inv == null) || (inv == this) ? new DefaultInventory() : inv; + } + + public ITankMachine getTankContainer() + { + ITankMachine inv = (ITankMachine)Machine.getInterface(ITankMachine.class, this); + return (inv == null) || (inv == this) ? new DefaultTankContainer() : inv; + } + + public IPoweredMachine getPower() + { + IPoweredMachine inv = (IPoweredMachine)Machine.getInterface(IPoweredMachine.class, this); + return (inv == null) || (inv == this) ? new DefaultPower() : inv; + } + + public int getSizeInventory() + { + return getInventory().getSizeInventory(); + } + + public ItemStack getStackInSlot(int index) + { + return getInventory().getStackInSlot(index); + } + + public ItemStack decrStackSize(int index, int amount) + { + return getInventory().decrStackSize(index, amount); + } + + public ItemStack getStackInSlotOnClosing(int var1) + { + return getInventory().getStackInSlotOnClosing(var1); + } + + public void setInventorySlotContents(int index, ItemStack itemStack) + { + getInventory().setInventorySlotContents(index, itemStack); + } + + public String getInventoryName() + { + return getInventory().getInventoryName(); + } + + public int getInventoryStackLimit() + { + return getInventory().getInventoryStackLimit(); + } + + public boolean isUseableByPlayer(EntityPlayer entityplayer) + { + if (isInvalid()) { + return false; + } + if (getWorldObj().getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this) { + return false; + } + if (entityplayer.getDistanceSq(this.xCoord + 0.5D, this.yCoord + 0.5D, this.zCoord + 0.5D) > 64.0D) { + return false; + } + return getInventory().isUseableByPlayer(entityplayer); + } + + public void openInventory() + { + getInventory().openInventory(); + } + + public void closeInventory() + { + getInventory().closeInventory(); + } + + public boolean hasCustomInventoryName() + { + return getInventory().hasCustomInventoryName(); + } + + public void markDirty() + { + super.markDirty(); + getInventory().markDirty(); + } + + public boolean isItemValidForSlot(int slot, ItemStack itemStack) + { + return getInventory().isItemValidForSlot(slot, itemStack); + } + + public int[] getAccessibleSlotsFromSide(int var1) + { + return getInventory().getAccessibleSlotsFromSide(var1); + } + + public boolean canInsertItem(int i, ItemStack itemstack, int j) + { + return getInventory().canInsertItem(i, itemstack, j); + } + + public boolean canExtractItem(int i, ItemStack itemstack, int j) + { + return getInventory().canExtractItem(i, itemstack, j); + } + + public boolean isReadOnly(int slot) + { + return getInventory().isReadOnly(slot); + } + + public PowerInfo getPowerInfo() + { + return getPower().getPowerInfo(); + } + + public TankInfo[] getTankInfos() + { + return getTankContainer().getTankInfos(); + } + + public boolean isTankReadOnly(int tank) + { + return getTankContainer().isTankReadOnly(tank); + } + + public boolean isLiquidValidForTank(FluidStack liquid, int tank) + { + return getTankContainer().isLiquidValidForTank(liquid, tank); + } + + public TankSlot addTank(int index, String name, int capacity) + { + return getTankContainer().addTank(index, name, capacity); + } + + public IFluidTank getTank(int index) + { + return getTankContainer().get