diff --git a/src/main/java/magicbees/block/BlockPhialingCabinet.java b/src/main/java/magicbees/block/BlockPhialingCabinet.java new file mode 100644 index 0000000..43b9b4f --- /dev/null +++ b/src/main/java/magicbees/block/BlockPhialingCabinet.java @@ -0,0 +1,73 @@ +package magicbees.block; + +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.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import magicbees.main.CommonProxy; +import magicbees.main.utils.TabMagicBees; +import magicbees.tileentity.TileEntityPhialingCabinet; + +public class BlockPhialingCabinet extends BlockContainer { + + @SideOnly(Side.CLIENT) + private IIcon[] icons; + + public BlockPhialingCabinet() { + super(Material.wood); + this.setCreativeTab(TabMagicBees.tabMagicBees); + this.setBlockName("phialingCabinet"); + this.setHardness(1f); + this.setResistance(1.5f); + this.setHarvestLevel("axe", 0); + } + + @Override + public TileEntity createNewTileEntity(World world, int metadata) { + return new TileEntityPhialingCabinet(); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7, + float par8, float par9) { + boolean activate = false; + + return activate; + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int side, int meta) { + + if (side == 0) { + return icons[0]; + } else if (side == 1) { + return icons[1]; + } else if (side == 2 || side == 3) { + return icons[2]; + } else { + return icons[3]; + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister register) { + icons = new IIcon[4]; + + icons[0] = register.registerIcon(CommonProxy.DOMAIN + ":stripped_tainted_birch_log_top"); + icons[1] = register.registerIcon(CommonProxy.DOMAIN + ":stripped_tainted_birch_log_top"); + icons[2] = register.registerIcon(CommonProxy.DOMAIN + ":stripped_tainted_birch_log"); + icons[3] = register.registerIcon(CommonProxy.DOMAIN + ":stripped_tainted_birch_wood"); + } +} diff --git a/src/main/java/magicbees/client/gui/ContainerPhialingCabinet.java b/src/main/java/magicbees/client/gui/ContainerPhialingCabinet.java new file mode 100644 index 0000000..23033fd --- /dev/null +++ b/src/main/java/magicbees/client/gui/ContainerPhialingCabinet.java @@ -0,0 +1,33 @@ +package magicbees.client.gui; + +/* + * public class ContainerPhialingCabinet extends ContainerMB { public TileEntityPhialingCabinet phialingCabinet; public + * int maxSlot = 0; // Constants private static final int SLOT_ONE = 0; private static final int SLOT_TWO = 1; private + * static final int SLOT_THREE = 2; private static final int SLOT_FOUR = 3; private static final int SLOT_FIVE = 4; + * private static final int SLOT_SIX = 5; private static final int SLOT_SEVEN = 6; private static final int SLOT_EIGHT = + * 7; private static final int SLOT_NINE = 8; public ContainerPhialingCabinet(InventoryPlayer inventoryPlayer, + * TileEntityPhialingCabinet phialingCabinet){ this.phialingCabinet = phialingCabinet; // Queen/Princess slot + * addSlotToContainer(new SlotCustomItems(this.phialingCabinet, 0, 29, 39, ItemInterface.getItemStack("Forestry", + * "beeQueenGE", 1), ItemInterface.getItemStack("Forestry", "beePrincessGE", 1))); // Drone slot addSlotToContainer(new + * SlotCustomItems(this.phialingCabinet, 1, 29, 65, ItemInterface.getItemStack("Forestry", "beeDroneGE", 64))); int + * currentSlot = 1; // Frame slots for (int x = 0; x < 3; x++){ currentSlot++; addSlotToContainer(new + * SlotFrame(phialingCabinet, currentSlot, 66, 23 + x * 29)); //LogHelper.info("[1] CURRENTSLOT: " + currentSlot); } for + * (int x = 0; x < 3; x++){ currentSlot++; addSlotToContainer(new Slot(phialingCabinet, currentSlot, 116, 26 + x * 26)); + * //LogHelper.info("[2] CURRENTSLOT: " + currentSlot); } int j = 0; for (int y = 0; y < 2; y++){ for (int x = 0; x < 2; + * x++){ currentSlot++; addSlotToContainer(new Slot(phialingCabinet, currentSlot, 95 + x * 42, 39 + j * 26)); + * //LogHelper.info("[3] CURRENTSLOT: " + currentSlot); } j++; } addPlayerInventory(inventoryPlayer, 0, 110); maxSlot = + * currentSlot; } + * @Override public ItemStack transferStackInSlot(EntityPlayer player, int slotIndex){ Slot itemSlot = + * this.getSlot(slotIndex); boolean clearSlot = false; if (itemSlot != null && itemSlot.getHasStack()) { ItemStack + * srcStack = itemSlot.getStack(); if (slotIndex <= maxSlot && srcStack != null){ clearSlot = + * this.mergeItemStack(srcStack, maxSlot + 1, maxSlot + 36, false); }else{ if (slotIndex > maxSlot && srcStack != null){ + * if (BeeManager.beeRoot.isMember(srcStack)){ if (!BeeManager.beeRoot.isDrone(srcStack)){ if + * (this.getSlot(SLOT_ONE).getHasStack() == false) { clearSlot = this.mergeItemStack(srcStack, SLOT_ONE, SLOT_ONE + 1, + * false); } }else{ if (this.getSlot(SLOT_TWO).isItemValid(srcStack)){ clearSlot = this.mergeItemStack(srcStack, + * SLOT_TWO, SLOT_TWO + 1, false); } } }else if(srcStack.getItem() instanceof IHiveFrame){ clearSlot = + * this.mergeItemStack(srcStack, SLOT_THREE, SLOT_THREE + SLOT_FOUR, false); } } } } if (clearSlot){ + * itemSlot.putStack(null); } itemSlot.onSlotChanged(); player.inventory.markDirty(); return null; } + * @Override public boolean canInteractWith(EntityPlayer entityPlayer) { return + * phialingCabinet.isUseableByPlayer(entityPlayer); } + */ +// } diff --git a/src/main/java/magicbees/main/Config.java b/src/main/java/magicbees/main/Config.java index bbae998..43d2d40 100644 --- a/src/main/java/magicbees/main/Config.java +++ b/src/main/java/magicbees/main/Config.java @@ -25,6 +25,7 @@ import magicbees.block.BlockEnchantedEarth; import magicbees.block.BlockHive; import magicbees.block.BlockMagicApiary; import magicbees.block.BlockManaAuraProvider; +import magicbees.block.BlockPhialingCabinet; import magicbees.block.BlockVisAuraProvider; import magicbees.block.types.HiveType; import magicbees.item.ItemCapsule; @@ -59,6 +60,7 @@ import magicbees.storage.BackpackDefinition; import magicbees.tileentity.TileEntityEffectJar; import magicbees.tileentity.TileEntityMagicApiary; import magicbees.tileentity.TileEntityManaAuraProvider; +import magicbees.tileentity.TileEntityPhialingCabinet; import magicbees.tileentity.TileEntityVisAuraProvider; /** @@ -112,6 +114,7 @@ public class Config { public static BlockEffectJar effectJar; public static BlockHive hive; public static BlockMagicApiary magicApiary; + public static BlockPhialingCabinet phialingCabinet; public static BlockManaAuraProvider manaAuraProvider; public static BlockVisAuraProvider visAuraProvider; @@ -209,6 +212,7 @@ public class Config { voidCapsule = new ItemCapsule(CapsuleType.VOID, capsuleStackSizeMax); setupThaumcraftItems(); + setupPhialingCabinet(); setupBotaniaItems(); setupOreDictionaryEntries(); @@ -493,6 +497,12 @@ public class Config { } } + public void setupPhialingCabinet() { + phialingCabinet = new BlockPhialingCabinet(); + GameRegistry.registerBlock(phialingCabinet, "phialingCabinet"); + GameRegistry.registerTileEntity(TileEntityPhialingCabinet.class, TileEntityPhialingCabinet.tileEntityName); + } + private void setupThaumcraftBackpacks() { try { // 0x8700C6 is a purple-y colour, which is associated with Thaumcraft. @@ -520,7 +530,7 @@ public class Config { private void setupMiscForestryItemHooks() { // Make Aromatic Lumps a swarmer inducer. Chance is /1000. if (aromaticLumpSwarmerRate > 0) { - aromaticLumpSwarmerRate = (aromaticLumpSwarmerRate >= 1000) ? 1000 : aromaticLumpSwarmerRate; + aromaticLumpSwarmerRate = Math.min(aromaticLumpSwarmerRate, 1000); BeeManager.inducers.put(miscResources.getStackForType(ResourceType.AROMATIC_LUMP), aromaticLumpSwarmerRate); } } diff --git a/src/main/java/magicbees/tileentity/TileEntityPhialingCabinet.java b/src/main/java/magicbees/tileentity/TileEntityPhialingCabinet.java new file mode 100644 index 0000000..0a758db --- /dev/null +++ b/src/main/java/magicbees/tileentity/TileEntityPhialingCabinet.java @@ -0,0 +1,314 @@ +package magicbees.tileentity; + +import java.util.Iterator; + +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +import forestry.api.apiculture.IBee; +import forestry.apiculture.IApiary; +import magicbees.bees.BeeManager; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.api.aspects.IAspectContainer; +import thaumcraft.api.aspects.IEssentiaTransport; + +public class TileEntityPhialingCabinet extends TileEntity implements IAspectContainer, IEssentiaTransport { + + public static final String tileEntityName = "Phialing Cabinet"; + + // added directly from the crucible of souls + public AspectList myAspects = new AspectList(); + public Aspect aspect; + public int amount = 0; + public int maxAmount = 64; + public int increment = 0; + + @Override + public void updateEntity() { + if (increment >= 20) { + try { + TileEntity above = worldObj.getTileEntity(this.xCoord, this.yCoord + 1, this.zCoord); + if (IApiary.class.isAssignableFrom(above.getClass())) { + IApiary apiary = (IApiary) above; + ItemStack queenStack = apiary.getApiaryInventory().getQueen(); + + // If the bee isn't a queen then what are we even doing? + if (!BeeManager.beeRoot.isMated(queenStack)) return; + + IBee queen = BeeManager.beeRoot.getMember(queenStack); + String queenUID = queen.getGenome().getPrimary().getUID(); + + Aspect aspect = Aspect.AIR; + + this.myAspects.add(aspect, 1); + } + } catch (Exception ignored) {} + } + increment++; + } + + // added directly from the crucible of souls + @Override + public AspectList getAspects() { + // TODO Auto-generated method stub + return this.myAspects; + } + + // added directly from the crucible of souls + @Override + public void setAspects(AspectList aspects) { + this.myAspects = aspects; + } + + // added directly from the crucible of souls + @Override + public boolean doesContainerAccept(Aspect tag) { + return false; + } + + // added directly from the crucible of souls + @Override + public int addToContainer(Aspect tag, int am) { + if (am == 0) { + return am; + } else { + if (this.amount < this.maxAmount && tag == this.aspect || this.amount == 0) { + this.aspect = tag; + int added = Math.min(am, this.maxAmount - this.amount); + this.amount += added; + am -= added; + } + return am; + } + } + + // added directly from the crucible of souls + @Override + public boolean takeFromContainer(Aspect tag, int amount) { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + if (this.myAspects.getAmount(tag) >= amount) { + this.myAspects.reduce(tag, amount); + return true; + } else { + return false; + } + } + + // added directly from the crucible of souls + @Override + public boolean takeFromContainer(AspectList ot) { + // TODO Auto-generated method stub + boolean hasIt = true; + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + ot.aspects.keySet().iterator(); + for (Aspect next : ot.aspects.keySet()) { + if (this.myAspects.getAmount(next) < ot.getAmount(next)) hasIt = false; + } + if (hasIt) { + for (Aspect next : ot.aspects.keySet()) { + myAspects.reduce(next, ot.getAmount(next)); + } + return true; + } else { + return false; + } + } + + // added directly from the crucible of souls + @Override + public boolean doesContainerContainAmount(Aspect tag, int amount) { + // TODO Auto-generated method stub + return (this.myAspects.getAmount(tag) > amount); + } + + // added directly from the crucible of souls + @Override + public boolean doesContainerContain(AspectList ot) { + boolean hasIt = true; + ot.aspects.keySet().iterator(); + for (Aspect next : ot.aspects.keySet()) { + if (this.myAspects.getAmount(next) < ot.getAmount(next)) hasIt = false; + } + return hasIt; + } + + // added directly from the crucible of souls + @Override + public int containerContains(Aspect tag) { + return this.myAspects.getAmount(tag); + } + + // added directly from the crucible of souls + @Override + public boolean isConnectable(ForgeDirection face) { + return (face != ForgeDirection.UP); + } + + // added directly from the crucible of souls + @Override + public boolean canInputFrom(ForgeDirection face) { + return false; + } + + // added directly from the crucible of souls + @Override + public boolean canOutputTo(ForgeDirection face) { + return (face != ForgeDirection.UP); + } + + // added directly from the crucible of souls + @Override + public void setSuction(Aspect aspect, int amount) { + // TODO Auto-generated method stub + + } + + // added directly from the crucible of souls + @Override + public int takeEssentia(Aspect aspect, int amount, ForgeDirection arg2) { + if (arg2 != ForgeDirection.UP) { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + if (amount > this.myAspects.getAmount(aspect)) { + int total = this.myAspects.getAmount(aspect); + this.myAspects.reduce(aspect, total); + return total; + } else { + this.myAspects.reduce(aspect, amount); + return amount; + } + + } else { + return 0; + } + + } + + // added directly from the crucible of souls + @Override + public int getMinimumSuction() { + // TODO Auto-generated method stub + return 0; + } + + // added directly from the crucible of souls + @Override + public boolean renderExtendedTube() { + // TODO Auto-generated method stub + return false; + // NEW AFTER THIS LINE + } + + // added directly from the crucible of souls + @Override + public Aspect getSuctionType(ForgeDirection face) { + return null; + } + + // added directly from the crucible of souls + @Override + public int getSuctionAmount(ForgeDirection face) { + return 0; + } + + // added directly from the crucible of souls + @Override + public Aspect getEssentiaType(ForgeDirection face) { + return this.myAspects.size() > 0 + ? this.myAspects.getAspects()[this.worldObj.rand.nextInt(this.myAspects.getAspects().length)] + : null; + } + + // added directly from the crucible of souls + @Override + public int getEssentiaAmount(ForgeDirection face) { + return this.myAspects.visSize(); + } + + // added directly from the crucible of souls + @Override + public int addEssentia(Aspect arg0, int arg1, ForgeDirection arg2) { + // TODO Auto-generated method stub + return 0; + } + + /* + * @Override public boolean isItemValidForSlot(int i, ItemStack itemStack) { return true; } + * @Override public void openInventory() { } + * @Override public void closeInventory() { } + * @Override public boolean isUseableByPlayer(EntityPlayer entityPlayer) { return entityPlayer.getDistanceSq(xCoord + * + 0.5, yCoord + 0.5, zCoord + 0.5) <= 64; } + * @Override public int getInventoryStackLimit() { return inventory.getInventoryStackLimit(); } + * @Override public boolean hasCustomInventoryName() { return false; } + * @Override public String getInventoryName() { return tileEntityName; } + * @Override public void setInventorySlotContents(int i, ItemStack itemStack) { + * inventory.setInventorySlotContents(i, itemStack); markDirty(); } + * @Override public ItemStack getStackInSlotOnClosing(int i) { ItemStack item = getStackInSlot(i); + * setInventorySlotContents(i, null); return item; } + * @Override public ItemStack decrStackSize(int i, int j) { ItemStack itemStack = getStackInSlot(i); if (itemStack + * != null) { if (itemStack.stackSize <= j) { setInventorySlotContents(i, null); }else{ itemStack = + * itemStack.splitStack(j); markDirty(); } } return itemStack; } + * @Override public ItemStack getStackInSlot(int i) { return inventory.getStackInSlot(i); } + * @Override public int[] getAccessibleSlotsFromSide(int i) { return inventory.getAccessibleSlotsFromSide(i); } + * @Override public boolean canInsertItem(int i, ItemStack itemStack, int i1) { return inventory.canInsertItem(i, + * itemStack, i1); } + * @Override public boolean canExtractItem(int i, ItemStack itemStack, int i1) { return inventory.canExtractItem(i, + * itemStack, i1); } + * @Override public int getSizeInventory() { return inventory.getSizeInventory(); } private static class + * PhialingCabinetInventory implements IPhialingCabinetInventory { public static final int SLOT_ONE = 0; public + * static final int SLOT_TWO = 1; public static final int SLOT_THREE = 2; public static final int SLOT_FOUR = 3; + * public static final int SLOT_FIVE = 4; public static final int SLOT_SIX = 5; public static final int SLOT_SEVEN = + * 6; public static final int SLOT_EIGHT = 7; public static final int SLOT_NINE = 8; private final + * TileEntityPhialingCabinet phialingCabinet; private ItemStack[] items; private + * PhialingCabinetInventory(TileEntityPhialingCabinet phialingCabinet) { this.phialingCabinet = phialingCabinet; + * this.items = new ItemStack[12]; } + * @Override public ItemStack getSlot1() { return phialingCabinet.getStackInSlot(SLOT_ONE); } + * @Override public ItemStack getSlot2() { return phialingCabinet.getStackInSlot(SLOT_TWO); } + * @Override public ItemStack getSlot3() { return phialingCabinet.getStackInSlot(SLOT_THREE); } + * @Override public ItemStack getSlot4() { return phialingCabinet.getStackInSlot(SLOT_FOUR); } + * @Override public ItemStack getSlot5() { return phialingCabinet.getStackInSlot(SLOT_FIVE); } + * @Override public ItemStack getSlot6() { return phialingCabinet.getStackInSlot(SLOT_SIX); } + * @Override public ItemStack getSlot7() { return phialingCabinet.getStackInSlot(SLOT_SEVEN); } + * @Override public ItemStack getSlot8() { return phialingCabinet.getStackInSlot(SLOT_EIGHT); } + * @Override public ItemStack getSlot9() { return phialingCabinet.getStackInSlot(SLOT_NINE); } + * @Override public void setSlot1(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_ONE, + * itemstack); } + * @Override public void setSlot2(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_TWO, + * itemstack); } + * @Override public void setSlot3(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_THREE, + * itemstack); } + * @Override public void setSlot4(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_FOUR, + * itemstack); } + * @Override public void setSlot5(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_FIVE, + * itemstack); } + * @Override public void setSlot6(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_SIX, + * itemstack); } + * @Override public void setSlot7(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_SEVEN, + * itemstack); } + * @Override public void setSlot8(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_EIGHT, + * itemstack); } + * @Override public void setSlot9(ItemStack itemstack) { phialingCabinet.setInventorySlotContents(SLOT_NINE, + * itemstack); } public int getSizeInventory() { return items.length; } public ItemStack getStackInSlot(int i) { + * return items[i]; } public void setInventorySlotContents(int i, ItemStack itemStack) { items[i] = itemStack; if + * (itemStack != null && itemStack.stackSize > getInventoryStackLimit()){ itemStack.stackSize = + * getInventoryStackLimit(); } } public int[] getAccessibleSlotsFromSide(int side) { if (side == 0 || side == 1) { + * return new int[] { SLOT_ONE, SLOT_TWO }; } else { int[] slots = new int[SLOT_NINE+1]; for (int i = 0, slot = + * SLOT_ONE; i < SLOT_NINE; i++, slot++) { slots[i] = slot; } return slots; } } public boolean canInsertItem(int + * slot, ItemStack itemStack, int side) { return true; } public boolean canExtractItem(int slot, ItemStack + * itemStack, int side) { return true; } public int getInventoryStackLimit() { return 64; } public void + * writeToNBT(NBTTagCompound compound) { NBTTagList itemsNBT = new NBTTagList(); for (int i = 0; i < items.length; + * i++) { ItemStack itemStack = items[i]; if (itemStack != null) { NBTTagCompound item = new NBTTagCompound(); + * item.setByte("Slot", (byte)i); itemStack.writeToNBT(item); itemsNBT.appendTag(item); } } compound.setTag("Items", + * itemsNBT); } public void readFromNBT(NBTTagCompound compound) { NBTTagList items = compound.getTagList("Items", + * Constants.NBT.TAG_COMPOUND); for (int i = 0; i < items.tagCount(); i++) { NBTTagCompound item = + * items.getCompoundTagAt(i); int slot = item.getByte("Slot"); if (slot >= 0 && slot < getSizeInventory()) { + * setInventorySlotContents(slot, ItemStack.loadItemStackFromNBT(item)); } } } } + */ +}