From 5a0fd881823734a2dc00712ced2081c14cea39f4 Mon Sep 17 00:00:00 2001 From: Rseifert Date: Thu, 23 Aug 2012 04:02:25 -0400 Subject: [PATCH] Init 1.3.2 Update upload Most of it is working just need some more work before can be call Updated. Still have to fix model rotations, Add new steam engine, Add Eletric motor block, Add crank Shaft, Fix all models to fit to pipes, Re do pipes to look nicer. Most likely i need to fix both steam engine and boiler's share resources methods, and Generation methods --- 1.3/common/EUI/SteamPower/BlockMachine.java | 289 ++++++++++ 1.3/common/EUI/SteamPower/ItemCoalFuel.java | 59 ++ 1.3/common/EUI/SteamPower/ItemMachine.java | 49 ++ 1.3/common/EUI/SteamPower/ItemParts.java | 70 +++ 1.3/common/EUI/SteamPower/SteamPower.java | 113 ++++ 1.3/common/EUI/SteamPower/SteamProxy.java | 72 +++ .../EUI/SteamPower/TileEntityMachine.java | 136 +++++ .../EUI/SteamPower/TileEntityNuller.java | 29 + .../EUI/SteamPower/api/IHeatConsumer.java | 22 + .../EUI/SteamPower/api/IHeatProducer.java | 14 + .../SteamPower/boiler/ContainerBoiler.java | 59 ++ .../SteamPower/boiler/TileEntityBoiler.java | 540 ++++++++++++++++++ .../SteamPower/burner/ContainerFireBox.java | 42 ++ .../SteamPower/burner/TileEntityFireBox.java | 301 ++++++++++ .../turbine/ContainerGenerator.java | 41 ++ .../turbine/TileEntityGenerator.java | 359 ++++++++++++ .../EUIClient/SteamPower/GUIFireBox.java | 91 +++ .../EUIClient/SteamPower/GUIGenerator.java | 79 +++ .../EUIClient/SteamPower/GuiBoiler.java | 88 +++ .../EUIClient/SteamPower/ModelEngine.java | 242 ++++++++ .../EUIClient/SteamPower/ModelFurnace.java | 82 +++ .../EUIClient/SteamPower/ModelTank.java | 155 +++++ .../EUIClient/SteamPower/RenderBoiler.java | 30 + .../EUIClient/SteamPower/RenderFurnace.java | 29 + .../SteamPower/RenderSteamEngine.java | 29 + .../SteamPower/SteamClientProxy.java | 39 ++ .../EUIClient/Textures/BoilerGui.png | Bin 0 -> 1876 bytes .../EUIClient/Textures/CopperWire.png | Bin 0 -> 3196 bytes .../EUIClient/Textures/DefaultPipe.png | Bin 0 -> 770 bytes 1.3/minecraft/EUIClient/Textures/Furnace.png | Bin 0 -> 2426 bytes .../EUIClient/Textures/GrinderGUI.png | Bin 0 -> 1284 bytes 1.3/minecraft/EUIClient/Textures/Items.png | Bin 0 -> 29993 bytes 1.3/minecraft/EUIClient/Textures/SteamGUI.png | Bin 0 -> 3762 bytes .../EUIClient/Textures/SteamPipe.png | Bin 0 -> 3196 bytes .../EUIClient/Textures/WaterPipe.png | Bin 0 -> 3192 bytes 1.3/minecraft/EUIClient/Textures/blocks.png | Bin 0 -> 22475 bytes .../EUIClient/Textures/tankTexture.png | Bin 0 -> 658 bytes 37 files changed, 3059 insertions(+) create mode 100644 1.3/common/EUI/SteamPower/BlockMachine.java create mode 100644 1.3/common/EUI/SteamPower/ItemCoalFuel.java create mode 100644 1.3/common/EUI/SteamPower/ItemMachine.java create mode 100644 1.3/common/EUI/SteamPower/ItemParts.java create mode 100644 1.3/common/EUI/SteamPower/SteamPower.java create mode 100644 1.3/common/EUI/SteamPower/SteamProxy.java create mode 100644 1.3/common/EUI/SteamPower/TileEntityMachine.java create mode 100644 1.3/common/EUI/SteamPower/TileEntityNuller.java create mode 100644 1.3/common/EUI/SteamPower/api/IHeatConsumer.java create mode 100644 1.3/common/EUI/SteamPower/api/IHeatProducer.java create mode 100644 1.3/common/EUI/SteamPower/boiler/ContainerBoiler.java create mode 100644 1.3/common/EUI/SteamPower/boiler/TileEntityBoiler.java create mode 100644 1.3/common/EUI/SteamPower/burner/ContainerFireBox.java create mode 100644 1.3/common/EUI/SteamPower/burner/TileEntityFireBox.java create mode 100644 1.3/common/EUI/SteamPower/turbine/ContainerGenerator.java create mode 100644 1.3/common/EUI/SteamPower/turbine/TileEntityGenerator.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/GUIFireBox.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/GUIGenerator.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/GuiBoiler.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/ModelEngine.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/ModelFurnace.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/ModelTank.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/RenderBoiler.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/RenderFurnace.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/RenderSteamEngine.java create mode 100644 1.3/minecraft/EUIClient/SteamPower/SteamClientProxy.java create mode 100644 1.3/minecraft/EUIClient/Textures/BoilerGui.png create mode 100644 1.3/minecraft/EUIClient/Textures/CopperWire.png create mode 100644 1.3/minecraft/EUIClient/Textures/DefaultPipe.png create mode 100644 1.3/minecraft/EUIClient/Textures/Furnace.png create mode 100644 1.3/minecraft/EUIClient/Textures/GrinderGUI.png create mode 100644 1.3/minecraft/EUIClient/Textures/Items.png create mode 100644 1.3/minecraft/EUIClient/Textures/SteamGUI.png create mode 100644 1.3/minecraft/EUIClient/Textures/SteamPipe.png create mode 100644 1.3/minecraft/EUIClient/Textures/WaterPipe.png create mode 100644 1.3/minecraft/EUIClient/Textures/blocks.png create mode 100644 1.3/minecraft/EUIClient/Textures/tankTexture.png diff --git a/1.3/common/EUI/SteamPower/BlockMachine.java b/1.3/common/EUI/SteamPower/BlockMachine.java new file mode 100644 index 00000000..6a5ac1bf --- /dev/null +++ b/1.3/common/EUI/SteamPower/BlockMachine.java @@ -0,0 +1,289 @@ +package EUI.SteamPower; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import universalelectricity.basiccomponents.BasicComponents; + +import EUI.SteamPower.boiler.TileEntityBoiler; +import EUI.SteamPower.burner.TileEntityFireBox; +import EUI.SteamPower.turbine.TileEntityGenerator; +import net.minecraft.client.Minecraft; +import net.minecraft.src.*; +import EUI.SteamPower.*; +import EUIClient.SteamPower.GUIFireBox; +import EUIClient.SteamPower.GUIGenerator; +import EUIClient.SteamPower.GuiBoiler; +import net.minecraftforge.common.ForgeDirection; + +public class BlockMachine extends universalelectricity.extend.BlockMachine +{ + + private Random furnaceRand = new Random(); + private static boolean keepFurnaceInventory = true; + + public BlockMachine(int par1) + { + super("machine", par1, Material.iron); + this.setRequiresSelfNotify(); + this.setCreativeTab(CreativeTabs.tabBlock); + + } + @Override + public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List) + { + + par3List.add(new ItemStack(this, 1, 1)); + par3List.add(new ItemStack(this, 1, 2)); + par3List.add(new ItemStack(this, 1, 3)); + par3List.add(new ItemStack(this, 1, 15)); + } + @Override + protected int damageDropped(int metadata) + { + return metadata; + } + @Override + public void randomDisplayTick(World par1World, int x, int y, int z, Random par5Random) + { + TileEntity tileEntity = par1World.getBlockTileEntity(x, y, z); + + if(tileEntity instanceof TileEntityFireBox) + { + if(((TileEntityFireBox)tileEntity).generateRate > 0) + { + int var6 = ((TileEntityFireBox) tileEntity).getDirection(); + float var7 = (float)x + 0.5F; + float var8 = (float)y + 0.0F + par5Random.nextFloat() * 6.0F / 16.0F; + float var9 = (float)z + 0.5F; + float var10 = 0.52F; + float var11 = par5Random.nextFloat() * 0.6F - 0.3F; + + if (var6 == 5) + { + par1World.spawnParticle("smoke", (double)(var7 - var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 - var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + } + else if (var6 == 4) + { + par1World.spawnParticle("smoke", (double)(var7 + var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 + var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + } + else if (var6 == 3) + { + par1World.spawnParticle("smoke", (double)(var7 + var11), (double)var8, (double)(var9 - var10), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 + var11), (double)var8, (double)(var9 - var10), 0.0D, 0.0D, 0.0D); + } + else if (var6 == 2) + { + par1World.spawnParticle("smoke", (double)(var7 + var11), (double)var8, (double)(var9 + var10), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 + var11), (double)var8, (double)(var9 + var10), 0.0D, 0.0D, 0.0D); + } + } + } + } + @Override + public int getBlockTexture(IBlockAccess par1iBlockAccess, int x, int y, int z, int side) + { + TileEntity tileEntity = par1iBlockAccess.getBlockTileEntity(x, y, z); + int metadata = par1iBlockAccess.getBlockMetadata(x, y, z); + if(metadata > -1 && tileEntity != null) + { + if (side == 1) + { + switch(metadata) + { + case 0: return 6; + case 1: return 4; + case 2: return 7; + case 3: return 4; + } + } + //If it is the back side + else if(side == ((TileEntityMachine) tileEntity).getDirection()); + { + switch(metadata) + { + case 0: return 5; + case 2: return 8; + case 3: return 4; + } + } + + + switch(metadata) + { + case 1: return 0; + case 2: return 2; + } + } + return 1; + + + } + @Override + public boolean onUseWrench(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer) + { + TileEntityMachine tileEntity = (TileEntityMachine)par1World.getBlockTileEntity(par2, par3, par4); + + //Reorient the block + switch(tileEntity.getDirection()) + { + case 2: tileEntity.setDirection(5); break; + case 5: tileEntity.setDirection(3); break; + case 3: tileEntity.setDirection(4); break; + case 4: tileEntity.setDirection(2); break; + } + + return true; + } + /** + * Called upon block activation (left or right click on the block.). The three integers represent x,y,z of the + * block. + */ + @Override + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer) + { + if (par1World.isRemote) + { + return true; + } + else + { + TileEntity blockEntity = (TileEntity)par1World.getBlockTileEntity(x, y, z); + + if (blockEntity != null) + { + + if(blockEntity instanceof TileEntityBoiler) + { + TileEntity var6 = (TileEntityBoiler)par1World.getBlockTileEntity(x, y, z); + par5EntityPlayer.openGui(SteamPower.instance, 1, par1World, x, y, z); + } + if(blockEntity instanceof TileEntityFireBox) + { + TileEntity var6 = (TileEntityFireBox)par1World.getBlockTileEntity(x, y, z); + par5EntityPlayer.openGui(SteamPower.instance, 0, par1World, x, y, z); + } + if(blockEntity instanceof TileEntityGenerator) + { + TileEntity var6 = (TileEntityGenerator)par1World.getBlockTileEntity(x, y, z); + par5EntityPlayer.openGui(SteamPower.instance, 2, par1World, x, y, z); + } + } + + return true; + } + } + @Override + public TileEntity createNewTileEntity(World var1,int meta) + { + switch(meta) + { + case 1: return new TileEntityBoiler(); + case 2: return new TileEntityFireBox(); + case 3: return new TileEntityGenerator(); + case 15: return new TileEntityNuller(); + } + return null; + } + + /** + * Called when the block is placed in the world. + */ + @Override + public void onBlockPlacedBy(World par1World, int x, int y, int z, EntityLiving par5EntityLiving) + { + int angle = MathHelper.floor_double((par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3; + int metadata = par1World.getBlockMetadata(x, y, z); + TileEntityMachine tileEntity = (TileEntityMachine)par1World.getBlockTileEntity(x, y, z); + + switch (angle) + { + case 0: tileEntity.setDirection(5); break; + case 1: tileEntity.setDirection(3); break; + case 2: tileEntity.setDirection(4); break; + case 3: tileEntity.setDirection(2); break; + } + } + /** + * Called whenever the block is removed. + */ + @Override + public void breakBlock(World par1World, int par2, int par3, int par4,int par5, int par6){ + if (!keepFurnaceInventory) + { + TileEntityMachine var5 = null; + TileEntity entityBox = par1World.getBlockTileEntity(par2, par3, par4); + if(entityBox instanceof TileEntityFireBox) + { + var5 = (TileEntityFireBox)entityBox; + } + else if(entityBox instanceof TileEntityBoiler) + { + var5 = (TileEntityBoiler)entityBox; + } + if (var5 != null) + { + for (int var6 = 0; var6 < var5.getSizeInventory(); ++var6) + { + ItemStack var7 = var5.getStackInSlot(var6); + + if (var7 != null) + { + float var8 = this.furnaceRand.nextFloat() * 0.8F + 0.1F; + float var9 = this.furnaceRand.nextFloat() * 0.8F + 0.1F; + float var10 = this.furnaceRand.nextFloat() * 0.8F + 0.1F; + + while (var7.stackSize > 0) + { + int var11 = this.furnaceRand.nextInt(21) + 10; + + if (var11 > var7.stackSize) + { + var11 = var7.stackSize; + } + + var7.stackSize -= var11; + EntityItem var12 = new EntityItem(par1World, (double)((float)par2 + var8), (double)((float)par3 + var9), (double)((float)par4 + var10), new ItemStack(var7.itemID, var11, var7.getItemDamage())); + + if (var7.hasTagCompound()) + { + var12.item.setTagCompound((NBTTagCompound)var7.getTagCompound().copy()); + } + + float var13 = 0.05F; + var12.motionX = (double)((float)this.furnaceRand.nextGaussian() * var13); + var12.motionY = (double)((float)this.furnaceRand.nextGaussian() * var13 + 0.2F); + var12.motionZ = (double)((float)this.furnaceRand.nextGaussian() * var13); + par1World.spawnEntityInWorld(var12); + } + } + } + } + } + + super.breakBlock(par1World, par2, par3, par4, par5, par6); + } + @Override + public String getTextureFile() + { + return "/EUIClient/textures/blocks/blocks.png"; + } + @Override + public boolean isOpaqueCube() + { + return false; + } + @Override + public boolean renderAsNormalBlock() + { + return false; + } + @Override + public int getRenderType() + { + return -1; + } +} diff --git a/1.3/common/EUI/SteamPower/ItemCoalFuel.java b/1.3/common/EUI/SteamPower/ItemCoalFuel.java new file mode 100644 index 00000000..8a25c219 --- /dev/null +++ b/1.3/common/EUI/SteamPower/ItemCoalFuel.java @@ -0,0 +1,59 @@ +package EUI.SteamPower; + +import java.util.ArrayList; + +import net.minecraft.src.*; + +public class ItemCoalFuel extends Item +{ + + public ItemCoalFuel(int par1) + { + super(par1); + this.setItemName("CoalDust"); + this.setHasSubtypes(true); + this.setMaxDamage(0); + this.setMaxStackSize(64); + } + @Override + public int getIconFromDamage(int par1) + { + switch(par1) + { + case 0: return 0; + case 1: return 1; + case 2: return 2; + } + return this.iconIndex; + } + @Override + public String getTextureFile() { + // TODO Auto-generated method stub + return "/eui/Items.png"; + } + public String getItemName() + { + return "CoalDust"; + } + + + + public String getItemNameIS(ItemStack par1ItemStack) + { + int var3 = par1ItemStack.getItemDamage(); + switch(var3) + { + case 0: return "CoalNuggets"; + case 1: return "CoalPellets"; + case 2: return "CoalDust"; + } + return this.getItemName(); + } + public void addCreativeItems(ArrayList itemList) { + + itemList.add(new ItemStack(this, 1,0)); + itemList.add(new ItemStack(this, 1,1)); + itemList.add(new ItemStack(this, 1,2)); + + } +} diff --git a/1.3/common/EUI/SteamPower/ItemMachine.java b/1.3/common/EUI/SteamPower/ItemMachine.java new file mode 100644 index 00000000..5a41ce2d --- /dev/null +++ b/1.3/common/EUI/SteamPower/ItemMachine.java @@ -0,0 +1,49 @@ +package EUI.SteamPower; +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.src.*; + +public class ItemMachine extends ItemBlock { + + public ItemMachine(int id) { + super(id); + setMaxDamage(0); + setHasSubtypes(true); + this.setTabToDisplayOn(CreativeTabs.tabBlock); + } + @Override + public void getSubItems(int par1, CreativeTabs par2CreativeTabs, List par3List) + { + + par3List.add(new ItemStack(this, 1, 1)); + par3List.add(new ItemStack(this, 1, 2)); + par3List.add(new ItemStack(this, 1, 3)); + par3List.add(new ItemStack(this, 1, 15)); + } + @Override + public int getMetadata(int metadata) + { + return metadata; + } + @Override + public String getItemName() + { + return "Machine"; + } + @Override + public String getItemNameIS(ItemStack par1ItemStack) + { + int var3 = par1ItemStack.getItemDamage(); + switch(var3) + { + case 0: return "CoalProcessor"; + case 1: return "Boiler"; + case 2: return "FireBox"; + case 3: return "SteamGen"; + case 15: return "EnergyNuller"; + } + return this.getItemName(); + } + } + diff --git a/1.3/common/EUI/SteamPower/ItemParts.java b/1.3/common/EUI/SteamPower/ItemParts.java new file mode 100644 index 00000000..22255215 --- /dev/null +++ b/1.3/common/EUI/SteamPower/ItemParts.java @@ -0,0 +1,70 @@ +package EUI.SteamPower; + +import java.util.ArrayList; + +import net.minecraft.src.Item; +import net.minecraft.src.ItemStack; + +public class ItemParts extends Item{ + + public ItemParts(int par1) + { + super(par1); + this.setItemName("Parts"); + this.setHasSubtypes(true); + this.setMaxDamage(0); + this.setMaxStackSize(64); + } + @Override + public int getIconFromDamage(int par1) + { + switch(par1) + { + case 0: return 3; + case 1: return 4; + case 2: return 5; + case 3: return 6; + case 4: return 7; + case 5: return 8; + case 6: return 9; + } + return this.iconIndex; + } + @Override + public String getTextureFile() { + // TODO Auto-generated method stub + return "/eui/Items.png"; + } + public String getItemName() + { + return "parts"; + } + + + + public String getItemNameIS(ItemStack par1ItemStack) + { + int var3 = par1ItemStack.getItemDamage(); + switch(var3) + { + case 1: return "Tank"; + case 3: return "Valve"; + case 4: return "Tube"; + case 5: return "Seal"; + case 6: return "Rivits"; + } + return this.getItemName(); + } + public void addCreativeItems(ArrayList itemList) + { + itemList.add(new ItemStack(this, 1,1)); + itemList.add(new ItemStack(this, 1,3)); + itemList.add(new ItemStack(this, 1,4)); + itemList.add(new ItemStack(this, 1,5)); + itemList.add(new ItemStack(this, 1,6)); + + } +} + + + diff --git a/1.3/common/EUI/SteamPower/SteamPower.java b/1.3/common/EUI/SteamPower/SteamPower.java new file mode 100644 index 00000000..ede15267 --- /dev/null +++ b/1.3/common/EUI/SteamPower/SteamPower.java @@ -0,0 +1,113 @@ +package EUI.SteamPower; +import net.minecraft.client.Minecraft; +import net.minecraft.src.Block; +import net.minecraft.src.ItemStack; +import net.minecraftforge.common.Configuration; + +import java.util.ArrayList; +import java.util.Map; +import java.io.*; + +import EUI.BasicPipes.BasicPipes; +import EUI.SteamPower.boiler.TileEntityBoiler; +import EUI.SteamPower.burner.TileEntityFireBox; +import EUI.SteamPower.turbine.TileEntityGenerator; + +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Mod.PostInit; +import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.Mod.Init; +import cpw.mods.fml.common.Mod.Instance; +import cpw.mods.fml.common.Mod.PreInit; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import cpw.mods.fml.common.network.NetworkMod; +import cpw.mods.fml.common.network.NetworkRegistry; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.common.registry.LanguageRegistry; + +import universalelectricity.UniversalElectricity; +import universalelectricity.basiccomponents.BasicComponents; +import universalelectricity.network.PacketManager; +@Mod(modid = "SteamPower", name = "Steam Power", version = "V4") +@NetworkMod(channels = { "SPpack" }, clientSideRequired = true, serverSideRequired = false, packetHandler = PacketManager.class) + +public class SteamPower{ + static Configuration config = new Configuration((new File(Minecraft.getMinecraftDir(), "config/EUIndustry/SteamPower.cfg"))); + private static int BlockID= configurationProperties(); + public static int genOutput; + public static int steamOutBoiler; + public static int pipeLoss; + public static int boilerHeat; + public static int fireOutput; + public static final String channel = "SPpack"; + public static Block machine = new EUI.SteamPower.BlockMachine(BlockID).setBlockName("machine"); + @Instance + public static SteamPower instance; + + @SidedProxy(clientSide = "EUIClient.SteamPower.SteamClientProxy", serverSide = "EUI.SteamPower.SteamProxy") + public static SteamProxy proxy; + public static String textureFile = "/EUIClient/Textures/"; + public static int configurationProperties() + { + config.load(); + BlockID = Integer.parseInt(config.getOrCreateIntProperty("MachinesID", Configuration.CATEGORY_BLOCK, 3030).value); + genOutput = Integer.parseInt(config.getOrCreateIntProperty("genOutputWattsmax", Configuration.CATEGORY_GENERAL, 1000).value); + steamOutBoiler = Integer.parseInt(config.getOrCreateIntProperty("steamOutPerCycle", Configuration.CATEGORY_GENERAL, 10).value); + boilerHeat = Integer.parseInt(config.getOrCreateIntProperty("boilerInKJNeed", Configuration.CATEGORY_GENERAL, 4500).value); + fireOutput = Integer.parseInt(config.getOrCreateIntProperty("fireBoxOutKJMax", Configuration.CATEGORY_GENERAL,250).value); + config.save(); + return BlockID; + } + @PreInit + public void preInit(FMLPreInitializationEvent event) + { + instance = this; + NetworkRegistry.instance().registerGuiHandler(this, this.proxy); + proxy.preInit(); + GameRegistry.registerBlock(machine, ItemMachine.class); + } + @Init + public void load(FMLInitializationEvent evt) + { + proxy.init(); + GameRegistry.registerTileEntity(TileEntityNuller.class, "EUNuller"); + //Names............... + LanguageRegistry.addName((new ItemStack(machine, 1, 1)), "Boiler"); + LanguageRegistry.addName((new ItemStack(machine, 1, 2)), "FireBox"); + LanguageRegistry.addName((new ItemStack(machine, 1, 3)), "SteamGen"); + LanguageRegistry.addName((new ItemStack(machine, 1, 15)), "EUVampire"); + + + } + @PostInit + public void postInit(FMLPostInitializationEvent event) + { + proxy.postInit(); + UniversalElectricity.registerMod(this,"SteamPower", "0.5.1"); + //Crafting + /** + * case 0: return new TileEntityGrinder(); <-Removed + case 1: return new TileEntityBoiler(); + case 2: return new TileEntityFireBox(); + case 3: return new TileEntityGenerator(); + case 14: return new TileEntityCondenser();<-Removed + case 15: return new TileEntityNuller();<-Just for testing Not craftable + */ + GameRegistry.addRecipe(new ItemStack(machine, 1, 1), new Object [] {"@T@", "OVO", "@T@", + 'T',new ItemStack(BasicPipes.parts, 1,5), + '@',new ItemStack(BasicComponents.itemSteelPlate), + 'O',new ItemStack(BasicPipes.parts, 1,1), + 'V',new ItemStack(BasicPipes.parts, 1,6)}); + GameRegistry.addRecipe(new ItemStack(machine, 1, 2), new Object [] { "@", "F", + 'F',Block.stoneOvenIdle, + '@',new ItemStack(BasicComponents.itemSteelPlate)}); + GameRegistry.addRecipe(new ItemStack(machine, 1, 3), new Object [] {"@T@", "PMP", "@T@", + 'T',new ItemStack(BasicPipes.parts, 1,0), + '@',new ItemStack(BasicComponents.itemSteelPlate), + 'P',Block.pistonBase, + 'M',new ItemStack(BasicComponents.itemMotor)}); + } + +} diff --git a/1.3/common/EUI/SteamPower/SteamProxy.java b/1.3/common/EUI/SteamPower/SteamProxy.java new file mode 100644 index 00000000..c82623ac --- /dev/null +++ b/1.3/common/EUI/SteamPower/SteamProxy.java @@ -0,0 +1,72 @@ +package EUI.SteamPower; + +import universalelectricity.basiccomponents.GUIBatteryBox; +import universalelectricity.basiccomponents.TileEntityBatteryBox; +import EUI.SteamPower.boiler.ContainerBoiler; +import EUI.SteamPower.boiler.TileEntityBoiler; +import EUI.SteamPower.burner.ContainerFireBox; +import EUI.SteamPower.burner.TileEntityFireBox; +import EUI.SteamPower.turbine.ContainerGenerator; +import EUI.SteamPower.turbine.TileEntityGenerator; +import EUIClient.SteamPower.GUIFireBox; +import EUIClient.SteamPower.GUIGenerator; +import EUIClient.SteamPower.GuiBoiler; +import cpw.mods.fml.common.network.IGuiHandler; +import cpw.mods.fml.common.registry.GameRegistry; +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.TileEntity; +import net.minecraft.src.World; + +public class SteamProxy implements IGuiHandler{ + + public void preInit() + { + + } + public void init() + { + GameRegistry.registerTileEntity(TileEntityBoiler.class, "boiler"); + GameRegistry.registerTileEntity(TileEntityFireBox.class, "fireBox"); + GameRegistry.registerTileEntity(TileEntityGenerator.class, "generator"); + + } + public void postInit() + { + + } + @Override + public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) + { + TileEntity tileEntity = world.getBlockTileEntity(x, y, z); + + if (tileEntity != null) + { + switch(ID) + { + case 0: return new GUIFireBox(player.inventory, ((TileEntityFireBox)tileEntity)); + case 1: return new GuiBoiler(player.inventory, ((TileEntityBoiler)tileEntity)); + case 2: return new GUIGenerator(player.inventory, ((TileEntityGenerator)tileEntity)); + } + } + + return null; + } + + @Override + public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) + { + TileEntity tileEntity = world.getBlockTileEntity(x, y, z); + + if (tileEntity != null) + { + switch(ID) + { + case 0: return new ContainerFireBox(player.inventory, ((TileEntityFireBox)tileEntity)); + case 1: return new ContainerBoiler(player.inventory, ((TileEntityBoiler)tileEntity)); + case 2: return new ContainerGenerator(player.inventory, ((TileEntityGenerator)tileEntity)); + } + } + + return null; + } +} diff --git a/1.3/common/EUI/SteamPower/TileEntityMachine.java b/1.3/common/EUI/SteamPower/TileEntityMachine.java new file mode 100644 index 00000000..a57975dd --- /dev/null +++ b/1.3/common/EUI/SteamPower/TileEntityMachine.java @@ -0,0 +1,136 @@ +package EUI.SteamPower; + +import com.google.common.io.ByteArrayDataInput; + +import universalelectricity.electricity.TileEntityElectricUnit; +import universalelectricity.extend.IRotatable; +import universalelectricity.network.IPacketReceiver; +import universalelectricity.network.PacketManager; +import net.minecraft.src.*; +import net.minecraftforge.common.ForgeDirection; +public class TileEntityMachine extends TileEntityElectricUnit +{ + public int facing = 0; + private int count = 0; + public TileEntity getSteamMachine(int i) + { + int x = this.xCoord; + int y = this.yCoord; + int z = this.zCoord; + + switch(i) + { + case 0: y = y - 1;break; + case 1: y = y + 1;break; + case 2: z = z + 1;break; + case 3: z = z - 1;break; + case 4: x = x + 1;break; + case 5: x = x - 1;break; + } + TileEntity aEntity = worldObj.getBlockTileEntity(x, y, z); + if(aEntity instanceof TileEntityMachine) + { + return aEntity; + } + + return null; + } + + public int getDirection() + { + return this.facing; + } + + public void setDirection(int i) + { + this.facing = i; + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) + { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setInteger("facing", this.facing); + } + + @Override + public void readFromNBT(NBTTagCompound par1NBTTagCompound) + { + super.readFromNBT(par1NBTTagCompound); + this.facing = par1NBTTagCompound.getInteger("facing"); + } + + @Override + public float electricityRequest() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public boolean canReceiveFromSide(ForgeDirection side) { + // TODO Auto-generated method stub + return false; + } + + + public int getSizeInventory() { + // TODO Auto-generated method stub + return 0; + } + + public ItemStack getStackInSlot(int var6) { + // TODO Auto-generated method stub + return null; + } + @Override + public boolean canUpdate() + { + return true; + } + public Object[] getSendData() + { + return new Object[]{}; + } + public int getNumSide(ForgeDirection side) + { + if(side == ForgeDirection.DOWN) + { + return 0; + } + if(side == ForgeDirection.UP) + { + return 1; + } + if(side == ForgeDirection.NORTH) + { + return 2; + } + if(side == ForgeDirection.SOUTH) + { + return 3; + } + if(side == ForgeDirection.WEST) + { + return 4; + } + if(side == ForgeDirection.EAST) + { + return 5; + } + return 0; + } + + public void onUpdate(float watts, float voltage, ForgeDirection side) + { + super.onUpdate(watts, voltage, side); + count++; + if(count >= 10) + { + if(!worldObj.isRemote) + { + PacketManager.sendTileEntityPacket(this, SteamPower.channel, getSendData()); + } + count = 0; + } + } +} \ No newline at end of file diff --git a/1.3/common/EUI/SteamPower/TileEntityNuller.java b/1.3/common/EUI/SteamPower/TileEntityNuller.java new file mode 100644 index 00000000..28ceb6c9 --- /dev/null +++ b/1.3/common/EUI/SteamPower/TileEntityNuller.java @@ -0,0 +1,29 @@ +package EUI.SteamPower; + +import net.minecraftforge.common.ForgeDirection; +import universalelectricity.extend.IElectricUnit; + +public class TileEntityNuller extends TileEntityMachine implements IElectricUnit { + + public float electricityRequest() + { + return 100; + } + @Override + public boolean canReceiveFromSide(ForgeDirection side) + { + return true; + } + public float getVoltage() + { + return 1000; + } + public int getTickInterval() + { + return 1; + } + public boolean canConnect(ForgeDirection side) + { + return true; + } +} diff --git a/1.3/common/EUI/SteamPower/api/IHeatConsumer.java b/1.3/common/EUI/SteamPower/api/IHeatConsumer.java new file mode 100644 index 00000000..6b5e1c28 --- /dev/null +++ b/1.3/common/EUI/SteamPower/api/IHeatConsumer.java @@ -0,0 +1,22 @@ +package EUI.SteamPower.api; + +/** + * The IHeatConsumer interface is an interface that must be applied to all tile entities that can receive heat joules. + * @author Darkguardsman code sourced from Calclavia + * + */ +public interface IHeatConsumer +{ + /** + * onRecieveSteam is called whenever a Steam transmitter sends a packet of electricity to the consumer (which is this block). + * @param vol - The amount of steam this block received + * @param side - The side of the block in which the electricity came from. + * @return vol - The amount of rejected steam to be sent to back + */ + public float onReceiveHeat(float jouls, int side); + + /** + * @return Return the stored electricity in this consumer. Called by conductors to spread electricity to this unit. + */ + public float getStoredHeat(); +} \ No newline at end of file diff --git a/1.3/common/EUI/SteamPower/api/IHeatProducer.java b/1.3/common/EUI/SteamPower/api/IHeatProducer.java new file mode 100644 index 00000000..1c8e33db --- /dev/null +++ b/1.3/common/EUI/SteamPower/api/IHeatProducer.java @@ -0,0 +1,14 @@ +package EUI.SteamPower.api; + + +public interface IHeatProducer +{ + /** + * onProduceElectricity is called when a conductor is connected to the producer block in which the conductor will demand power from the producer + * block. + * @param jouls - The maximum jouls can be transfered + * @param side - The side of block in which the conductor is on + * @return jouls - Return jouls to consumer + */ + public float onProduceHeat(float jouls, int side); +} \ No newline at end of file diff --git a/1.3/common/EUI/SteamPower/boiler/ContainerBoiler.java b/1.3/common/EUI/SteamPower/boiler/ContainerBoiler.java new file mode 100644 index 00000000..af6599f5 --- /dev/null +++ b/1.3/common/EUI/SteamPower/boiler/ContainerBoiler.java @@ -0,0 +1,59 @@ +package EUI.SteamPower.boiler; +import net.minecraft.src.*; + +public class ContainerBoiler extends Container +{ + private TileEntityBoiler boiler; + private int lastCookTime = 0; + private int lastBurnTime = 0; + private int lastItemBurnTime = 0; + + public ContainerBoiler(InventoryPlayer par1InventoryPlayer, TileEntityBoiler par2TileEntityboiler) + { + this.boiler = par2TileEntityboiler; + this.addSlotToContainer(new Slot(par2TileEntityboiler, 0, 56, 17)); + int var3; + + for (var3 = 0; var3 < 3; ++var3) + { + for (int var4 = 0; var4 < 9; ++var4) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + } + + + + public void updateProgressBar(int par1, int par2) + { + if (par1 == 0) + { + // this.boiler.furnaceCookTime = par2; + } + + if (par1 == 1) + { + //this.boiler.boilerRunTime = par2; + } + + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) + { + return this.boiler.isUseableByPlayer(par1EntityPlayer); + } + + /** + * Called to transfer a stack from one inventory to the other eg. when shift clicking. + */ + public ItemStack transferStackInSlot(int par1) + { + return null; + } +} diff --git a/1.3/common/EUI/SteamPower/boiler/TileEntityBoiler.java b/1.3/common/EUI/SteamPower/boiler/TileEntityBoiler.java new file mode 100644 index 00000000..46ad17aa --- /dev/null +++ b/1.3/common/EUI/SteamPower/boiler/TileEntityBoiler.java @@ -0,0 +1,540 @@ +package EUI.SteamPower.boiler; +import com.google.common.io.ByteArrayDataInput; + +import universalelectricity.network.IPacketReceiver; +import EUI.BasicPipes.pipes.api.ILiquidConsumer; +import EUI.BasicPipes.pipes.api.ILiquidProducer; +import EUI.SteamPower.SteamPower; +import EUI.SteamPower.TileEntityMachine; +import EUI.SteamPower.burner.TileEntityFireBox; +import net.minecraft.src.*; +import net.minecraftforge.common.ForgeDirection; +import net.minecraftforge.common.ISidedInventory; + +public class TileEntityBoiler extends TileEntityMachine implements IPacketReceiver, IInventory, ISidedInventory,ILiquidProducer, ILiquidConsumer +{ + + /** + * The ItemStacks that hold the items currently being used in the furnace + */ + private ItemStack[] furnaceItemStacks = new ItemStack[1]; + + /** The number of ticks that the boiler will keep burning */ + public int RunTime = 0; + /** The ammount of energy stored before being add to run Timer */ + public int energyStore = 0; + /** The ammount of water stored */ + public int waterStored = 0; + /** The ammount of steam stored */ + public int steamStored = 0; + /** The ammount of heat stored */ + public int heatStored = 0; + public int heatMax = 10000; + /** The ammount of heat stored */ + public int hullHeat = 0; + public int hullHeatMax = 10000; + private int heatTick = 0; + int count = 0; + boolean hullHeated = false; + TileEntity[] connectedBlocks = {null, null, null, null, null, null}; + int steamMax = 140; + public boolean isBeingHeated = false; + /** + * Returns the number of slots in the inventory. + */ + public int getSizeInventory() + { + return this.furnaceItemStacks.length; + } + + /** + * Returns the stack in slot i + */ + public ItemStack getStackInSlot(int par1) + { + return this.furnaceItemStacks[par1]; + } + + public ItemStack decrStackSize(int par1, int par2) + { + if (this.furnaceItemStacks[par1] != null) + { + ItemStack var3; + + if (this.furnaceItemStacks[par1].stackSize <= par2) + { + var3 = this.furnaceItemStacks[par1]; + this.furnaceItemStacks[par1] = null; + return var3; + } + else + { + var3 = this.furnaceItemStacks[par1].splitStack(par2); + + if (this.furnaceItemStacks[par1].stackSize == 0) + { + this.furnaceItemStacks[par1] = null; + } + + return var3; + } + } + else + { + return null; + } + } + + /** + * When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem - + * like when you close a workbench GUI. + */ + public ItemStack getStackInSlotOnClosing(int par1) + { + if (this.furnaceItemStacks[par1] != null) + { + ItemStack var2 = this.furnaceItemStacks[par1]; + this.furnaceItemStacks[par1] = null; + return var2; + } + else + { + return null; + } + } + + /** + * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections). + */ + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) + { + this.furnaceItemStacks[par1] = par2ItemStack; + + if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) + { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + } + + /** + * Returns the name of the inventory. + */ + public String getInvName() + { + return "container.boiler"; + } + + /** + * Reads a tile entity from NBT. + */ + public void readFromNBT(NBTTagCompound par1NBTTagCompound) + { + super.readFromNBT(par1NBTTagCompound); + NBTTagList var2 = par1NBTTagCompound.getTagList("Items"); + this.furnaceItemStacks = new ItemStack[this.getSizeInventory()]; + + for (int var3 = 0; var3 < var2.tagCount(); ++var3) + { + NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3); + byte var5 = var4.getByte("Slot"); + + if (var5 >= 0 && var5 < this.furnaceItemStacks.length) + { + this.furnaceItemStacks[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + + this.RunTime = par1NBTTagCompound.getShort("BurnTime"); + this.energyStore = par1NBTTagCompound.getInteger("energyStore"); + this.steamStored = par1NBTTagCompound.getInteger("steamStore"); + this.heatStored = par1NBTTagCompound.getInteger("heatStore"); + this.waterStored = par1NBTTagCompound.getInteger("waterStore"); + this.hullHeat = par1NBTTagCompound.getInteger("hullHeat"); + } + + /** + * Writes a tile entity to NBT. + */ + public void writeToNBT(NBTTagCompound par1NBTTagCompound) + { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setShort("BurnTime", (short)this.RunTime); + par1NBTTagCompound.setInteger("energyStore", (int)this.energyStore); + par1NBTTagCompound.setInteger("steamStore", (int)this.steamStored); + par1NBTTagCompound.setInteger("heatStore", (int)this.heatStored); + par1NBTTagCompound.setInteger("waterStore", (int)this.waterStored); + par1NBTTagCompound.setInteger("hullHeat", (int)this.hullHeat); + NBTTagList var2 = new NBTTagList(); + + for (int var3 = 0; var3 < this.furnaceItemStacks.length; ++var3) + { + if (this.furnaceItemStacks[var3] != null) + { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte)var3); + this.furnaceItemStacks[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + + par1NBTTagCompound.setTag("Items", var2); + } + + /** + * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't + * this more of a set than a get?* + */ + public int getInventoryStackLimit() + { + return 64; + } + + /** + * Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count + * ticks and creates a new spawn inside its implementation. + */ + private boolean getIsHeated() { + TileEntity blockEntity = worldObj.getBlockTileEntity(this.xCoord, this.yCoord - 1, this.zCoord); + if(blockEntity instanceof TileEntityFireBox) + { + return true; + } + else + { + return false; + } + } + @Override + public void updateEntity(){ + count++; + if(count >= 20){ + isBeingHeated = getIsHeated(); + addWater();//adds water from container slot + shareWater(); + count = 0; + } + + //changed hullHeat max depending on contents of boiler + if(waterStored > 0) + { + hullHeatMax = 4700; + if(hullHeat > hullHeatMax) + { + hullHeat = 4700; + } + } + else + { + hullHeatMax = 10000; + } + //Checks if the hull is heated + if(hullHeat >= hullHeatMax) + { + hullHeated = true; + } + else + { + hullHeat = Math.min(hullHeat + heatStored, hullHeatMax); + } + //checks if heat level hit max + if(hullHeat >= 10000) + { + if(heatTick >= 1200) + { + // TODO remove block and set fire + heatTick = 0; + } + else + { + heatTick += 1; + } + } + + + int heatNeeded = SteamPower.boilerHeat; // kilo joules + //if hull heated do work + if(hullHeated) + { + if(heatStored > SteamPower.fireOutput) + { + if(waterStored >= 1){ + if(heatStored >= heatNeeded) + { + heatStored = Math.max(heatStored - heatNeeded, 0); + --waterStored; + steamStored = Math.min(steamStored + SteamPower.steamOutBoiler,this.steamMax); + } + } + else + { + heatStored = 0; + } + } + } + TileEntity blockE = worldObj.getBlockTileEntity(xCoord, yCoord -1, zCoord); + if(blockE instanceof TileEntityFireBox) + { + if(!hullHeated || waterStored > 0) + { + heatStored = (int) Math.min((heatStored + ((TileEntityFireBox)blockE).onProduceHeat(SteamPower.fireOutput, 1)), heatMax); + } + } + + } + public void shareWater() + { + int wSum = getStoredLiquid(1); //pre-sets the sum to the first tanks current volume + int tankCount = 1; //amount of tanks around this tank, used to get avarage liquid ammount + boolean bottom = false; // whether or not this tanks need to worry about what is bellow it + TileEntity entityBellow = worldObj.getBlockTileEntity(this.xCoord,this.yCoord-1, this.zCoord); + TileEntity entityAbove = worldObj.getBlockTileEntity(this.xCoord,this.yCoord+1, this.zCoord); + //checks wether or not the block bellow it is a tank to move liquid too + if(entityBellow instanceof TileEntityBoiler) + { + int bWater = ((TileEntityBoiler) entityBellow).getStoredLiquid(1); + int bMax = ((TileEntityBoiler) entityBellow).getLiquidCapacity(1); + //checks if that tank has room to get liquid. + + if(bWater < bMax) + { + int emptyVol = Math.max( bMax - bWater,0); + int tradeVol = Math.min(emptyVol, waterStored); + int rejected = ((TileEntityBoiler) entityBellow).onReceiveLiquid(1, tradeVol, ForgeDirection.getOrientation(1)); + waterStored = Math.max(waterStored - rejected,0); + wSum -= rejected; + } + else + { + bottom = true; + } + } + else + { + //there was no tank bellow this tank + bottom = true; + } + //if this is the bottom tank or bottom tank is full then trade liquid with tanks around it. + if(bottom) + { + //get average water around center tank + for(int i = 0; i<4;i++) + { + int x = this.xCoord; + int z = this.zCoord; + //switch to check each side TODO rewrite for side values + switch(i) + { + case 0: --x; + case 1: ++x; + case 2: --z; + case 3: ++z; + } + TileEntity entity = worldObj.getBlockTileEntity(x,this.yCoord, z); + if(entity instanceof TileEntityBoiler) + { + //if is a tank add to the sum + wSum += ((TileEntityBoiler) entity).getStoredLiquid(1); + tankCount += 1; + } + } + } + //transfers water + for(int i = 0; i<4;i++) + { + int average = wSum / tankCount;// takes the sum and makes it an average + int x2 = this.xCoord; + int z2 = this.zCoord; + int tradeSum = 0; + //switch to check each side TODO rewrite for side values + switch(i) + { + case 0: --x2; + case 1: ++x2; + case 2: --z2; + case 3: ++z2; + } + TileEntity entity = worldObj.getBlockTileEntity(x2,this.yCoord, z2); + if(entity instanceof TileEntityBoiler) + { + int targetW = ((TileEntityBoiler) entity).getStoredLiquid(1); + if(targetW < average) + { + tradeSum = Math.min(average, waterStored); //gets the ammount to give to the target tank + int rejectedAm = ((TileEntityBoiler) entity).onReceiveLiquid(1, tradeSum, ForgeDirection.getOrientation(i)); //send that ammount with safty incase some comes back + waterStored =rejectedAm + waterStored - tradeSum; //counts up current water sum after trade + } + } + } + if(entityAbove instanceof TileEntityBoiler) + { + int bWater = ((TileEntityBoiler) entityAbove).getStoredLiquid(1); + int bMax = ((TileEntityBoiler) entityAbove).getLiquidCapacity(1); + if(bottom && waterStored > 0) + { + if(bWater < bMax) + { + int emptyVolS = Math.max( bMax - bWater,0); + int tradeVolS = Math.min(emptyVolS, steamStored); + int rejectedS = ((TileEntityBoiler) entityAbove).addSteam(tradeVolS); + waterStored = Math.max(waterStored - rejectedS,0); + wSum -= rejectedS; + } + } + } + + + + + + } + public int addSteam(int watt) { + int rejectedElectricity = Math.max((this.steamStored + watt) - steamMax, 0); + this.steamStored += watt - rejectedElectricity; + return rejectedElectricity; + } + private void addWater() { + if (this.furnaceItemStacks[0] != null) + { + if(this.furnaceItemStacks[0].isItemEqual(new ItemStack(Item.bucketWater,1))) + { + if((int)waterStored < getLiquidCapacity(1)) + { + ++waterStored; + this.furnaceItemStacks[0] = new ItemStack(Item.bucketEmpty,1); + this.onInventoryChanged(); + } + } + } + + } + + /** + * Do not make give this method the name canInteractWith because it clashes with Container + */ + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) + { + return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + + public void openChest() {} + + public void closeChest() {} + + public int precentHeated() { + int var1; + if(hullHeat < 100) + { + var1 = (int)(100 *(hullHeat/100)); + } + else + { + var1 = 100; + } + return var1; + } + @Override + public int onReceiveLiquid(int type, int vol, ForgeDirection side) { + if(type == 1) + { + int rejectedElectricity = Math.max((this.waterStored + vol) - this.getLiquidCapacity(1), 0); + this.waterStored += vol - rejectedElectricity; + return rejectedElectricity; + } + return vol; + } + + @Override + public boolean canRecieveLiquid(int type,ForgeDirection side) { + if(type == 1) + { + return true; + } + return false; + } + + @Override + public int getStoredLiquid(int type) { + if(type == 1) + { + return this.waterStored; + } + if(type == 0) + { + return this.steamStored; + } + return 0; + } + + @Override + public int getLiquidCapacity(int type) { + if(type ==1) + { + return 14; + } + if(type == 0) + { + return steamMax; + } + return 0; + } + @Override + public int onProduceLiquid(int type, int maxVol, ForgeDirection side) { + if(type == 0) + { + if(steamStored > 1) + { + this.steamStored -= 1; + return 1; + } + } + return 0; + } + + @Override + public boolean canProduceLiquid(int type, ForgeDirection side) { + if(type == 0) + { + return true; + } + return false; + } + + @Override + public int getStartInventorySide(ForgeDirection side) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public int getSizeInventorySide(ForgeDirection side) { + // TODO Auto-generated method stub + return 0; + } + public Object[] getSendData() + { + return new Object[]{(int)facing,(int)RunTime,(int)energyStore,(int)waterStored, + (int)steamStored,(int)heatStored,(int)hullHeat,(int)heatTick}; + } + + @Override + public void handlePacketData(NetworkManager network, + Packet250CustomPayload packet, EntityPlayer player, + ByteArrayDataInput dataStream) { + try{ + facing = dataStream.readInt(); + RunTime = dataStream.readInt(); + energyStore = dataStream.readInt(); + waterStored = dataStream.readInt(); + steamStored = dataStream.readInt(); + heatStored = dataStream.readInt(); + hullHeat = dataStream.readInt(); + heatTick = dataStream.readInt(); + } + catch(Exception e) + { + e.printStackTrace(); + } + + } + + } diff --git a/1.3/common/EUI/SteamPower/burner/ContainerFireBox.java b/1.3/common/EUI/SteamPower/burner/ContainerFireBox.java new file mode 100644 index 00000000..20918815 --- /dev/null +++ b/1.3/common/EUI/SteamPower/burner/ContainerFireBox.java @@ -0,0 +1,42 @@ +package EUI.SteamPower.burner; + +import net.minecraft.src.*; + +public class ContainerFireBox extends Container +{ + private TileEntityFireBox tileEntity; + + public ContainerFireBox(InventoryPlayer par1InventoryPlayer, TileEntityFireBox tileEntity) + { + this.tileEntity = tileEntity; + this.addSlotToContainer(new Slot(tileEntity, 0, 33, 34)); + int var3; + + for (var3 = 0; var3 < 3; ++var3) + { + for (int var4 = 0; var4 < 9; ++var4) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) + { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + /** + * Called to transfer a stack from one inventory to the other eg. when shift clicking. + */ + public ItemStack transferStackInSlot(int par1) + { + + return null; + } +} diff --git a/1.3/common/EUI/SteamPower/burner/TileEntityFireBox.java b/1.3/common/EUI/SteamPower/burner/TileEntityFireBox.java new file mode 100644 index 00000000..c07c5fd2 --- /dev/null +++ b/1.3/common/EUI/SteamPower/burner/TileEntityFireBox.java @@ -0,0 +1,301 @@ +package EUI.SteamPower.burner; + +import com.google.common.io.ByteArrayDataInput; + +import universalelectricity.network.IPacketReceiver; +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.IInventory; +import net.minecraft.src.Item; +import net.minecraft.src.ItemStack; +import net.minecraft.src.NBTTagCompound; +import net.minecraft.src.NBTTagList; +import net.minecraft.src.NetworkManager; +import net.minecraft.src.Packet250CustomPayload; +import net.minecraft.src.TileEntity; +import net.minecraftforge.common.ForgeDirection; +import net.minecraftforge.common.ISidedInventory; +import EUI.SteamPower.SteamPower; +import EUI.SteamPower.TileEntityMachine; +import EUI.SteamPower.api.IHeatProducer; +import EUI.SteamPower.boiler.*; + +public class TileEntityFireBox extends TileEntityMachine implements IPacketReceiver,IInventory, ISidedInventory, IHeatProducer +{ + //max heat generated per second + + public boolean isConnected = false; + public TileEntity[] connectedBlocks = {null, null, null, null, null, null}; + private int connectedUnits = 0; + public static int maxGenerateRate = 250; + //Current generation rate based on hull heat. In TICKS. + public int generateRate = 0; + int count = 0; + public int itemCookTime = 0; + public ItemStack[] containingItems = new ItemStack[1]; + public void updateEntity() + {if (!this.worldObj.isRemote){ + + if(count == 20) + { + addConnection(); + sharCoal(); + + count = 0; + } + count++; + maxGenerateRate = SteamPower.fireOutput + (connectedUnits*5); + TileEntity blockEntity = worldObj.getBlockTileEntity(this.xCoord, this.yCoord + 1, this.zCoord); + if(blockEntity instanceof TileEntityBoiler) + { + isConnected = true; + } + else + { + isConnected = false; + } + //The top slot is for recharging items. Check if the item is a electric item. If so, recharge it. + if (this.containingItems[0] != null && isConnected) + { + if (this.containingItems[0].getItem().shiftedIndex == Item.coal.shiftedIndex) + { + if(this.itemCookTime <= 0) + { + itemCookTime = Math.max(1600 - (int)(this.generateRate*20), 400); + this.decrStackSize(0, 1); + } + } + } + + } + //Starts generating electricity if the device is heated up + if (this.itemCookTime > 0) + { + this.itemCookTime --; + if(isConnected) + { + this.generateRate = Math.min(this.generateRate+Math.min((this.generateRate)+1, 1), this.maxGenerateRate/20); + } + } + //Loose heat when the generator is not connected or if there is no coal in the inventory. + if(this.itemCookTime <= 0 || !isConnected) + { + this.generateRate = Math.max(this.generateRate-5, 0); + } + } + + //gets all connected fireBoxes and shares its supply of coal + public void sharCoal(){ + for(int i =0; i<6;i++) + { + + if(connectedBlocks[i] instanceof TileEntityFireBox) + { + TileEntityFireBox connectedConsumer = (TileEntityFireBox) connectedBlocks[i]; + if(this.containingItems[0] != null) + { + if(this.containingItems[0].getItem().shiftedIndex == Item.coal.shiftedIndex && this.containingItems[0].stackSize > 0) + { + if(connectedConsumer.containingItems[0] != null) + { + if(connectedConsumer.containingItems[0].getItem().shiftedIndex == Item.coal.shiftedIndex) + { + if(connectedConsumer.containingItems[0].getItem().shiftedIndex == Item.coal.shiftedIndex) + { + int CSum = Math.round(this.containingItems[0].stackSize + connectedConsumer.containingItems[0].stackSize)/2; + if(this.containingItems[0].stackSize > connectedConsumer.containingItems[0].stackSize) + { + int transferC = 0; + transferC = Math.round(CSum - connectedConsumer.containingItems[0].stackSize); + connectedConsumer.containingItems[0].stackSize = connectedConsumer.containingItems[0].stackSize + transferC; + this.containingItems[0].stackSize = this.containingItems[0].stackSize - transferC; + } + } + } + } + else + { + connectedConsumer.containingItems[0] = new ItemStack(this.containingItems[0].getItem()); + this.containingItems[0].stackSize -= 1; + } + } + } + } + } + + + } + public void addConnection() + { + connectedUnits = 0; + for(int i = 0; i<6; i++) + { + + TileEntity aEntity = getSteamMachine(i); + if(aEntity instanceof TileEntityFireBox && i != 0 && i != 1) + { + this.connectedBlocks[i] = aEntity; + connectedUnits += 1; + } + else + { + this.connectedBlocks[i] = null; + } + } + } + /** + * Reads a tile entity from NBT. + */ + public void readFromNBT(NBTTagCompound par1NBTTagCompound) + { + super.readFromNBT(par1NBTTagCompound); + this.itemCookTime = par1NBTTagCompound.getInteger("itemCookTime"); + this.generateRate = par1NBTTagCompound.getInteger("generateRate"); + NBTTagList var2 = par1NBTTagCompound.getTagList("Items"); + this.containingItems = new ItemStack[this.getSizeInventory()]; + for (int var3 = 0; var3 < var2.tagCount(); ++var3) + { + NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3); + byte var5 = var4.getByte("Slot"); + if (var5 >= 0 && var5 < this.containingItems.length) + { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + } + /** + * Writes a tile entity to NBT. + */ + public void writeToNBT(NBTTagCompound par1NBTTagCompound) + { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setInteger("itemCookTime", (int)this.itemCookTime); + par1NBTTagCompound.setInteger("generateRate", (int)this.generateRate); + NBTTagList var2 = new NBTTagList(); + for (int var3 = 0; var3 < this.containingItems.length; ++var3) + { + if (this.containingItems[var3] != null) + { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte)var3); + this.containingItems[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + par1NBTTagCompound.setTag("Items", var2); + } + @Override + public int getStartInventorySide(ForgeDirection side) + { + if (side == ForgeDirection.DOWN) + { + return 1; + } + if (side == ForgeDirection.UP) + { + return 0; + } + return 2; + } + @Override + public int getSizeInventorySide(ForgeDirection side) { return getSizeInventory(); } + @Override + public int getSizeInventory() { return this.containingItems.length; } + @Override + public ItemStack getStackInSlot(int par1) { return this.containingItems[par1]; } + @Override + public ItemStack decrStackSize(int par1, int par2) + { + if (this.containingItems[par1] != null) + { + ItemStack var3; + if (this.containingItems[par1].stackSize <= par2) + { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } + else + { + var3 = this.containingItems[par1].splitStack(par2); + if (this.containingItems[par1].stackSize == 0) + { + this.containingItems[par1] = null; + } + return var3; + } + } + else + { + return null; + } + } + @Override + public ItemStack getStackInSlotOnClosing(int par1) + { + if (this.containingItems[par1] != null) + { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } + else + { + return null; + } + } + @Override + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) + { + this.containingItems[par1] = par2ItemStack; + if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) + { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + } + @Override + public String getInvName() { + return "FireBox"; + } + @Override + public int getInventoryStackLimit() + { + return 64; + } + @Override + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) + { + return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + @Override + public void openChest() { } + @Override + public void closeChest() { } + @Override + public float onProduceHeat(float jouls, int side) { + // TODO Auto-generated method stub + return Math.min(generateRate,jouls); + } + @Override + public Object[] getSendData() + { + return new Object[]{(int)facing,(int)connectedUnits,(int)generateRate,(int)itemCookTime}; + } + + @Override + public void handlePacketData(NetworkManager network, + Packet250CustomPayload packet, EntityPlayer player, + ByteArrayDataInput dataStream) { + try + { + facing = dataStream.readInt(); + connectedUnits = dataStream.readInt(); + generateRate = dataStream.readInt(); + itemCookTime = dataStream.readInt(); + } + catch(Exception e) + { + e.printStackTrace(); + } + + } +} diff --git a/1.3/common/EUI/SteamPower/turbine/ContainerGenerator.java b/1.3/common/EUI/SteamPower/turbine/ContainerGenerator.java new file mode 100644 index 00000000..293b2424 --- /dev/null +++ b/1.3/common/EUI/SteamPower/turbine/ContainerGenerator.java @@ -0,0 +1,41 @@ +package EUI.SteamPower.turbine; + +import net.minecraft.src.*; + +public class ContainerGenerator extends Container +{ + private TileEntityGenerator tileEntity; + + public ContainerGenerator(InventoryPlayer par1InventoryPlayer, TileEntityGenerator tileEntity) + { + this.tileEntity = tileEntity; + this.addSlotToContainer(new Slot(tileEntity, 0, 33, 34)); + int var3; + + for (var3 = 0; var3 < 3; ++var3) + { + for (int var4 = 0; var4 < 9; ++var4) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) + { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) + { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + /** + * Called to transfer a stack from one inventory to the other eg. when shift clicking. + */ + public ItemStack transferStackInSlot(int par1) + { + return null; + } +} diff --git a/1.3/common/EUI/SteamPower/turbine/TileEntityGenerator.java b/1.3/common/EUI/SteamPower/turbine/TileEntityGenerator.java new file mode 100644 index 00000000..50c05594 --- /dev/null +++ b/1.3/common/EUI/SteamPower/turbine/TileEntityGenerator.java @@ -0,0 +1,359 @@ +package EUI.SteamPower.turbine; + +import com.google.common.io.ByteArrayDataInput; + +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.IInventory; +import net.minecraft.src.Item; +import net.minecraft.src.ItemStack; +import net.minecraft.src.NBTTagCompound; +import net.minecraft.src.NBTTagList; +import net.minecraft.src.NetworkManager; +import net.minecraft.src.Packet250CustomPayload; +import net.minecraft.src.TileEntity; +import net.minecraftforge.common.ForgeDirection; +import net.minecraftforge.common.ISidedInventory; +import universalelectricity.UniversalElectricity; +import universalelectricity.Vector3; +import universalelectricity.electricity.ElectricityManager; +import universalelectricity.extend.IElectricUnit; +import universalelectricity.extend.TileEntityConductor; +import universalelectricity.network.IPacketReceiver; +import EUI.BasicPipes.pipes.api.ILiquidConsumer; +import EUI.BasicPipes.pipes.api.ILiquidProducer; +import EUI.SteamPower.SteamPower; +import EUI.SteamPower.TileEntityMachine; + +public class TileEntityGenerator extends TileEntityMachine implements IPacketReceiver, IElectricUnit,ILiquidConsumer,ILiquidProducer, IInventory, ISidedInventory +{ + //Maximum possible generation rate of watts in SECONDS + public int maxGenerateRate = 1000; + public int waterStored = 0; + public int steamStored = 0; + public int steamConsumed = 0; + //Current generation rate based on hull heat. In TICKS. + public float generateRate = 0; + //public TileEntityConductor connectedWire = null; + /** + * The number of ticks that a fresh copy of the currently-burning item would keep the furnace burning for + */ + public int itemCookTime = 0; + /** + * The ItemStacks that hold the items currently being used in the battery box + */ + private ItemStack[] containingItems = new ItemStack[1]; + public TileEntityConductor connectedElectricUnit = null; + @Override + public boolean canConnect(ForgeDirection side) + { + return true; + } + + /** + * Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count + * ticks and creates a new spawn inside its implementation. + */ + public void onUpdate(float watts, float voltage, ForgeDirection side) + { if(!this.worldObj.isRemote) + { + super.onUpdate(watts, voltage, side); + + //Check nearby blocks and see if the conductor is full. If so, then it is connected + TileEntity tileEntity = Vector3.getUEUnitFromSide(this.worldObj, new Vector3(this.xCoord, this.yCoord, this.zCoord), ForgeDirection.getOrientation(this.getBlockMetadata()).getOpposite()); + + + if(tileEntity instanceof TileEntityConductor) + { + if(ElectricityManager.electricityRequired(((TileEntityConductor)tileEntity).connectionID) > 0) + { + this.connectedElectricUnit = (TileEntityConductor)tileEntity; + } + else + { + this.connectedElectricUnit = null; + } + } + else + { + this.connectedElectricUnit = null; + } + + + if(!this.isDisabled()) + { + //Adds time to runTime by consuming steam + if(this.itemCookTime <= 0) + { + if(steamStored > 0) + { + --steamStored; + ++steamConsumed; + if(steamConsumed == SteamPower.steamOutBoiler) + { + ++waterStored; + steamConsumed = 0; + } + itemCookTime += 65; + } + } + + //Empties water from tank to buckets + if (this.containingItems[0] != null) + { + if(this.containingItems[0].getItem().shiftedIndex == Item.bucketEmpty.shiftedIndex) + { + if(this.waterStored > 0) + { + this.containingItems[0] = new ItemStack(Item.bucketWater,1); + --waterStored; + } + } + } + + //Starts generating electricity if the device is heated up + if (this.itemCookTime > 0) + { + this.itemCookTime --; + + if(this.connectedElectricUnit != null) + { + this.generateRate = (float)Math.min(this.generateRate+Math.min((this.generateRate)*0.001+0.0015, 0.05F), this.maxGenerateRate/20); + } + } + + if(this.connectedElectricUnit == null || this.itemCookTime <= 0) + { + this.generateRate = (float)Math.max(this.generateRate-0.05, 0); + } + + if(this.generateRate > 1) + { + ElectricityManager.produceElectricity(this.connectedElectricUnit, this.generateRate*this.getTickInterval(), this.getVoltage()); + } + } + } + } + /** + * Reads a tile entity from NBT. + */ + public void readFromNBT(NBTTagCompound par1NBTTagCompound) + { + super.readFromNBT(par1NBTTagCompound); + this.itemCookTime = par1NBTTagCompound.getInteger("itemCookTime"); + this.waterStored = par1NBTTagCompound.getInteger("waterStored"); + this.steamConsumed = par1NBTTagCompound.getInteger("steamConsumed"); + this.steamStored = par1NBTTagCompound.getInteger("steamStored"); + this.generateRate = par1NBTTagCompound.getFloat("generateRate"); + NBTTagList var2 = par1NBTTagCompound.getTagList("Items"); + this.containingItems = new ItemStack[this.getSizeInventory()]; + for (int var3 = 0; var3 < var2.tagCount(); ++var3) + { + NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3); + byte var5 = var4.getByte("Slot"); + if (var5 >= 0 && var5 < this.containingItems.length) + { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + } + /** + * Writes a tile entity to NBT. + */ + public void writeToNBT(NBTTagCompound par1NBTTagCompound) + { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setInteger("itemCookTime", (int)this.itemCookTime); + par1NBTTagCompound.setInteger("waterStored", (int)this.waterStored); + par1NBTTagCompound.setInteger("steamConsumed", (int)this.steamConsumed); + par1NBTTagCompound.setInteger("steamStored", (int)this.steamStored); + par1NBTTagCompound.setFloat("generateRate", (int)this.generateRate); + NBTTagList var2 = new NBTTagList(); + for (int var3 = 0; var3 < this.containingItems.length; ++var3) + { + if (this.containingItems[var3] != null) + { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte)var3); + this.containingItems[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + par1NBTTagCompound.setTag("Items", var2); + } + @Override + public int getStartInventorySide(ForgeDirection side) + { + return 0; + } + @Override + public int getSizeInventorySide(ForgeDirection side) { return 0; } + @Override + public int getSizeInventory() { return this.containingItems.length; } + @Override + public ItemStack getStackInSlot(int par1) { return this.containingItems[par1]; } + @Override + public ItemStack decrStackSize(int par1, int par2) + { + if (this.containingItems[par1] != null) + { + ItemStack var3; + if (this.containingItems[par1].stackSize <= par2) + { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } + else + { + var3 = this.containingItems[par1].splitStack(par2); + if (this.containingItems[par1].stackSize == 0) + { + this.containingItems[par1] = null; + } + return var3; + } + } + else + { + return null; + } + } + @Override + public ItemStack getStackInSlotOnClosing(int par1) + { + if (this.containingItems[par1] != null) + { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } + else + { + return null; + } + } + @Override + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) + { + this.containingItems[par1] = par2ItemStack; + if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) + { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + } + @Override + public String getInvName() { + return "SteamGen"; + } + @Override + public int getInventoryStackLimit() + { + return 64; + } + @Override + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) + { + return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + @Override + public void openChest() { } + @Override + public void closeChest() { } + + @Override + public void onDisable(int duration) { + // TODO Auto-generated method stub + + } + + @Override + public boolean isDisabled() { + // TODO Auto-generated method stub + return false; + } + + @Override + public int onProduceLiquid(int type, int maxVol, ForgeDirection side) { + if(type == 1) + { + if(this.waterStored > 0) + { + --waterStored; + return 1; + } + } + return 0; + } + + @Override + public boolean canProduceLiquid(int type, ForgeDirection side) { + if(type == 1) + { + return true; + } + return false; + } + + @Override + public int onReceiveLiquid(int type, int vol, ForgeDirection side) { + if(type == 0) + { + int rejectedSteam = Math.max((this.steamStored + vol) - 100, 0); + this.steamStored += vol - rejectedSteam; + return rejectedSteam; + } + return vol; + } + + @Override + public boolean canRecieveLiquid(int type, ForgeDirection side) { + if(type == 0) + { + return true; + } + return false; + } + + @Override + public int getStoredLiquid(int type) { + if(type == 0) + { + return this.steamStored; + } + return 0; + } + + @Override + public int getLiquidCapacity(int type) { + if(type == 0) + { + return 100; + } + return 0; + } + @Override + public Object[] getSendData() + { + return new Object[]{(int)facing,(int)waterStored,(int)steamStored,(int)steamConsumed,(int)generateRate,(int)itemCookTime}; + } + + @Override + public void handlePacketData(NetworkManager network, + Packet250CustomPayload packet, EntityPlayer player, + ByteArrayDataInput dataStream) { + try + { + facing = dataStream.readInt(); + waterStored = dataStream.readInt(); + steamStored = dataStream.readInt(); + steamConsumed = dataStream.readInt(); + generateRate = dataStream.readInt(); + itemCookTime = dataStream.readInt(); + } + catch(Exception e) + { + e.printStackTrace(); + } + + } +} diff --git a/1.3/minecraft/EUIClient/SteamPower/GUIFireBox.java b/1.3/minecraft/EUIClient/SteamPower/GUIFireBox.java new file mode 100644 index 00000000..816f7383 --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/GUIFireBox.java @@ -0,0 +1,91 @@ +package EUIClient.SteamPower; + +import org.lwjgl.opengl.GL11; + +import EUI.SteamPower.SteamPower; +import EUI.SteamPower.burner.ContainerFireBox; +import EUI.SteamPower.burner.TileEntityFireBox; + +import java.math.*; +import java.text.DecimalFormat; +import java.lang.Integer; +import net.minecraft.src.*; + +public class GUIFireBox extends GuiContainer +{ + private TileEntityFireBox tileEntity; + + private int containerWidth; + private int containerHeight; + + public GUIFireBox(InventoryPlayer par1InventoryPlayer, TileEntityFireBox tileEntity) + { + super(new ContainerFireBox(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items) + */ + protected void drawGuiContainerForegroundLayer() + { + this.fontRenderer.drawString("FireBox", 55, 6, 4210752); + this.fontRenderer.drawString("HeatOut", 90, 33, 4210752); + String displayText = ""; + if(!tileEntity.isConnected) + { + displayText = "No Boiler"; + } + else if(tileEntity.containingItems[0] != null) + { + if(tileEntity.containingItems[0].getItem().shiftedIndex != Item.coal.shiftedIndex) + { + displayText = "No Coal"; + } + else{ + if(tileEntity.generateRate*20 < 20) + { + displayText = "Hull Heat: "+(tileEntity.generateRate*100)+"%"; + } + else + { + displayText = getWattDisplay((tileEntity.generateRate*20)); + } + } + } + this.fontRenderer.drawString(displayText, (int)(105-displayText.length()*1.25), 45, 4210752); + this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + /** + * Draw the background layer for the GuiContainer (everything behind the items) + */ + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + int var4 = this.mc.renderEngine.getTexture(SteamPower.textureFile+"SteamGUI.png"); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.renderEngine.bindTexture(var4); + containerWidth = (this.width - this.xSize) / 2; + containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(containerWidth, containerHeight, 0, 0, this.xSize, this.ySize); + } + public static String getWattDisplay(int watts) + { + String displayWatt; + if(watts > 1000) + { + displayWatt = roundTwoDecimals((double)watts/1000)+" MJ"; + } + else + { + displayWatt = watts+" KJ"; + } + + return displayWatt; + } + public static double roundTwoDecimals(double d) + { + DecimalFormat twoDForm = new DecimalFormat("#.##"); + return Double.valueOf(twoDForm.format(d)); + } +} diff --git a/1.3/minecraft/EUIClient/SteamPower/GUIGenerator.java b/1.3/minecraft/EUIClient/SteamPower/GUIGenerator.java new file mode 100644 index 00000000..e6b7adbb --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/GUIGenerator.java @@ -0,0 +1,79 @@ +package EUIClient.SteamPower; + +import org.lwjgl.opengl.GL11; + +import EUI.SteamPower.SteamPower; +import EUI.SteamPower.turbine.ContainerGenerator; +import EUI.SteamPower.turbine.TileEntityGenerator; + +import java.math.*; +import java.lang.Integer; +import net.minecraft.src.*; + + public class GUIGenerator extends GuiContainer + { + private TileEntityGenerator tileEntity; + + private int containerWidth; + private int containerHeight; + + public GUIGenerator(InventoryPlayer par1InventoryPlayer, TileEntityGenerator tileEntity) + { + super(new ContainerGenerator(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items) + */ + protected void drawGuiContainerForegroundLayer() + { + this.fontRenderer.drawString("Steam Engine MkI", 55, 6, 4210752); + this.fontRenderer.drawString("MeterReadings", 90, 33, 4210752); + String displayText = ""; + String displayText2 = ""; + String displayText3 = ""; + if(tileEntity.connectedElectricUnit == null) + { + displayText = "Not Connected"; + } + else if(tileEntity.generateRate*20 <= 0) + { + if(tileEntity.steamStored> 0) + { + displayText = "Power Full"; + } + if(tileEntity.steamStored<= 0) + { + displayText = "No Steam"; + } + } + else if(tileEntity.generateRate*20 < 20) + { + displayText = "Warming UP: "+(int)(tileEntity.generateRate*100)+"%"; + } + else + { + displayText = universalelectricity.UniversalElectricity.getWattDisplay((int)(tileEntity.generateRate*20)); + } + displayText2 = "water" + "-" + tileEntity.waterStored; + displayText3 = "steam" + "-" + tileEntity.steamStored; + this.fontRenderer.drawString(displayText, (int)(105-displayText.length()*1), 45, 4210752); + this.fontRenderer.drawString(displayText2, (int)(105-displayText.length()*1), 55, 4210752); + this.fontRenderer.drawString(displayText3, (int)(105-displayText.length()*1), 65, 4210752); + this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + /** + * Draw the background layer for the GuiContainer (everything behind the items) + */ + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + int var4 = this.mc.renderEngine.getTexture(SteamPower.textureFile+"SteamGUI.png"); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.renderEngine.bindTexture(var4); + containerWidth = (this.width - this.xSize) / 2; + containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(containerWidth, containerHeight, 0, 0, this.xSize, this.ySize); + } + } diff --git a/1.3/minecraft/EUIClient/SteamPower/GuiBoiler.java b/1.3/minecraft/EUIClient/SteamPower/GuiBoiler.java new file mode 100644 index 00000000..dc91a79c --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/GuiBoiler.java @@ -0,0 +1,88 @@ +package EUIClient.SteamPower; +import java.text.DecimalFormat; + +import net.minecraft.src.*; + +import org.lwjgl.opengl.GL11; + +import EUI.SteamPower.SteamPower; +import EUI.SteamPower.boiler.ContainerBoiler; +import EUI.SteamPower.boiler.TileEntityBoiler; + +public class GuiBoiler extends GuiContainer +{ + private TileEntityBoiler boilerInventory; + + public GuiBoiler(InventoryPlayer par1InventoryPlayer, TileEntityBoiler par2TileEntityGrinder) + { + super(new ContainerBoiler(par1InventoryPlayer, par2TileEntityGrinder)); + this.boilerInventory = par2TileEntityGrinder; + } + + /** + * Draw the foreground layer for the GuiContainer (everythin in front of the items) + */ + protected void drawGuiContainerForegroundLayer() + { + this.fontRenderer.drawString("Boiler", 60, 6, 4210752); + this.fontRenderer.drawString("Inventory", 8, this.ySize - 96 + 2, 4210752); if(boilerInventory.hullHeat >=10000) + { + this.fontRenderer.drawString("Heat Danger", (int)(105), 50, 4210752); + } + this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + /** + * Draw the background layer for the GuiContainer (everything behind the items) + */ + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + int var4 = this.mc.renderEngine.getTexture(SteamPower.textureFile+"BoilerGui.png"); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.renderEngine.bindTexture(var4); + int var5 = (this.width - this.xSize) / 2; + int var6 = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(var5, var6, 0, 0, this.xSize-1, this.ySize); + int var7; + int var8; + int var9; + int var10; + if (this.boilerInventory.waterStored > 0) + { + var7 = boilerInventory.getStoredLiquid(1)*4 + 1; + this.drawTexturedModalRect(var5 + 29, var6 + 72 - var7, 176, 148 - var7, 23, var7); + } + if (this.boilerInventory.steamStored > 0) + { + var8 = boilerInventory.steamStored/14*4 + 1; + this.drawTexturedModalRect(var5 + 108, var6 + 72 - var8, 176, 90 - var8, 23, var8); + } + + float precentH = Math.min(boilerInventory.hullHeat/1000 + 1, 10); + var9 = (int) Math.min(precentH*3.0F,30); + this.drawTexturedModalRect(var5 + 59, var6 + 70 - var9, 199, 71 - var9, 9, var9); + float precentSH = this.boilerInventory.heatStored/1000; + var10 = (int) Math.round(precentSH*5.33); + this.drawTexturedModalRect(var5 + 78, var6 + 16, 176, 14, var10, 16); + + } + public static String getWattDisplay(int watts) + { + String displayWatt; + if(watts > 1000) + { + displayWatt = roundTwoDecimals((double)watts/1000)+" MJ"; + } + else + { + displayWatt = watts+" kJ"; + } + + return displayWatt; + } + public static double roundTwoDecimals(double d) + { + DecimalFormat twoDForm = new DecimalFormat("#.##"); + return Double.valueOf(twoDForm.format(d)); + } +} diff --git a/1.3/minecraft/EUIClient/SteamPower/ModelEngine.java b/1.3/minecraft/EUIClient/SteamPower/ModelEngine.java new file mode 100644 index 00000000..a06fd499 --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/ModelEngine.java @@ -0,0 +1,242 @@ +// Date: 8/14/2012 3:20:15 AM +// Template version 1.1 +// Java generated by Techne +// Keep in mind that you still need to fill in some blanks +// - ZeuX + + + + + + +package EUIClient.SteamPower; + +import net.minecraft.src.Entity; +import net.minecraft.src.ModelBase; +import net.minecraft.src.ModelRenderer; + +public class ModelEngine extends ModelBase +{ + //fields + ModelRenderer BASE; + ModelRenderer PISTON_WALL_1; + ModelRenderer PISTON_HEAD_MOVES; + ModelRenderer PISTON_TURNER_MOVES; + ModelRenderer PISTON_ARM_MOVES; + ModelRenderer GEAR_A_NECK; + ModelRenderer PISTON_WALL_2; + ModelRenderer PISTON_WALL_3; + ModelRenderer PISTON_WALL_4; + ModelRenderer PISTON_SUPPORT_1; + ModelRenderer PISTON_SUPPORT_2; + ModelRenderer FORCE_CONDUCTOR_BOX; + ModelRenderer GEAR_A_TEETH_1_ROTATES; + ModelRenderer GEAR_A_TEETH_2_ROTATES; + ModelRenderer GEAR_A_TEETH_3_ROTATES; + ModelRenderer FORCE_TRANSMITTER_ROTATES; + ModelRenderer GEAR_B_TEETH_1_ROTATES; + ModelRenderer GEAR_B_TEETH_2_ROTATES; + ModelRenderer GEAR_B_TEETH_3_ROTATES; + ModelRenderer SUPPORT_PLATE; + ModelRenderer ORNAMENT_1; + ModelRenderer ORNAMENT_2; + ModelRenderer LEVER_1_CAN_BE_TURNED; + ModelRenderer LEVER_2_CAN_BE_TURNED; + + public ModelEngine() + { + textureWidth = 128; + textureHeight = 128; + + BASE = new ModelRenderer(this, 0, 0); + BASE.addBox(0F, 0F, 0F, 16, 1, 16); + BASE.setRotationPoint(-8F, 23F, -8F); + BASE.setTextureSize(128, 128); + BASE.mirror = true; + setRotation(BASE, 0F, 0F, 0F); + PISTON_WALL_1 = new ModelRenderer(this, 0, 18); + PISTON_WALL_1.addBox(0F, 0F, 0F, 7, 1, 4); + PISTON_WALL_1.setRotationPoint(0F, 22F, 1F); + PISTON_WALL_1.setTextureSize(128, 128); + PISTON_WALL_1.mirror = true; + setRotation(PISTON_WALL_1, 1.570796F, 0F, 0F); + PISTON_HEAD_MOVES = new ModelRenderer(this, 0, 24); + PISTON_HEAD_MOVES.addBox(0F, -2F, -2F, 4, 4, 4); + PISTON_HEAD_MOVES.setRotationPoint(0F, 20F, 4F); + PISTON_HEAD_MOVES.setTextureSize(128, 128); + PISTON_HEAD_MOVES.mirror = true; + setRotation(PISTON_HEAD_MOVES, 0F, 0F, 0F); + PISTON_TURNER_MOVES = new ModelRenderer(this, 0, 33); + PISTON_TURNER_MOVES.addBox(0F, -1F, -1F, 1, 2, 2); + PISTON_TURNER_MOVES.setRotationPoint(-1F, 20F, 4F); + PISTON_TURNER_MOVES.setTextureSize(128, 128); + PISTON_TURNER_MOVES.mirror = true; + setRotation(PISTON_TURNER_MOVES, 0F, 0F, 0F); + PISTON_ARM_MOVES = new ModelRenderer(this, 0, 38); + PISTON_ARM_MOVES.addBox(0F, 0F, -1F, 4, 1, 1); + PISTON_ARM_MOVES.setRotationPoint(-5F, 19F, 4F); + PISTON_ARM_MOVES.setTextureSize(128, 128); + PISTON_ARM_MOVES.mirror = true; + setRotation(PISTON_ARM_MOVES, 0F, 0F, 0F); + GEAR_A_NECK = new ModelRenderer(this, 65, 25); + GEAR_A_NECK.addBox(-1F, -1F, 0F, 2, 2, 1); + GEAR_A_NECK.setRotationPoint(-4F, 19F, -4F); + GEAR_A_NECK.setTextureSize(128, 128); + GEAR_A_NECK.mirror = true; + setRotation(GEAR_A_NECK, 0F, 0F, 0F); + PISTON_WALL_2 = new ModelRenderer(this, 0, 18); + PISTON_WALL_2.addBox(0F, 0F, 0F, 7, 1, 4); + PISTON_WALL_2.setRotationPoint(0F, 17F, 2F); + PISTON_WALL_2.setTextureSize(128, 128); + PISTON_WALL_2.mirror = true; + setRotation(PISTON_WALL_2, 0F, 0F, 0F); + PISTON_WALL_3 = new ModelRenderer(this, 0, 18); + PISTON_WALL_3.addBox(0F, 0F, 0F, 7, 1, 4); + PISTON_WALL_3.setRotationPoint(0F, 22F, 2F); + PISTON_WALL_3.setTextureSize(128, 128); + PISTON_WALL_3.mirror = true; + setRotation(PISTON_WALL_3, 0F, 0F, 0F); + PISTON_WALL_4 = new ModelRenderer(this, 0, 18); + PISTON_WALL_4.addBox(0F, 0F, 0F, 7, 1, 4); + PISTON_WALL_4.setRotationPoint(0F, 22F, 6F); + PISTON_WALL_4.setTextureSize(128, 128); + PISTON_WALL_4.mirror = true; + setRotation(PISTON_WALL_4, 1.570796F, 0F, 0F); + PISTON_SUPPORT_1 = new ModelRenderer(this, 0, 41); + PISTON_SUPPORT_1.addBox(0F, 0F, 0F, 1, 8, 6); + PISTON_SUPPORT_1.setRotationPoint(7F, 15F, 1F); + PISTON_SUPPORT_1.setTextureSize(128, 128); + PISTON_SUPPORT_1.mirror = true; + setRotation(PISTON_SUPPORT_1, 0F, 0F, 0F); + PISTON_SUPPORT_2 = new ModelRenderer(this, 0, 57); + PISTON_SUPPORT_2.addBox(0F, 0F, 0F, 1, 4, 4); + PISTON_SUPPORT_2.setRotationPoint(7F, 12F, 4F); + PISTON_SUPPORT_2.setTextureSize(128, 128); + PISTON_SUPPORT_2.mirror = true; + setRotation(PISTON_SUPPORT_2, -0.7853982F, 0F, 0F); + FORCE_CONDUCTOR_BOX = new ModelRenderer(this, 65, 0); + FORCE_CONDUCTOR_BOX.addBox(0F, 0F, 0F, 4, 5, 6); + FORCE_CONDUCTOR_BOX.setRotationPoint(-6F, 18F, -3F); + FORCE_CONDUCTOR_BOX.setTextureSize(128, 128); + FORCE_CONDUCTOR_BOX.mirror = true; + setRotation(FORCE_CONDUCTOR_BOX, 0F, 0F, 0F); + GEAR_A_TEETH_1_ROTATES = new ModelRenderer(this, 93, 0); + GEAR_A_TEETH_1_ROTATES.addBox(-3F, -1F, 0F, 6, 2, 1); + GEAR_A_TEETH_1_ROTATES.setRotationPoint(-4F, 19F, -5F); + GEAR_A_TEETH_1_ROTATES.setTextureSize(128, 128); + GEAR_A_TEETH_1_ROTATES.mirror = true; + setRotation(GEAR_A_TEETH_1_ROTATES, 0F, 0F, 0F); + GEAR_A_TEETH_2_ROTATES = new ModelRenderer(this, 93, 0); + GEAR_A_TEETH_2_ROTATES.addBox(-3F, -1F, 0F, 6, 2, 1); + GEAR_A_TEETH_2_ROTATES.setRotationPoint(-4F, 19F, -5F); + GEAR_A_TEETH_2_ROTATES.setTextureSize(128, 128); + GEAR_A_TEETH_2_ROTATES.mirror = true; + setRotation(GEAR_A_TEETH_2_ROTATES, 0F, 0F, 1.047198F); + GEAR_A_TEETH_3_ROTATES = new ModelRenderer(this, 93, 0); + GEAR_A_TEETH_3_ROTATES.addBox(-3F, -1F, 0F, 6, 2, 1); + GEAR_A_TEETH_3_ROTATES.setRotationPoint(-4F, 19F, -5F); + GEAR_A_TEETH_3_ROTATES.setTextureSize(128, 128); + GEAR_A_TEETH_3_ROTATES.mirror = true; + setRotation(GEAR_A_TEETH_3_ROTATES, 0F, 0F, -1.047198F); + FORCE_TRANSMITTER_ROTATES = new ModelRenderer(this, 65, 25); + FORCE_TRANSMITTER_ROTATES.addBox(-1F, -1F, 0F, 2, 2, 1); + FORCE_TRANSMITTER_ROTATES.setRotationPoint(0F, 17F, -8F); + FORCE_TRANSMITTER_ROTATES.setTextureSize(128, 128); + FORCE_TRANSMITTER_ROTATES.mirror = true; + setRotation(FORCE_TRANSMITTER_ROTATES, 0F, 0F, 0F); + GEAR_B_TEETH_1_ROTATES = new ModelRenderer(this, 93, 5); + GEAR_B_TEETH_1_ROTATES.addBox(-3F, -1F, 0F, 6, 2, 3); + GEAR_B_TEETH_1_ROTATES.setRotationPoint(0F, 17F, -7F); + GEAR_B_TEETH_1_ROTATES.setTextureSize(128, 128); + GEAR_B_TEETH_1_ROTATES.mirror = true; + setRotation(GEAR_B_TEETH_1_ROTATES, 0F, 0F, 0F); + GEAR_B_TEETH_2_ROTATES = new ModelRenderer(this, 93, 5); + GEAR_B_TEETH_2_ROTATES.addBox(-3F, -1F, 0F, 6, 2, 3); + GEAR_B_TEETH_2_ROTATES.setRotationPoint(0F, 17F, -7F); + GEAR_B_TEETH_2_ROTATES.setTextureSize(128, 128); + GEAR_B_TEETH_2_ROTATES.mirror = true; + setRotation(GEAR_B_TEETH_2_ROTATES, 0F, 0F, 1.047198F); + GEAR_B_TEETH_3_ROTATES = new ModelRenderer(this, 93, 5); + GEAR_B_TEETH_3_ROTATES.addBox(-3F, -1F, 0F, 6, 2, 3); + GEAR_B_TEETH_3_ROTATES.setRotationPoint(0F, 17F, -7F); + GEAR_B_TEETH_3_ROTATES.setTextureSize(128, 128); + GEAR_B_TEETH_3_ROTATES.mirror = true; + setRotation(GEAR_B_TEETH_3_ROTATES, 0F, 0F, -1.047198F); + SUPPORT_PLATE = new ModelRenderer(this, 65, 12); + SUPPORT_PLATE.addBox(0F, 0F, 0F, 9, 8, 4); + SUPPORT_PLATE.setRotationPoint(-1F, 15F, -4F); + SUPPORT_PLATE.setTextureSize(128, 128); + SUPPORT_PLATE.mirror = true; + setRotation(SUPPORT_PLATE, 0F, 0F, 0F); + ORNAMENT_1 = new ModelRenderer(this, 86, 0); + ORNAMENT_1.addBox(0F, 0F, 0F, 1, 4, 2); + ORNAMENT_1.setRotationPoint(6F, 19F, -5F); + ORNAMENT_1.setTextureSize(128, 128); + ORNAMENT_1.mirror = true; + setRotation(ORNAMENT_1, -0.2094395F, 0F, 0F); + ORNAMENT_2 = new ModelRenderer(this, 86, 0); + ORNAMENT_2.addBox(0F, 0F, 0F, 1, 4, 2); + ORNAMENT_2.setRotationPoint(4F, 19F, -5F); + ORNAMENT_2.setTextureSize(128, 128); + ORNAMENT_2.mirror = true; + setRotation(ORNAMENT_2, -0.2094395F, 0F, 0F); + LEVER_1_CAN_BE_TURNED = new ModelRenderer(this, 0, 0); + LEVER_1_CAN_BE_TURNED.addBox(0F, -6F, 0F, 1, 6, 1); + LEVER_1_CAN_BE_TURNED.setRotationPoint(6F, 16F, -3F); + LEVER_1_CAN_BE_TURNED.setTextureSize(128, 128); + LEVER_1_CAN_BE_TURNED.mirror = true; + setRotation(LEVER_1_CAN_BE_TURNED, 0F, 0F, 0F); + LEVER_2_CAN_BE_TURNED = new ModelRenderer(this, 0, 0); + LEVER_2_CAN_BE_TURNED.addBox(0F, -6F, 0F, 1, 6, 1); + LEVER_2_CAN_BE_TURNED.setRotationPoint(4F, 16F, -3F); + LEVER_2_CAN_BE_TURNED.setTextureSize(128, 128); + LEVER_2_CAN_BE_TURNED.mirror = true; + setRotation(LEVER_2_CAN_BE_TURNED, 0F, 0F, 0F); + } + + public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) + { + super.render(entity, f, f1, f2, f3, f4, f5); + setRotationAngles(f, f1, f2, f3, f4, f5); + genRender(f5); + } + public void genRender(float f5) + { + BASE.render(f5); + PISTON_WALL_1.render(f5); + PISTON_HEAD_MOVES.render(f5); + PISTON_TURNER_MOVES.render(f5); + PISTON_ARM_MOVES.render(f5); + GEAR_A_NECK.render(f5); + PISTON_WALL_2.render(f5); + PISTON_WALL_3.render(f5); + PISTON_WALL_4.render(f5); + PISTON_SUPPORT_1.render(f5); + PISTON_SUPPORT_2.render(f5); + FORCE_CONDUCTOR_BOX.render(f5); + GEAR_A_TEETH_1_ROTATES.render(f5); + GEAR_A_TEETH_2_ROTATES.render(f5); + GEAR_A_TEETH_3_ROTATES.render(f5); + FORCE_TRANSMITTER_ROTATES.render(f5); + GEAR_B_TEETH_1_ROTATES.render(f5); + GEAR_B_TEETH_2_ROTATES.render(f5); + GEAR_B_TEETH_3_ROTATES.render(f5); + SUPPORT_PLATE.render(f5); + ORNAMENT_1.render(f5); + ORNAMENT_2.render(f5); + LEVER_1_CAN_BE_TURNED.render(f5); + LEVER_2_CAN_BE_TURNED.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); + } + +} diff --git a/1.3/minecraft/EUIClient/SteamPower/ModelFurnace.java b/1.3/minecraft/EUIClient/SteamPower/ModelFurnace.java new file mode 100644 index 00000000..37d0e0bd --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/ModelFurnace.java @@ -0,0 +1,82 @@ +// Date: 8/14/2012 3:02:31 AM +// Template version 1.1 +// Java generated by Techne +// Keep in mind that you still need to fill in some blanks +// - ZeuX + + + + + + +package EUIClient.SteamPower; + +import net.minecraft.src.Entity; +import net.minecraft.src.ModelBase; +import net.minecraft.src.ModelRenderer; + +public class ModelFurnace extends ModelBase +{ + //fields + ModelRenderer Body; + ModelRenderer top; + ModelRenderer bottom; + ModelRenderer Shape1; + + public ModelFurnace() + { + textureWidth = 256; + textureHeight = 256; + + Body = new ModelRenderer(this, 0, 0); + Body.addBox(-8F, -8F, -8F, 14, 14, 12); + Body.setRotationPoint(1F, 18F, 1F); + Body.setTextureSize(256, 256); + Body.mirror = true; + setRotation(Body, 0F, 0F, 0F); + top = new ModelRenderer(this, 80, 20); + top.addBox(-8F, 0F, -8F, 16, 2, 16); + top.setRotationPoint(0F, 8F, 0F); + top.setTextureSize(256, 256); + top.mirror = true; + setRotation(top, 0F, 0F, 0F); + bottom = new ModelRenderer(this, 80, 0); + bottom.addBox(-8F, 22F, -8F, 16, 2, 16); + bottom.setRotationPoint(0F, 0F, 0F); + bottom.setTextureSize(256, 256); + bottom.mirror = true; + setRotation(bottom, 0F, 0F, 0F); + Shape1 = new ModelRenderer(this, 0, 0); + Shape1.addBox(-4F, -4F, 0F, 10, 8, 1); + Shape1.setRotationPoint(-1F, 16F, 5F); + Shape1.setTextureSize(256, 256); + Shape1.mirror = true; + setRotation(Shape1, 0F, 0F, 0F); + } + + public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) + { + super.render(entity, f, f1, f2, f3, f4, f5); + setRotationAngles(f, f1, f2, f3, f4, f5); + genRender(f5); + } + public void genRender(float f5) + { + Body.render(f5); + top.render(f5); + bottom.render(f5); + Shape1.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); + } + +} diff --git a/1.3/minecraft/EUIClient/SteamPower/ModelTank.java b/1.3/minecraft/EUIClient/SteamPower/ModelTank.java new file mode 100644 index 00000000..f57c884e --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/ModelTank.java @@ -0,0 +1,155 @@ +// Date: 8/14/2012 1:48:41 AM +// Template version 1.1 +// Java generated by Techne +// Keep in mind that you still need to fill in some blanks +// - ZeuX + + + + + + +package EUIClient.SteamPower; + +import net.minecraft.src.Entity; +import net.minecraft.src.ModelBase; +import net.minecraft.src.ModelRenderer; + +public class ModelTank extends ModelBase +{ + //fields + ModelRenderer TANK_WALL_1; + ModelRenderer TANK_WALL_2; + ModelRenderer TANK_WALL_3; + ModelRenderer TANK_WALL_4; + ModelRenderer TANK_SUPPORT_1; + ModelRenderer TANK_TOP_1; + ModelRenderer TANK_WALL_5; + ModelRenderer TANK_SUPPORT_2; + ModelRenderer TANK_SUPPORT_3; + ModelRenderer TANK_WALL_6; + ModelRenderer TANK_TOP_2; + ModelRenderer TANK_TOP_3; + ModelRenderer TANK_VALVE; + + public ModelTank(float par1) + { + textureWidth = 128; + textureHeight = 128; + + TANK_WALL_1 = new ModelRenderer(this, 0, 49); + TANK_WALL_1.addBox(0F, 0F, 0F, 1, 12, 8,par1); + TANK_WALL_1.setRotationPoint(6F, 12F, -4F); + TANK_WALL_1.setTextureSize(128, 128); + TANK_WALL_1.mirror = true; + setRotation(TANK_WALL_1, 0F, 0F, 0F); + TANK_WALL_2 = new ModelRenderer(this, 0, 70); + TANK_WALL_2.addBox(0F, 0F, 0F, 1, 12, 7,par1); + TANK_WALL_2.setRotationPoint(-8F, 12F, -4F); + TANK_WALL_2.setTextureSize(128, 128); + TANK_WALL_2.mirror = true; + setRotation(TANK_WALL_2, 0F, 0F, 0F); + TANK_WALL_3 = new ModelRenderer(this, 0, 34); + TANK_WALL_3.addBox(0F, 0F, 0F, 8, 12, 1,par1); + TANK_WALL_3.setRotationPoint(0F, 12F, 8F); + TANK_WALL_3.setTextureSize(128, 128); + TANK_WALL_3.mirror = true; + setRotation(TANK_WALL_3, 0F, 2.617994F, 0F); + TANK_WALL_4 = new ModelRenderer(this, 0, 34); + TANK_WALL_4.addBox(0F, 0F, 0F, 8, 12, 1,par1); + TANK_WALL_4.setRotationPoint(0F, 12F, -8F); + TANK_WALL_4.setTextureSize(128, 128); + TANK_WALL_4.mirror = true; + setRotation(TANK_WALL_4, 0F, -0.5235988F, 0F); + TANK_SUPPORT_1 = new ModelRenderer(this, 43, 22); + TANK_SUPPORT_1.addBox(-1F, 0F, -8F, 2, 14, 16,par1); + TANK_SUPPORT_1.setRotationPoint(0F, 10F, 0F); + TANK_SUPPORT_1.setTextureSize(128, 128); + TANK_SUPPORT_1.mirror = true; + setRotation(TANK_SUPPORT_1, 0F, 0F, 0F); + TANK_TOP_1 = new ModelRenderer(this, 43, 11); + TANK_TOP_1.addBox(-8F, 0F, -4F, 16, 2, 8,par1); + TANK_TOP_1.setRotationPoint(0F, 10F, 0F); + TANK_TOP_1.setTextureSize(128, 128); + TANK_TOP_1.mirror = true; + setRotation(TANK_TOP_1, 0F, 0F, 0F); + TANK_WALL_5 = new ModelRenderer(this, 0, 34); + TANK_WALL_5.addBox(0F, 0F, 0F, 8, 12, 1,par1); + TANK_WALL_5.setRotationPoint(0F, 12F, -7F); + TANK_WALL_5.setTextureSize(128, 128); + TANK_WALL_5.mirror = true; + setRotation(TANK_WALL_5, 0F, -2.617994F, 0F); + TANK_SUPPORT_2 = new ModelRenderer(this, 0, 0); + TANK_SUPPORT_2.addBox(-1F, 0F, -9F, 2, 14, 18,par1); + TANK_SUPPORT_2.setRotationPoint(0F, 10F, 0F); + TANK_SUPPORT_2.setTextureSize(128, 128); + TANK_SUPPORT_2.mirror = true; + setRotation(TANK_SUPPORT_2, 0F, 1.047198F, 0F); + TANK_SUPPORT_3 = new ModelRenderer(this, 0, 0); + TANK_SUPPORT_3.addBox(-1F, 0F, -9F, 2, 14, 18,par1); + TANK_SUPPORT_3.setRotationPoint(0F, 10F, 0F); + TANK_SUPPORT_3.setTextureSize(128, 128); + TANK_SUPPORT_3.mirror = true; + setRotation(TANK_SUPPORT_3, 0F, -1.047198F, 0F); + TANK_WALL_6 = new ModelRenderer(this, 0, 34); + TANK_WALL_6.addBox(0F, 0F, 0F, 8, 12, 1,par1); + TANK_WALL_6.setRotationPoint(0F, 12F, 7F); + TANK_WALL_6.setTextureSize(128, 128); + TANK_WALL_6.mirror = true; + setRotation(TANK_WALL_6, 0F, 0.5235988F, 0F); + TANK_TOP_2 = new ModelRenderer(this, 43, 0); + TANK_TOP_2.addBox(-6F, 0F, -4F, 12, 2, 8,par1); + TANK_TOP_2.setRotationPoint(0F, 10F, 0F); + TANK_TOP_2.setTextureSize(128, 128); + TANK_TOP_2.mirror = true; + setRotation(TANK_TOP_2, 0F, 1.047198F, 0F); + TANK_TOP_3 = new ModelRenderer(this, 43, 0); + TANK_TOP_3.addBox(-6F, 0F, -4F, 12, 2, 8,par1); + TANK_TOP_3.setRotationPoint(0F, 10F, 0F); + TANK_TOP_3.setTextureSize(128, 128); + TANK_TOP_3.mirror = true; + setRotation(TANK_TOP_3, 0F, -1.047198F, 0F); + TANK_VALVE = new ModelRenderer(this, 84, 0); + TANK_VALVE.addBox(0F, 0F, 0F, 2, 1, 2,par1); + TANK_VALVE.setRotationPoint(-1F, 9F, -1F); + TANK_VALVE.setTextureSize(128, 128); + TANK_VALVE.mirror = true; + setRotation(TANK_VALVE, 0F, 0F, 0F); + } + @Override + public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) + { + super.render(entity, f, f1, f2, f3, f4, f5); + setRotationAngles(f, f1, f2, f3, f4, f5); + generalRender(f5); + } + public void generalRender(float f5) + { + TANK_WALL_1.render(f5); + TANK_WALL_2.render(f5); + TANK_WALL_3.render(f5); + TANK_WALL_4.render(f5); + TANK_SUPPORT_1.render(f5); + TANK_TOP_1.render(f5); + TANK_WALL_5.render(f5); + TANK_SUPPORT_2.render(f5); + TANK_SUPPORT_3.render(f5); + TANK_WALL_6.render(f5); + TANK_TOP_2.render(f5); + TANK_TOP_3.render(f5); + TANK_VALVE.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); + } + +} diff --git a/1.3/minecraft/EUIClient/SteamPower/RenderBoiler.java b/1.3/minecraft/EUIClient/SteamPower/RenderBoiler.java new file mode 100644 index 00000000..b64d662c --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/RenderBoiler.java @@ -0,0 +1,30 @@ +package EUIClient.SteamPower; + +import org.lwjgl.opengl.GL11; + +import EUI.SteamPower.SteamPower; + +import net.minecraft.src.*; + +public class RenderBoiler extends TileEntitySpecialRenderer +{ + int type = 0; + private ModelTank model; + + public RenderBoiler(float par1) + { + model = new ModelTank(par1); + } + + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double d, double d1, double d2, float d3) { + bindTextureByName(SteamPower.textureFile+"tankTexture.png"); + GL11.glPushMatrix(); + GL11.glTranslatef((float) d + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F); + GL11.glScalef(1.0F, -1F, -1F); + model.generalRender(0.0625F); + GL11.glPopMatrix(); + } + +} \ No newline at end of file diff --git a/1.3/minecraft/EUIClient/SteamPower/RenderFurnace.java b/1.3/minecraft/EUIClient/SteamPower/RenderFurnace.java new file mode 100644 index 00000000..d379048a --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/RenderFurnace.java @@ -0,0 +1,29 @@ +package EUIClient.SteamPower; + +import org.lwjgl.opengl.GL11; + +import EUI.SteamPower.SteamPower; +import net.minecraft.src.*; + +public class RenderFurnace extends TileEntitySpecialRenderer +{ + int type = 0; + private ModelFurnace model; + + public RenderFurnace() + { + model = new ModelFurnace(); + } + + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double d, double d1, double d2, float d3) { + bindTextureByName(SteamPower.textureFile+"Furnace.png"); + GL11.glPushMatrix(); + GL11.glTranslatef((float) d + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F); + GL11.glScalef(1.0F, -1F, -1F); + model.genRender(0.0625F); + GL11.glPopMatrix(); + } + +} \ No newline at end of file diff --git a/1.3/minecraft/EUIClient/SteamPower/RenderSteamEngine.java b/1.3/minecraft/EUIClient/SteamPower/RenderSteamEngine.java new file mode 100644 index 00000000..3ad0c5a4 --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/RenderSteamEngine.java @@ -0,0 +1,29 @@ +package EUIClient.SteamPower; + +import org.lwjgl.opengl.GL11; + +import EUI.SteamPower.SteamPower; +import net.minecraft.src.*; + +public class RenderSteamEngine extends TileEntitySpecialRenderer +{ + int type = 0; + private ModelEngine model; + + public RenderSteamEngine() + { + model = new ModelEngine(); + } + + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double d, double d1, double d2, float d3) { + bindTextureByName(SteamPower.textureFile+"tankTexture.png"); + GL11.glPushMatrix(); + GL11.glTranslatef((float) d + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F); + GL11.glScalef(1.0F, -1F, -1F); + model.genRender(0.0625F); + GL11.glPopMatrix(); + } + +} \ No newline at end of file diff --git a/1.3/minecraft/EUIClient/SteamPower/SteamClientProxy.java b/1.3/minecraft/EUIClient/SteamPower/SteamClientProxy.java new file mode 100644 index 00000000..6fb887e8 --- /dev/null +++ b/1.3/minecraft/EUIClient/SteamPower/SteamClientProxy.java @@ -0,0 +1,39 @@ +package EUIClient.SteamPower; + + +import EUI.SteamPower.SteamProxy; +import EUI.SteamPower.TileEntityNuller; +import EUI.SteamPower.boiler.TileEntityBoiler; +import EUI.SteamPower.burner.TileEntityFireBox; +import EUI.SteamPower.turbine.TileEntityGenerator; +import cpw.mods.fml.client.registry.ClientRegistry; +import cpw.mods.fml.common.network.IGuiHandler; +import cpw.mods.fml.common.registry.GameRegistry; +import net.minecraft.src.EntityPlayer; +import net.minecraft.src.ModelBiped; +import net.minecraft.src.RenderBiped; +import net.minecraft.src.RenderBlocks; +import net.minecraft.src.TileEntity; +import net.minecraft.src.World; +import net.minecraftforge.client.MinecraftForgeClient; + +public class SteamClientProxy extends SteamProxy{ + + public void preInit() + { + MinecraftForgeClient.preloadTexture("/EUIClient/textures/blocks.png"); + MinecraftForgeClient.preloadTexture("/EUIClient/textures/Items.png"); + } + @Override + public void init() + { + ClientRegistry.registerTileEntity(TileEntityBoiler.class, "boiler", new RenderBoiler(0f)); + ClientRegistry.registerTileEntity(TileEntityFireBox.class, "fireBox", new RenderFurnace()); + ClientRegistry.registerTileEntity(TileEntityGenerator.class, "generator", new RenderSteamEngine()); + } + public void postInit() + { + + } + +} diff --git a/1.3/minecraft/EUIClient/Textures/BoilerGui.png b/1.3/minecraft/EUIClient/Textures/BoilerGui.png new file mode 100644 index 0000000000000000000000000000000000000000..2eb1fa5cbe5f7f4330864804ad3ab01e055bfe25 GIT binary patch literal 1876 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 literal 0 HcmV?d00001 diff --git a/1.3/minecraft/EUIClient/Textures/Items.png b/1.3/minecraft/EUIClient/Textures/Items.png new file mode 100644 index 0000000000000000000000000000000000000000..2ac4a810f40f2f56bef731001ca478c627d4e8a1 GIT binary patch literal 29993 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 EFXfgrNdN!< literal 0 HcmV?d00001 diff --git a/1.3/minecraft/EUIClient/Textures/SteamGUI.png b/1.3/minecraft/EUIClient/Textures/SteamGUI.png new file mode 100644 index 0000000000000000000000000000000000000000..ac81171315361eec20cf1f7eb53d5f6cdff48132 GIT binary patch literal 3762 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 WU59UubRrj*0?^SgRIgOC4f_YtG&Dv4 literal 0 HcmV?d00001 diff --git a/1.3/minecraft/EUIClient/Textures/SteamPipe.png b/1.3/minecraft/EUIClient/Textures/SteamPipe.png new file mode 100644 index 0000000000000000000000000000000000000000..5f4bb528d01814f47003ede29cf06b68de001a59 GIT binary patch literal 3196 zcmV-?41@EDP)004&%004{+008|`004nN004b?008NW002DY000@xb3BE2000U( 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%0AbMeZq%L-(Jd-Vy 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 WV**nd(hB$(kd4LhqoqgAUH>ok(3-da literal 0 HcmV?d00001 diff --git a/1.3/minecraft/EUIClient/Textures/tankTexture.png b/1.3/minecraft/EUIClient/Textures/tankTexture.png new file mode 100644 index 0000000000000000000000000000000000000000..82b85311d70a731928995004e0824bbbee23c308 GIT binary patch literal 658 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSjKx9jP7LeL$-D$|*pj^6T^J-m z@Uec~W}paXfk$L90|Vb-5N14{zaj-F$X?><>&kwIgO6F$=zD;b2?GO@kf)1dNX4zU zw;hX`3`E!-Tu7YBUBO@z$$zQ3ib4OtJUy$jDS|9Zr#-2?@Aujw>)#Vwk6TN6W%$}3 z{`&Z{ChyYhSUcx)mETHh?=M$fFKs>7&)0MRaUuDYPSY9VesAx%HEW;Gxu4|?$2Zs5 ze8^7!zuCC{&!2l?P20A)^t1noW#0dNsa*)C!Urw`)5puboJ-`l^3|RDnKt2gziG4R z^oE@`bDxRFFfCj6dH&q9!A}!b^_0Y#pV{l5$-6*p!ltkWq4XIHZx*=NL~~t>DqbDI z`Qz}j_3wYX)*k%&dXZWC)q9+K$|Ehl&JhY&S)FL`VjWY*CMFF=M&=J04f0<(9x@qh zt>1f9^``auzt^w*{21zdM4)A#=pGXX@AD#4Dpp4buVB|`k3Kl-fbVai#vrCi3$wK|kpBK-(bvSNyi@*(@ASMBZysCyt z|NQG-f9_ttFP>L*NvTN`rvrlkgGnO`PlH+jkj)Xzl=CElQJ_I`ex^r!=7-=&MgfLZ z*-YNQHt-by#Ti%_7!#xy`mrXnIxy_m$^XE?;{$_*z#U+tglubG%zmJ3gAmB|8B7;hK$@|D1NA@HTISuV|De_N P3?%L8>gTe~DWM4fP^b7L literal 0 HcmV?d00001