From f558718571ed9462a5ab444e847b86e890525110 Mon Sep 17 00:00:00 2001 From: HbmMods Date: Sun, 4 Nov 2018 21:32:49 +0100 Subject: [PATCH] boilers --- .../textures/blocks/machine_boiler_base.png | Bin 0 -> 295 bytes .../blocks/machine_boiler_electric_front.png | Bin 0 -> 425 bytes .../machine_boiler_electric_front_lit.png | Bin 0 -> 423 bytes .../textures/blocks/machine_boiler_front.png | Bin 0 -> 407 bytes .../blocks/machine_boiler_front_lit.png | Bin 0 -> 536 bytes .../textures/blocks/machine_boiler_port.png | Bin 0 -> 357 bytes .../textures/blocks/machine_boiler_side.png | Bin 0 -> 351 bytes assets/hbm/textures/gui/gui_boiler.png | Bin 0 -> 2736 bytes .../hbm/textures/gui/gui_boiler_electric.png | Bin 0 -> 2837 bytes assets/hbm/textures/gui/gui_nei_boiler.png | Bin 0 -> 1011 bytes com/hbm/blocks/ModBlocks.java | 17 + com/hbm/blocks/machine/MachineBoiler.java | 342 +++++++++++++++ com/hbm/handler/GUIHandler.java | 19 + com/hbm/inventory/MachineRecipes.java | 12 + .../container/ContainerMachineBoiler.java | 95 +++++ com/hbm/inventory/gui/GUIMachineBoiler.java | 66 +++ com/hbm/main/MainRegistry.java | 4 + com/hbm/packet/AuxGaugePacket.java | 9 + .../machine/TileEntityMachineBoiler.java | 394 ++++++++++++++++++ .../TileEntityMachineBoilerElectric.java | 7 + .../machine/TileEntityWatzCore.java | 6 + 21 files changed, 971 insertions(+) create mode 100644 assets/hbm/textures/blocks/machine_boiler_base.png create mode 100644 assets/hbm/textures/blocks/machine_boiler_electric_front.png create mode 100644 assets/hbm/textures/blocks/machine_boiler_electric_front_lit.png create mode 100644 assets/hbm/textures/blocks/machine_boiler_front.png create mode 100644 assets/hbm/textures/blocks/machine_boiler_front_lit.png create mode 100644 assets/hbm/textures/blocks/machine_boiler_port.png create mode 100644 assets/hbm/textures/blocks/machine_boiler_side.png create mode 100644 assets/hbm/textures/gui/gui_boiler.png create mode 100644 assets/hbm/textures/gui/gui_boiler_electric.png create mode 100644 assets/hbm/textures/gui/gui_nei_boiler.png create mode 100644 com/hbm/blocks/machine/MachineBoiler.java create mode 100644 com/hbm/inventory/container/ContainerMachineBoiler.java create mode 100644 com/hbm/inventory/gui/GUIMachineBoiler.java create mode 100644 com/hbm/tileentity/machine/TileEntityMachineBoiler.java create mode 100644 com/hbm/tileentity/machine/TileEntityMachineBoilerElectric.java diff --git a/assets/hbm/textures/blocks/machine_boiler_base.png b/assets/hbm/textures/blocks/machine_boiler_base.png new file mode 100644 index 0000000000000000000000000000000000000000..53366936e18d49a83db5d55fdadc939f79638c4f GIT binary patch literal 295 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`EX7WqAsj$Z!;#VfGjNPRFOLA8DM%s zG&Cque23k-subT%ri@wFVz%A6`@dlFfxGGo{*G^-x)_zaub-Z8^@KAe#-+w}%{=2L zOIPk<`0@6j-`h3*ViCFD4Ub()uZ@Ua$+?TkIC{#tr)i6P9E4(@h9sQRu)W8z`_$fb r*_p}PJ7-o1UHSPsCyo1I^dH8;J&$fodKtG8=u-wyS3j3^P69p3N|-Dx6LyjH(KCUB~Zj zS#~su045Fqtcn8fyIp5*w^u~Ksc;s&cX(A45g-+njgBp5{+EFjvYpeGIp^@YUL((Q zd`+jwvJ9V-39>B1wk+|s*}&Rv*Y+WV*v4M3hizFxf2XWH4S#cdlA-597U>bh=JO?z!QHl67s^KEn!$F7wE-t&I|eG&t5 T^Uxn+00000NkvXXu0mjf4EeL4 literal 0 HcmV?d00001 diff --git a/assets/hbm/textures/blocks/machine_boiler_electric_front_lit.png b/assets/hbm/textures/blocks/machine_boiler_electric_front_lit.png new file mode 100644 index 0000000000000000000000000000000000000000..b1414c36593fa8236696ca7bcc04b51aadbdae13 GIT binary patch literal 423 zcmV;Y0a*TtP)hw+>HSdMF3UB@p$Yc1AzA)0MPIE z8|>I9swxhL174QPD3XXEga8r2<#NIEVuAgB-(bf^(SW{YGpwo#r_%|mszP1Y@q1gA z9Ze#Di30$mqQLiV*V)_c6%lYMoCWV49u-9dNJV9%V~d&pWnhJD=d@+cIlQjd$nzW@ z(bDVQfRSX7$ zj#%lirEi9a;EhgdsV1qoZ6l%^164&`*Nv)auPw)>Gks*fjc(%DwNk)){tp8%19EUV RybAyT002ovPDHLkV1oD2wT=J) literal 0 HcmV?d00001 diff --git a/assets/hbm/textures/blocks/machine_boiler_front.png b/assets/hbm/textures/blocks/machine_boiler_front.png new file mode 100644 index 0000000000000000000000000000000000000000..60c80600cc2f5f8f149e13f412f30e15829f033e GIT binary patch literal 407 zcmV;I0cie-P)C$imcO+-*t%nT0^;lFUKh|qbGb0($KK)&vCjA0mfyl3Phw4m>HML_WN$0oZoG~*Ni$!yK)bF3S690^d(7Bu# z(G%Z`rbb-n(%j*9l4zcn6F*t^&hF-TS&{Is{0rd69OcLq@1p%-o$`!;VUSLx+ai=&g^8m%R^6RCa48XS65ek{nekA#bRM1LI?pfBZ-LcKS{nK zLY5Tg9IASBO7^r5rEOch_dS4_F_}!r)hIOpPz62ewK>KvvisG-0mp8)!_3G4RFzzf zu`@3;wZh749G9z}5g0000RzVJp)%fxl5dldgk`>VQAXd~u-LeO_kK2C4p8Ny&VU+Os z`-8^=I2-^HxO{vqnj5(l;LY*O$0Kk$y+KuRyWJ5Jxv460%o_LSa|r-|d0rYF|BB1X zUQS$QhG_z>*E^J&}iSpja&hOu=DYzFws)}4nsf~%YHBzrG-eq@0q*4K_#uz~n zKoU9X+RNx2-vZV#4#Tk4yz>(yxB?raooab znv5h=6=ntxlK2&lC5h~lloCXwfqdV`7^M`{S}y`KL)UdbtCDPIstS_W_Z?;i0RR!X zft)m|@pMc|>0bfKMqp-G*YyPkfSfY`pzr&eI&q0+hGki9CaEfFtx#2*=ZWJuFwgT% zU3Q61R7z=t&o)XaFHgh|-5dZo&$F$cWU(z(g+$|?@_oD zDWxVos)%pkNiMb42KszHsI@ldqf{?4j^q0lyt1Ww!1dUoHzbi=PK@YDH1`=K xuXnI*+pTK6YsYx2@h8hq_UL>{=|=c%{s&)P9*Pd}Z~OoN002ovPDHLkV1fd=lk)%o literal 0 HcmV?d00001 diff --git a/assets/hbm/textures/gui/gui_boiler.png b/assets/hbm/textures/gui/gui_boiler.png new file mode 100644 index 0000000000000000000000000000000000000000..cc2df3e84f68ffa3da4cdf007211f2d0fc234fcc GIT binary patch literal 2736 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 literal 0 HcmV?d00001 diff --git a/assets/hbm/textures/gui/gui_nei_boiler.png b/assets/hbm/textures/gui/gui_nei_boiler.png new file mode 100644 index 0000000000000000000000000000000000000000..605a221b8c2f619ca86edced25e6e26335853a36 GIT binary patch literal 1011 zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G$6%N?Bp530R%N1DIE+9%&R-#j%@hCddhfow?$y`y8ULREJw|!J 0) + { + int j1 = this.field_149933_a.nextInt(21) + 10; + + if (j1 > itemstack.stackSize) + { + j1 = itemstack.stackSize; + } + + itemstack.stackSize -= j1; + EntityItem entityitem = new EntityItem(p_149749_1_, p_149749_2_ + f, p_149749_3_ + f1, p_149749_4_ + f2, new ItemStack(itemstack.getItem(), j1, itemstack.getItemDamage())); + + if (itemstack.hasTagCompound()) + { + entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy()); + } + + float f3 = 0.05F; + entityitem.motionX = (float)this.field_149933_a.nextGaussian() * f3; + entityitem.motionY = (float)this.field_149933_a.nextGaussian() * f3 + 0.2F; + entityitem.motionZ = (float)this.field_149933_a.nextGaussian() * f3; + p_149749_1_.spawnEntityInWorld(entityitem); + } + } + } + + p_149749_1_.func_147453_f(p_149749_2_, p_149749_3_, p_149749_4_, p_149749_5_); + } + } + + super.breakBlock(p_149749_1_, p_149749_2_, p_149749_3_, p_149749_4_, p_149749_5_, p_149749_6_); + } + + @Override + @SideOnly(Side.CLIENT) + public void randomDisplayTick(World p_149734_1_, int x, int y, int z, Random rand) + { + if (isActive) { + + if(this == ModBlocks.machine_boiler_on) { + int l = p_149734_1_.getBlockMetadata(x, y, z); + float f = x + 0.5F; + float f1 = y + 0.25F + rand.nextFloat() * 6.0F / 16.0F; + float f2 = z + 0.5F; + float f3 = 0.52F; + float f4 = rand.nextFloat() * 0.6F - 0.3F; + float f5 = rand.nextFloat(); + float f6 = rand.nextFloat(); + + if (l == 4) + { + p_149734_1_.spawnParticle("smoke", f - f3, f1, f2 + f4, 0.0D, 0.0D, 0.0D); + p_149734_1_.spawnParticle("flame", f - f3, f1, f2 + f4, 0.0D, 0.0D, 0.0D); + } + else if (l == 5) + { + p_149734_1_.spawnParticle("smoke", f + f3, f1, f2 + f4, 0.0D, 0.0D, 0.0D); + p_149734_1_.spawnParticle("flame", f + f3, f1, f2 + f4, 0.0D, 0.0D, 0.0D); + } + else if (l == 2) + { + p_149734_1_.spawnParticle("smoke", f + f4, f1, f2 - f3, 0.0D, 0.0D, 0.0D); + p_149734_1_.spawnParticle("flame", f + f4, f1, f2 - f3, 0.0D, 0.0D, 0.0D); + } + else if (l == 3) + { + p_149734_1_.spawnParticle("smoke", f + f4, f1, f2 + f3, 0.0D, 0.0D, 0.0D); + p_149734_1_.spawnParticle("flame", f + f4, f1, f2 + f3, 0.0D, 0.0D, 0.0D); + } + } else { + int l = p_149734_1_.getBlockMetadata(x, y, z); + float f = x + 0.5F; + float f1 = y + 0.25F + rand.nextFloat() * 6.0F / 16.0F; + float f2 = z + 0.5F; + float f3 = 0.52F; + float f4 = rand.nextFloat() * 0.6F - 0.3F; + float f5 = rand.nextFloat(); + float f6 = rand.nextFloat(); + + if (l == 4) + { + p_149734_1_.spawnParticle("reddust", f - f3, f1, f2 + f4, 0.0D, 0.0D, 0.0D); + } + else if (l == 5) + { + p_149734_1_.spawnParticle("reddust", f + f3, f1, f2 + f4, 0.0D, 0.0D, 0.0D); + } + else if (l == 2) + { + p_149734_1_.spawnParticle("reddust", f + f4, f1, f2 - f3, 0.0D, 0.0D, 0.0D); + } + else if (l == 3) + { + p_149734_1_.spawnParticle("reddust", f + f4, f1, f2 + f3, 0.0D, 0.0D, 0.0D); + } + } + } + } +} diff --git a/com/hbm/handler/GUIHandler.java b/com/hbm/handler/GUIHandler.java index d5fd76053..fb4d9fadc 100644 --- a/com/hbm/handler/GUIHandler.java +++ b/com/hbm/handler/GUIHandler.java @@ -33,6 +33,7 @@ import com.hbm.tileentity.machine.TileEntityFWatzCore; import com.hbm.tileentity.machine.TileEntityFusionMultiblock; import com.hbm.tileentity.machine.TileEntityMachineAssembler; import com.hbm.tileentity.machine.TileEntityMachineBattery; +import com.hbm.tileentity.machine.TileEntityMachineBoiler; import com.hbm.tileentity.machine.TileEntityMachineCMBFactory; import com.hbm.tileentity.machine.TileEntityMachineCentrifuge; import com.hbm.tileentity.machine.TileEntityMachineChemplant; @@ -718,6 +719,15 @@ public class GUIHandler implements IGuiHandler { } return null; } + + case ModBlocks.guiID_machine_boiler: + { + if(entity instanceof TileEntityMachineBoiler) + { + return new ContainerMachineBoiler(player.inventory, (TileEntityMachineBoiler) entity); + } + return null; + } } return null; } @@ -1358,6 +1368,15 @@ public class GUIHandler implements IGuiHandler { } return null; } + + case ModBlocks.guiID_machine_boiler: + { + if(entity instanceof TileEntityMachineBoiler) + { + return new GUIMachineBoiler(player.inventory, (TileEntityMachineBoiler) entity); + } + return null; + } } } else { //CLIENTONLY GUIS diff --git a/com/hbm/inventory/MachineRecipes.java b/com/hbm/inventory/MachineRecipes.java index 682df397d..f26bb827a 100644 --- a/com/hbm/inventory/MachineRecipes.java +++ b/com/hbm/inventory/MachineRecipes.java @@ -471,6 +471,18 @@ public class MachineRecipes { return list; } + //return: FluidType, amount produced, amount required, heat required (°C * 100) + @SuppressWarnings("incomplete-switch") + public static Object[] getBoilerOutput(FluidType type) { + + switch(type) { + case WATER: return new Object[] { FluidType.STEAM, 5, 5, 10000 }; + case OIL: return new Object[] { FluidType.HOTOIL, 5, 5, 35000 }; + } + + return null; + } + public static List stamps_flat = new ArrayList() {{ add(ModItems.stamp_stone_flat); add(ModItems.stamp_iron_flat); diff --git a/com/hbm/inventory/container/ContainerMachineBoiler.java b/com/hbm/inventory/container/ContainerMachineBoiler.java new file mode 100644 index 000000000..936b40d05 --- /dev/null +++ b/com/hbm/inventory/container/ContainerMachineBoiler.java @@ -0,0 +1,95 @@ +package com.hbm.inventory.container; + +import com.hbm.inventory.SlotMachineOutput; +import com.hbm.tileentity.machine.TileEntityMachineBoiler; +import com.hbm.tileentity.machine.TileEntityMachineGasCent; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.ICrafting; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerMachineBoiler extends Container { + + private TileEntityMachineBoiler diFurnace; + + public ContainerMachineBoiler(InventoryPlayer invPlayer, TileEntityMachineBoiler tedf) { + + diFurnace = tedf; + + //Fluid ID + this.addSlotToContainer(new Slot(tedf, 0, 8, 17)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 1, 8, 53)); + //Input IO + this.addSlotToContainer(new Slot(tedf, 2, 44, 17)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 3, 44, 53)); + //Fuel + this.addSlotToContainer(new Slot(tedf, 4, 98, 53)); + //Output IO + this.addSlotToContainer(new Slot(tedf, 5, 152, 17)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 6, 152, 53)); + + for(int i = 0; i < 3; i++) + { + for(int j = 0; j < 9; j++) + { + this.addSlotToContainer(new Slot(invPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18)); + } + } + + for(int i = 0; i < 9; i++) + { + this.addSlotToContainer(new Slot(invPlayer, i, 8 + i * 18, 142)); + } + } + + @Override + public void addCraftingToCrafters(ICrafting crafting) { + super.addCraftingToCrafters(crafting); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer p_82846_1_, int par2) + { + ItemStack var3 = null; + Slot var4 = (Slot) this.inventorySlots.get(par2); + + if (var4 != null && var4.getHasStack()) + { + ItemStack var5 = var4.getStack(); + var3 = var5.copy(); + + if (par2 <= 6) { + if (!this.mergeItemStack(var5, 7, this.inventorySlots.size(), true)) + { + return null; + } + } + else if (!this.mergeItemStack(var5, 4, 5, false)) + { + if (!this.mergeItemStack(var5, 2, 3, false)) + if (!this.mergeItemStack(var5, 5, 6, false)) + if (!this.mergeItemStack(var5, 0, 1, false)) + return null; + } + + if (var5.stackSize == 0) + { + var4.putStack((ItemStack) null); + } + else + { + var4.onSlotChanged(); + } + } + + return var3; + } + + @Override + public boolean canInteractWith(EntityPlayer player) { + return diFurnace.isUseableByPlayer(player); + } +} diff --git a/com/hbm/inventory/gui/GUIMachineBoiler.java b/com/hbm/inventory/gui/GUIMachineBoiler.java new file mode 100644 index 000000000..087e709f1 --- /dev/null +++ b/com/hbm/inventory/gui/GUIMachineBoiler.java @@ -0,0 +1,66 @@ +package com.hbm.inventory.gui; + +import org.lwjgl.opengl.GL11; + +import com.hbm.inventory.FluidTank; +import com.hbm.inventory.container.ContainerMachineBoiler; +import com.hbm.inventory.container.ContainerMachineGasCent; +import com.hbm.lib.RefStrings; +import com.hbm.tileentity.machine.TileEntityMachineBoiler; +import com.hbm.tileentity.machine.TileEntityMachineGasCent; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; + +public class GUIMachineBoiler extends GuiInfoContainer { + + public static ResourceLocation texture = new ResourceLocation(RefStrings.MODID + ":textures/gui/gui_boiler.png"); + private TileEntityMachineBoiler diFurnace; + + public GUIMachineBoiler(InventoryPlayer invPlayer, TileEntityMachineBoiler tedf) { + super(new ContainerMachineBoiler(invPlayer, tedf)); + diFurnace = tedf; + + this.xSize = 176; + this.ySize = 168; + } + + @Override + public void drawScreen(int mouseX, int mouseY, float f) { + super.drawScreen(mouseX, mouseY, f); + + diFurnace.tanks[0].renderTankInfo(this, mouseX, mouseY, guiLeft + 62, guiTop + 69 - 52, 16, 52); + diFurnace.tanks[1].renderTankInfo(this, mouseX, mouseY, guiLeft + 134, guiTop + 69 - 52, 16, 52); + + this.drawCustomInfoStat(mouseX, mouseY, guiLeft + 102, guiTop + 16, 8, 18, mouseX, mouseY, new String[] { String.valueOf((int)((double)diFurnace.heat / 100D)) + "°C"}); + } + + @Override + protected void drawGuiContainerForegroundLayer(int i, int j) { + String name = this.diFurnace.hasCustomInventoryName() ? this.diFurnace.getInventoryName() : I18n.format(this.diFurnace.getInventoryName()); + + this.fontRendererObj.drawString(name, this.xSize / 2 - this.fontRendererObj.getStringWidth(name) / 2, 6, 4210752); + this.fontRendererObj.drawString(I18n.format("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) { + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + Minecraft.getMinecraft().getTextureManager().bindTexture(texture); + drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize); + + /*int i = (int)diFurnace.getPowerRemainingScaled(34); + drawTexturedModalRect(guiLeft + 8, guiTop + 51 - i, 176, 34 - i, 16, i);*/ + + int j = (int)diFurnace.getHeatScaled(17); + drawTexturedModalRect(guiLeft + 103, guiTop + 33 - j, 194, 16 - j, 6, j); + + Minecraft.getMinecraft().getTextureManager().bindTexture(diFurnace.tanks[0].getSheet()); + diFurnace.tanks[0].renderTank(this, guiLeft + 62, guiTop + 69, diFurnace.tanks[0].getTankType().textureX() * FluidTank.x, diFurnace.tanks[0].getTankType().textureY() * FluidTank.y, 16, 52); + + Minecraft.getMinecraft().getTextureManager().bindTexture(diFurnace.tanks[1].getSheet()); + diFurnace.tanks[1].renderTank(this, guiLeft + 134, guiTop + 69, diFurnace.tanks[1].getTankType().textureX() * FluidTank.x, diFurnace.tanks[1].getTankType().textureY() * FluidTank.y, 16, 52); + } +} diff --git a/com/hbm/main/MainRegistry.java b/com/hbm/main/MainRegistry.java index 9ff93b2c0..2168027d2 100644 --- a/com/hbm/main/MainRegistry.java +++ b/com/hbm/main/MainRegistry.java @@ -274,6 +274,8 @@ import com.hbm.tileentity.machine.TileEntityFusionMultiblock; import com.hbm.tileentity.machine.TileEntityHatch; import com.hbm.tileentity.machine.TileEntityMachineAssembler; import com.hbm.tileentity.machine.TileEntityMachineBattery; +import com.hbm.tileentity.machine.TileEntityMachineBoiler; +import com.hbm.tileentity.machine.TileEntityMachineBoilerElectric; import com.hbm.tileentity.machine.TileEntityMachineCMBFactory; import com.hbm.tileentity.machine.TileEntityMachineCentrifuge; import com.hbm.tileentity.machine.TileEntityMachineChemplant; @@ -722,6 +724,8 @@ public class MainRegistry GameRegistry.registerTileEntity(TileEntityBlastDoor.class, "tileentity_blast_door"); GameRegistry.registerTileEntity(TileEntitySafe.class, "tileentity_safe"); GameRegistry.registerTileEntity(TileEntityMachineGasCent.class, "tileentity_gas_centrifuge"); + GameRegistry.registerTileEntity(TileEntityMachineBoiler.class, "tileentity_boiler"); + GameRegistry.registerTileEntity(TileEntityMachineBoilerElectric.class, "tileentity_electric_boiler"); EntityRegistry.registerModEntity(EntityRocket.class, "entity_rocket", 0, this, 250, 1, true); EntityRegistry.registerModEntity(EntityNukeExplosion.class, "entity_nuke_explosion", 1, this, 250, 1, true); diff --git a/com/hbm/packet/AuxGaugePacket.java b/com/hbm/packet/AuxGaugePacket.java index 50c657855..9d3e0d7a1 100644 --- a/com/hbm/packet/AuxGaugePacket.java +++ b/com/hbm/packet/AuxGaugePacket.java @@ -8,6 +8,7 @@ import com.hbm.tileentity.deco.TileEntityBomber; import com.hbm.tileentity.machine.TileEntityAMSBase; import com.hbm.tileentity.machine.TileEntityAMSEmitter; import com.hbm.tileentity.machine.TileEntityAMSLimiter; +import com.hbm.tileentity.machine.TileEntityMachineBoiler; import com.hbm.tileentity.machine.TileEntityMachineCentrifuge; import com.hbm.tileentity.machine.TileEntityMachineDiesel; import com.hbm.tileentity.machine.TileEntityMachineGasCent; @@ -167,6 +168,14 @@ public class AuxGaugePacket implements IMessage { if(m.id == 1) cent.isProgressing = m.value == 1; } + if (te instanceof TileEntityMachineBoiler) { + TileEntityMachineBoiler boiler = (TileEntityMachineBoiler)te; + + if(m.id == 0) + boiler.heat = m.value; + if(m.id == 1) + boiler.burnTime = m.value; + } } catch (Exception x) { } return null; diff --git a/com/hbm/tileentity/machine/TileEntityMachineBoiler.java b/com/hbm/tileentity/machine/TileEntityMachineBoiler.java new file mode 100644 index 000000000..08319b5ff --- /dev/null +++ b/com/hbm/tileentity/machine/TileEntityMachineBoiler.java @@ -0,0 +1,394 @@ +package com.hbm.tileentity.machine; + +import java.util.ArrayList; +import java.util.List; + +import com.hbm.blocks.machine.MachineBoiler; +import com.hbm.blocks.machine.MachineCoal; +import com.hbm.handler.FluidTypeHandler.FluidType; +import com.hbm.interfaces.IConsumer; +import com.hbm.interfaces.IFluidAcceptor; +import com.hbm.interfaces.IFluidContainer; +import com.hbm.interfaces.IFluidSource; +import com.hbm.inventory.FluidContainerRegistry; +import com.hbm.inventory.FluidTank; +import com.hbm.inventory.MachineRecipes; +import com.hbm.items.ModItems; +import com.hbm.items.special.ItemBattery; +import com.hbm.lib.Library; +import com.hbm.packet.AuxElectricityPacket; +import com.hbm.packet.AuxGaugePacket; +import com.hbm.packet.PacketDispatcher; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.tileentity.TileEntityFurnace; + +public class TileEntityMachineBoiler extends TileEntity implements ISidedInventory, IFluidContainer, IFluidAcceptor, IFluidSource { + + private ItemStack slots[]; + + public int burnTime; + public int heat; + public static final int maxHeat = 50000; + public int age = 0; + public List list = new ArrayList(); + public FluidTank[] tanks; + + private static final int[] slots_top = new int[] {4}; + private static final int[] slots_bottom = new int[] {6}; + private static final int[] slots_side = new int[] {4}; + + private String customName; + + public TileEntityMachineBoiler() { + slots = new ItemStack[7]; + tanks = new FluidTank[2]; + tanks[0] = new FluidTank(FluidType.WATER, 8000, 0); + tanks[1] = new FluidTank(FluidType.STEAM, 8000, 1); + } + + @Override + public int getSizeInventory() { + return slots.length; + } + + @Override + public ItemStack getStackInSlot(int i) { + return slots[i]; + } + + @Override + public ItemStack getStackInSlotOnClosing(int i) { + if(slots[i] != null) + { + ItemStack itemStack = slots[i]; + slots[i] = null; + return itemStack; + } else { + return null; + } + } + + @Override + public void setInventorySlotContents(int i, ItemStack itemStack) { + slots[i] = itemStack; + if(itemStack != null && itemStack.stackSize > getInventoryStackLimit()) + { + itemStack.stackSize = getInventoryStackLimit(); + } + } + + @Override + public String getInventoryName() { + return this.hasCustomInventoryName() ? this.customName : "container.machineBoiler"; + } + + @Override + public boolean hasCustomInventoryName() { + return this.customName != null && this.customName.length() > 0; + } + + public void setCustomName(String name) { + this.customName = name; + } + + @Override + public int getInventoryStackLimit() { + return 64; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer player) { + if(worldObj.getTileEntity(xCoord, yCoord, zCoord) != this) + { + return false; + }else{ + return player.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <=64; + } + } + + //You scrubs aren't needed for anything (right now) + @Override + public void openInventory() {} + @Override + public void closeInventory() {} + + @Override + public boolean isItemValidForSlot(int i, ItemStack stack) { + + if(i == 4) + if(TileEntityFurnace.getItemBurnTime(stack) > 0) + return true; + + return false; + } + + @Override + public ItemStack decrStackSize(int i, int j) { + if(slots[i] != null) + { + if(slots[i].stackSize <= j) + { + ItemStack itemStack = slots[i]; + slots[i] = null; + return itemStack; + } + ItemStack itemStack1 = slots[i].splitStack(j); + if (slots[i].stackSize == 0) + { + slots[i] = null; + } + + return itemStack1; + } else { + return null; + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + NBTTagList list = nbt.getTagList("items", 10); + + heat = nbt.getInteger("heat"); + burnTime = nbt.getInteger("burnTime"); + tanks[0].readFromNBT(nbt, "water"); + tanks[1].readFromNBT(nbt, "steam"); + slots = new ItemStack[getSizeInventory()]; + + for(int i = 0; i < list.tagCount(); i++) + { + NBTTagCompound nbt1 = list.getCompoundTagAt(i); + byte b0 = nbt1.getByte("slot"); + if(b0 >= 0 && b0 < slots.length) + { + slots[b0] = ItemStack.loadItemStackFromNBT(nbt1); + } + } + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("heat", heat); + nbt.setInteger("burnTime", burnTime); + tanks[0].writeToNBT(nbt, "water"); + tanks[1].writeToNBT(nbt, "steam"); + NBTTagList list = new NBTTagList(); + + for(int i = 0; i < slots.length; i++) + { + if(slots[i] != null) + { + NBTTagCompound nbt1 = new NBTTagCompound(); + nbt1.setByte("slot", (byte)i); + slots[i].writeToNBT(nbt1); + list.appendTag(nbt1); + } + } + nbt.setTag("items", list); + } + + @Override + public int[] getAccessibleSlotsFromSide(int p_94128_1_) + { + return p_94128_1_ == 0 ? slots_bottom : (p_94128_1_ == 1 ? slots_top : slots_side); + } + + @Override + public boolean canInsertItem(int i, ItemStack itemStack, int j) { + return this.isItemValidForSlot(i, itemStack); + } + + @Override + public boolean canExtractItem(int i, ItemStack itemStack, int j) { + return false; + } + + public int getHeatScaled(int i) { + return (heat * i) / maxHeat; + } + + @Override + public void updateEntity() { + + if(!worldObj.isRemote) + { + age++; + if(age >= 20) + { + age = 0; + } + + if(age == 9 || age == 19) + fillFluidInit(tanks[1].getTankType()); + + tanks[0].setType(0, 1, slots); + tanks[0].loadTank(2, 3, slots); + //TODO: set tanks[1]'s type accordingly + + Object[] outs = MachineRecipes.getBoilerOutput(tanks[0].getTankType()); + + if(outs == null) { + tanks[1].setTankType(FluidType.NONE); + } else { + tanks[1].setTankType((FluidType) outs[0]); + } + + tanks[1].unloadTank(5, 6, slots); + + for(int i = 0; i < 2; i++) + tanks[i].updateTank(xCoord, yCoord, zCoord); + + boolean flag1 = false; + + if(heat > 0) { + heat -= 15; + } + + if(burnTime > 0) { + burnTime--; + heat += 50; + flag1 = true; + } + + if(burnTime == 0 && !flag1) + MachineBoiler.updateBlockState(false, worldObj, xCoord, yCoord, zCoord); + + if(heat > maxHeat) + heat = maxHeat; + + if(burnTime == 0 && TileEntityFurnace.getItemBurnTime(slots[4]) > 0) { + burnTime = (int) (TileEntityFurnace.getItemBurnTime(slots[4]) * 0.25); + slots[4].stackSize--; + + if(slots[4].stackSize <= 0) + slots[4] = null; + + if(!flag1) + MachineBoiler.updateBlockState(true, worldObj, xCoord, yCoord, zCoord); + } + + if(outs != null) { + + for(int i = 0; i < (heat / ((Integer)outs[3]).intValue()); i++) { + if(tanks[0].getFill() >= ((Integer)outs[2]).intValue() && tanks[1].getFill() + ((Integer)outs[1]).intValue() <= tanks[1].getMaxFill()) { + tanks[0].setFill(tanks[0].getFill() - ((Integer)outs[2]).intValue()); + tanks[1].setFill(tanks[1].getFill() + ((Integer)outs[1]).intValue()); + + if(i == 0) + heat -= 25; + else + heat -= 5; + } + } + } + + if(heat < 0) { + heat = 0; + } + + PacketDispatcher.wrapper.sendToAll(new AuxGaugePacket(xCoord, yCoord, zCoord, heat, 0)); + PacketDispatcher.wrapper.sendToAll(new AuxGaugePacket(xCoord, yCoord, zCoord, burnTime, 1)); + } + } + + public boolean isItemValid() { + + if(slots[1] != null && TileEntityFurnace.getItemBurnTime(slots[1]) > 0) + { + return true; + } + + return false; + } + + @Override + public void fillFluidInit(FluidType type) { + + fillFluid(this.xCoord + 1, this.yCoord, this.zCoord, getTact(), type); + fillFluid(this.xCoord - 1, this.yCoord, this.zCoord, getTact(), type); + fillFluid(this.xCoord, this.yCoord + 1, this.zCoord, getTact(), type); + fillFluid(this.xCoord, this.yCoord - 1, this.zCoord, getTact(), type); + fillFluid(this.xCoord, this.yCoord, this.zCoord + 1, getTact(), type); + fillFluid(this.xCoord, this.yCoord, this.zCoord - 1, getTact(), type); + } + + @Override + public void fillFluid(int x, int y, int z, boolean newTact, FluidType type) { + Library.transmitFluid(x, y, z, newTact, this, worldObj, type); + } + + @Override + public boolean getTact() { + if(age >= 0 && age < 10) + { + return true; + } + + return false; + } + + @Override + public void setFluidFill(int i, FluidType type) { + if(type.name().equals(tanks[0].getTankType().name())) + tanks[0].setFill(i); + else if(type.name().equals(tanks[1].getTankType().name())) + tanks[1].setFill(i); + } + + @Override + public int getFluidFill(FluidType type) { + if(type.name().equals(tanks[0].getTankType().name())) + return tanks[0].getFill(); + else if(type.name().equals(tanks[1].getTankType().name())) + return tanks[1].getFill(); + + return 0; + } + + @Override + public int getMaxFluidFill(FluidType type) { + if(type.name().equals(tanks[0].getTankType().name())) + return tanks[0].getMaxFill(); + + return 0; + } + + @Override + public void setFillstate(int fill, int index) { + if(index < 2 && tanks[index] != null) + tanks[index].setFill(fill); + } + + @Override + public void setType(FluidType type, int index) { + if(index < 2 && tanks[index] != null) + tanks[index].setTankType(type); + } + + @Override + public List getTanks() { + List list = new ArrayList(); + list.add(tanks[0]); + list.add(tanks[1]); + + return list; + } + + @Override + public List getFluidList(FluidType type) { + return list; + } + + @Override + public void clearFluidList(FluidType type) { + list.clear(); + } +} diff --git a/com/hbm/tileentity/machine/TileEntityMachineBoilerElectric.java b/com/hbm/tileentity/machine/TileEntityMachineBoilerElectric.java new file mode 100644 index 000000000..6bb8b71fc --- /dev/null +++ b/com/hbm/tileentity/machine/TileEntityMachineBoilerElectric.java @@ -0,0 +1,7 @@ +package com.hbm.tileentity.machine; + +import net.minecraft.tileentity.TileEntity; + +public class TileEntityMachineBoilerElectric extends TileEntity { + +} diff --git a/com/hbm/tileentity/machine/TileEntityWatzCore.java b/com/hbm/tileentity/machine/TileEntityWatzCore.java index f6002ce2d..cddf673cb 100644 --- a/com/hbm/tileentity/machine/TileEntityWatzCore.java +++ b/com/hbm/tileentity/machine/TileEntityWatzCore.java @@ -734,6 +734,7 @@ public class TileEntityWatzCore extends TileEntity implements ISidedInventory, I public void setType(FluidType type, int index) { tank.setTankType(type); } + @Override public void fillFluidInit(FluidType type) { fillFluid(this.xCoord + 4, this.yCoord, this.zCoord, getTact(), type); @@ -742,22 +743,27 @@ public class TileEntityWatzCore extends TileEntity implements ISidedInventory, I fillFluid(this.xCoord, this.yCoord, this.zCoord - 4, getTact(), type); } + @Override public void fillFluid(int x, int y, int z, boolean newTact, FluidType type) { Library.transmitFluid(x, y, z, newTact, this, worldObj, type); } + @Override public int getFluidFill(FluidType type) { return tank.getFill(); } + @Override public void setFluidFill(int i, FluidType type) { tank.setFill(i); } + @Override public List getFluidList(FluidType type) { return list1; } + @Override public void clearFluidList(FluidType type) { list1.clear();