diff --git a/build.prop b/build.prop index d4d26ae..f7759d6 100644 --- a/build.prop +++ b/build.prop @@ -1,6 +1,6 @@ minecraft_version=1.7.10 forge_version=10.13.4.1566-1.7.10 tfc_version=0.79.27 -mod_version=1.13 +mod_version=1.14 mod_id=TerraFirmaPunkTweaks group_name=com.JAWolfe.TerraFirmaPunkTweaks \ No newline at end of file diff --git a/builds/TerraFirmaPunkTweaks-1.7.10-1.14.jar b/builds/TerraFirmaPunkTweaks-1.7.10-1.14.jar new file mode 100644 index 0000000..1cc7b21 Binary files /dev/null and b/builds/TerraFirmaPunkTweaks-1.7.10-1.14.jar differ diff --git a/changelog.txt b/changelog.txt index a4477af..14eea65 100644 --- a/changelog.txt +++ b/changelog.txt @@ -1,6 +1,14 @@ Changelog ================================================= ------------------------------------------------- +TFP Tweaks 1.14 +------------------------------------------------- +New Features ++Added a new block, Brick Oven. Brick oven acts like a firepit and vanilla furnace + +Tweaks ++Loom minetweaker method addRecipe code optimization +------------------------------------------------- TFP Tweaks 1.13 ------------------------------------------------- Bug Fixes diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/RecipeTweaks.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/RecipeTweaks.java index 0c5d3bb..287032e 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/RecipeTweaks.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/RecipeTweaks.java @@ -2,7 +2,11 @@ package com.JAWolfe.terrafirmapunktweaks; import java.util.List; +import com.JAWolfe.terrafirmapunktweaks.handlers.FuelManager; import com.JAWolfe.terrafirmapunktweaks.reference.ConfigSettings; +import com.bioxx.tfc.api.TFCBlocks; +import com.bioxx.tfc.api.TFCItems; +import com.bioxx.tfc.api.Constant.Global; import cpw.mods.fml.common.Loader; import net.minecraft.item.Item; @@ -40,7 +44,14 @@ public class RecipeTweaks } public static void RecipeFixes() - { + { + for(int i = 0; i < Global.WOOD_ALL.length; i++) + { + FuelManager.getInstance().addFuel(new ItemStack(TFCItems.logs, 1, i)); + } + + FuelManager.getInstance().addFuel(new ItemStack(Item.getItemFromBlock(TFCBlocks.peat), 1)); + if(Loader.isModLoaded("Steamcraft")) { //OreDictionary.registerOre("itemAxe", new ItemStack(SteamcraftItems.steamAxe, 1, OreDictionary.WILDCARD_VALUE)); diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/TerraFirmaPunkTweaks.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/TerraFirmaPunkTweaks.java index 4eab2df..c0bbb8d 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/TerraFirmaPunkTweaks.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/TerraFirmaPunkTweaks.java @@ -14,6 +14,7 @@ import cpw.mods.fml.common.Mod.EventHandler; 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.NetworkRegistry; import net.minecraftforge.common.MinecraftForge; @Mod(modid = References.ModID, name = References.ModName, version = References.ModVersion, dependencies = References.ModDependencies) @@ -44,10 +45,14 @@ public class TerraFirmaPunkTweaks RecipeTweaks.RecipeFixes(); proxy.setupFluids(); + + NetworkRegistry.INSTANCE.registerGuiHandler(instance, new GUIHandler()); MinecraftForge.EVENT_BUS.register(new PlayerInteractionHandler()); MinecraftForge.EVENT_BUS.register(new PlayerDamageHandler()); + proxy.registerRenderInformation(); + proxy.registerWAILA(); } diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBlocks.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBlocks.java index de3c5ef..6e50736 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBlocks.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBlocks.java @@ -1,5 +1,8 @@ package com.JAWolfe.terrafirmapunktweaks.blocks; +import com.bioxx.tfc.api.Constant.Global; +import com.google.common.collect.ObjectArrays; + import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.registry.GameRegistry; import flaxbeard.steamcraft.SteamcraftBlocks; @@ -9,14 +12,27 @@ import net.minecraftforge.fluids.FluidRegistry; public class TFPBlocks { + public static Block tweakedboiler; public static Block tweakedboilerOn; public static Block tweakedFlashBoiler; + public static Block[] tfpBrickOven; public static Block tfpBlood; public static Fluid tfpFluidBlood; + public static int brickOvenRenderID; + public static void initialise() { + String[] IgStone = ObjectArrays.concat(Global.STONE_IGEX, Global.STONE_IGIN, String.class); + tfpBrickOven = new Block[IgStone.length]; + + for (int i = 0; i < IgStone.length; i++) + { + tfpBrickOven[i] = new TFPBrickOven(i).setBlockName("TFPBrickOven " + IgStone[i]); + GameRegistry.registerBlock(tfpBrickOven[i], "tfpBrickOven" + IgStone[i]); + } + if(Loader.isModLoaded("Steamcraft")) { tweakedboiler = new TweakedBoiler(false).setBlockName(SteamcraftBlocks.boiler.getUnlocalizedName().substring(5)).setHardness(5.0F).setResistance(10.0F); diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBrickOven.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBrickOven.java new file mode 100644 index 0000000..8a01575 --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBrickOven.java @@ -0,0 +1,357 @@ +package com.JAWolfe.terrafirmapunktweaks.blocks; + +import java.util.Random; + +import com.JAWolfe.terrafirmapunktweaks.TerraFirmaPunkTweaks; +import com.JAWolfe.terrafirmapunktweaks.reference.GUIs; +import com.JAWolfe.terrafirmapunktweaks.reference.References; +import com.JAWolfe.terrafirmapunktweaks.tiles.TEBrickOven; +import com.bioxx.tfc.Blocks.BlockTerraContainer; +import com.bioxx.tfc.api.TFCBlocks; +import com.bioxx.tfc.api.TFCItems; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +public class TFPBrickOven extends BlockTerraContainer +{ + @SideOnly(Side.CLIENT) + private IIcon OvenFrontOnIcon; + @SideOnly(Side.CLIENT) + private IIcon OvenFrontOffIcon; + @SideOnly(Side.CLIENT) + private IIcon OvenSideIcon; + + private final Random random = new Random(); + private int OvenType; + + public TFPBrickOven(int ovenType) + { + this.OvenType = ovenType; + this.blockHardness = 16; + } + + @Override + public void registerBlockIcons(IIconRegister register) + { + String iconPrefix = References.ModID + ":"; + OvenFrontOnIcon = register.registerIcon(iconPrefix + "TFPOvenFrontOn"); + OvenFrontOffIcon = register.registerIcon(iconPrefix + "TFPOvenFrontOff"); + OvenSideIcon = register.registerIcon(References.MODID_TFC + ":" + "Invisible"); + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int side, int metadata) + { + if (side == 1) + return this.OvenSideIcon; + else + { + if(metadata == 0 || metadata == 2) + { + if(side == 3) + return this.OvenFrontOffIcon; + else if(side == 4 || side == 5 || side == 2) + return this.OvenSideIcon; + } + else if(metadata == 1) + { + if(side == 2) + return this.OvenFrontOffIcon; + else if(side == 3 || side == 4 || side == 5) + return this.OvenSideIcon; + } + else if(metadata == 3) + { + if(side == 2 || side == 3 || side == 5) + return this.OvenSideIcon; + else if(side == 4) + return this.OvenFrontOffIcon; + } + else if(metadata == 4) + { + if(side == 2 || side == 3 || side == 4) + return this.OvenSideIcon; + else if(side == 5) + return this.OvenFrontOffIcon; + } + else if(metadata == 5) + { + if(side == 2) + return this.OvenFrontOnIcon; + else if(side == 3 || side == 4 || side == 5) + return this.OvenSideIcon; + } + else if(metadata == 6) + { + if(side == 3) + return this.OvenFrontOnIcon; + else if(side == 4 || side == 5 || side == 2) + return this.OvenSideIcon; + } + else if(metadata == 7) + { + if(side == 2 || side == 3 || side == 5) + return this.OvenSideIcon; + else if(side == 4) + return this.OvenFrontOnIcon; + } + else if(metadata == 8) + { + if(side == 2 || side == 3 || side == 4) + return this.OvenSideIcon; + else if(side == 5) + return this.OvenFrontOnIcon; + } + + return this.OvenFrontOffIcon; + } + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + + @Override + public int getRenderType() + { + return TFPBlocks.brickOvenRenderID; + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityplayer, int par6, float par7, float par8, float par9) + { + if(world.isRemote) + return true; + + ItemStack heldItem = entityplayer.getHeldItem(); + TEBrickOven TE = (TEBrickOven)world.getTileEntity(x, y, z); + + if(heldItem != null && (heldItem.getItem() == TFCItems.fireStarter || heldItem.getItem() == TFCItems.flintSteel)) + { + if(TE != null) + { + if(TE.fireTemp < 210 && TE.ovenItemStacks[9] != null) + { + TE.fireTemp = 300; + int ss = entityplayer.inventory.getCurrentItem().stackSize; + int dam = entityplayer.inventory.getCurrentItem().getItemDamage(); + + entityplayer.inventory.setInventorySlotContents(entityplayer.inventory.currentItem, + new ItemStack(entityplayer.getCurrentEquippedItem().getItem(), ss, dam)); + + int metadata = world.getBlockMetadata(x, y, z); + world.setBlockMetadataWithNotify(x, y, z, metadata + 4, 3); + } + } + } + else if(heldItem != null && heldItem.getItem() == Item.getItemFromBlock(TFCBlocks.torch)) + { + if(TE != null) + { + if(TE.fireTemp < 210 && TE.ovenItemStacks[9] != null) + { + TE.fireTemp = 300; + int ss = entityplayer.inventory.getCurrentItem().stackSize - 1; + + entityplayer.inventory.setInventorySlotContents(entityplayer.inventory.currentItem, + new ItemStack(entityplayer.getCurrentEquippedItem().getItem(), ss)); + + int metadata = world.getBlockMetadata(x, y, z); + world.setBlockMetadataWithNotify(x, y, z, metadata + 4, 3); + } + } + } + else + { + if(TE != null) + { + entityplayer.openGui(TerraFirmaPunkTweaks.instance, GUIs.BRICKOVEN.ordinal(), world, x, y, z); + return true; + } + } + + return true; + } + + @Override + public void onBlockAdded(World world, int x, int y, int z) + { + super.onBlockAdded(world, x, y, z); + if (!world.isRemote) + { + Block block1 = world.getBlock(x, y, z - 1); + Block block2 = world.getBlock(x, y, z + 1); + Block block3 = world.getBlock(x - 1, y, z); + Block block4 = world.getBlock(x + 1, y, z); + byte b0 = 3; + + if (block1.func_149730_j() && !block2.func_149730_j()) + { + b0 = 2; + } + + if (block2.func_149730_j() && !block1.func_149730_j()) + { + b0 = 1; + } + + if (block3.func_149730_j() && !block4.func_149730_j()) + { + b0 = 4; + } + + if (block4.func_149730_j() && !block3.func_149730_j()) + { + b0 = 3; + } + + world.setBlockMetadataWithNotify(x, y, z, b0, 2); + } + } + + @Override + public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityliving, ItemStack stack) + { + int l = MathHelper.floor_double((double)(entityliving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3; + + if (l == 0) + { + world.setBlockMetadataWithNotify(x, y, z, 1, 2); + } + + if (l == 1) + { + world.setBlockMetadataWithNotify(x, y, z, 4, 2); + } + + if (l == 2) + { + world.setBlockMetadataWithNotify(x, y, z, 2, 2); + } + + if (l == 3) + { + world.setBlockMetadataWithNotify(x, y, z, 3, 2); + } + + if (stack.hasDisplayName()) + { + ((TEBrickOven)world.getTileEntity(x, y, z)).setCustomInventoryName(stack.getDisplayName()); + } + } + + @Override + public TileEntity createNewTileEntity(World world, int metadata) + { + return new TEBrickOven(); + } + + public int getOvenType() + { + return this.OvenType; + } + + @Override + public void randomDisplayTick(World world, int x, int y, int z, Random rand) + { + int meta = world.getBlockMetadata(x, y, z); + if (meta >= 5) + { + if (rand.nextInt(24) == 0) + world.playSound(x, y, z, "fire.fire", 0.4F + (rand.nextFloat() / 2), 0.7F + rand.nextFloat(), false); + + float f = (float)x + 0.5F; + float f1 = (float)y + 0.0F + rand.nextFloat() * 6.0F / 16.0F; + float f2 = (float)z + 0.5F; + float f3 = 0.52F; + float f4 = rand.nextFloat() * 0.6F - 0.3F; + + if (meta == 7) + { + world.spawnParticle("smoke", (double)(f - f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D); + world.spawnParticle("flame", (double)(f - f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D); + } + else if (meta == 8) + { + world.spawnParticle("smoke", (double)(f + f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D); + world.spawnParticle("flame", (double)(f + f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D); + } + else if (meta == 5) + { + world.spawnParticle("smoke", (double)(f + f4), (double)f1, (double)(f2 - f3), 0.0D, 0.0D, 0.0D); + world.spawnParticle("flame", (double)(f + f4), (double)f1, (double)(f2 - f3), 0.0D, 0.0D, 0.0D); + } + else if (meta == 6) + { + world.spawnParticle("smoke", (double)(f + f4), (double)f1, (double)(f2 + f3), 0.0D, 0.0D, 0.0D); + world.spawnParticle("flame", (double)(f + f4), (double)f1, (double)(f2 + f3), 0.0D, 0.0D, 0.0D); + } + } + } + + @Override + public int getLightValue(IBlockAccess world, int x, int y, int z) + { + int meta = world.getBlockMetadata(x, y, z); + if(meta > 4) + return 10; + else + return 0; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block block, int metadata) + { + if (world.getTileEntity(x, y, z) instanceof TEBrickOven) + { + TEBrickOven te = (TEBrickOven)world.getTileEntity(x, y, z); + for (int i1 = 0; i1 < te.getSizeInventory(); ++i1) + { + ItemStack itemstack = te.getStackInSlot(i1); + + if (itemstack != null) + { + while (itemstack.stackSize > 0) + { + int j1 = this.random.nextInt(21) + 10; + + if (j1 > itemstack.stackSize) + { + j1 = itemstack.stackSize; + } + + itemstack.stackSize -= j1; + EntityItem entityitem = new EntityItem(world, x + 0.5f, y + 0.5f, z + 0.5f, new ItemStack(itemstack.getItem(), j1, itemstack.getItemDamage())); + + if (itemstack.hasTagCompound()) + { + entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy()); + } + + //float f3 = 0.05F; + world.spawnEntityInWorld(entityitem); + } + } + } + world.func_147453_f(x, y, z, block); + } + super.breakBlock(world, x, y, z, block, metadata); + } +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBrickOvenRenderer.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBrickOvenRenderer.java new file mode 100644 index 0000000..91eba40 --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/blocks/TFPBrickOvenRenderer.java @@ -0,0 +1,114 @@ +package com.JAWolfe.terrafirmapunktweaks.blocks; + +import org.lwjgl.opengl.GL11; + +import com.bioxx.tfc.api.TFCBlocks; + +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; + +public class TFPBrickOvenRenderer implements ISimpleBlockRenderingHandler +{ + @Override + public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, + RenderBlocks renderer) + { + int ovenType = 0; + + if(block instanceof TFPBrickOven) + ovenType = ((TFPBrickOven)block).getOvenType(); + + IIcon cobbleIcon = TFCBlocks.stoneIgExCobble.getIcon(0, ovenType); + + if(ovenType > 3) + cobbleIcon = TFCBlocks.stoneIgInCobble.getIcon(0, ovenType - 4); + + renderer.renderAllFaces = true; + + renderer.setRenderBounds(0, 0, 0, 1, 1, 1); + + renderer.overrideBlockTexture = cobbleIcon; + renderer.renderStandardBlock(block, x, y, z); + renderer.clearOverrideBlockTexture(); + + renderer.renderStandardBlock(block, x, y, z); + + renderer.uvRotateTop = 0; + renderer.uvRotateBottom = 0; + renderer.uvRotateWest = 0; + renderer.uvRotateEast = 0; + renderer.uvRotateNorth = 0; + renderer.uvRotateSouth = 0; + + renderer.renderAllFaces = false; + return true; + } + + @Override + public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) + { + int ovenType = 0; + + if(block instanceof TFPBrickOven) + ovenType = ((TFPBrickOven)block).getOvenType(); + + IIcon cobbleIcon = TFCBlocks.stoneIgExCobble.getIcon(0, ovenType); + + if(ovenType > 3) + cobbleIcon = TFCBlocks.stoneIgInCobble.getIcon(0, ovenType - 4); + + renderInvBlock(block, renderer, cobbleIcon); + } + + private void renderInvBlock(Block block, RenderBlocks renderer, IIcon icon) + { + Tessellator tessellator = Tessellator.instance; + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, -1F, 0.0F); + renderer.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, icon); + renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getBlockTextureFromSide(0)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, icon); + renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getBlockTextureFromSide(1)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, -1F); + renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, icon); + renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getBlockTextureFromSide(2)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, icon); + renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getBlockTextureFromSide(3)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(-1F, 0.0F, 0.0F); + renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, icon); + renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getBlockTextureFromSide(4)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, icon); + renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getBlockTextureFromSide(5)); + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + @Override + public boolean shouldRender3DInInventory(int modelId) { + return true; + } + + @Override + public int getRenderId() { + return 0; + } + +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/FuelManager.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/FuelManager.java new file mode 100644 index 0000000..47d384a --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/FuelManager.java @@ -0,0 +1,68 @@ +package com.JAWolfe.terrafirmapunktweaks.handlers; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +public class FuelManager +{ + private static final FuelManager INSTANCE = new FuelManager(); + public static final FuelManager getInstance() + { + return INSTANCE; + } + + private List fuels; + + private FuelManager() + { + fuels = new ArrayList(); + } + + public void addFuel(ItemStack fuel) + { + for(int i = 0; i < fuels.size(); i++) + { + if (fuels.get(i) != null && matches(fuel, fuels.get(i))) + return; + } + + this.fuels.add(fuel); + } + + public void removeFuel(ItemStack fuel) + { + for(int i = 0; i < fuels.size(); i++) + { + if (fuels.get(i) != null && matches(fuel, fuels.get(i))) + fuels.remove(i--); + } + } + + public boolean isFuel(ItemStack itemstack) + { + for(int i = 0; i < fuels.size(); i++) + { + if (fuels.get(i) != null && matches(itemstack, fuels.get(i))) + return true; + } + + return false; + } + + public List getFuels() + { + return this.fuels; + } + + private Boolean matches(ItemStack item1, ItemStack item2) + { + boolean iStack = item1 != null && item2 != null; + + boolean itemsEqual = OreDictionary.itemMatches(item1, item2, true); + + return iStack && itemsEqual; + } +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/GUIHandler.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/GUIHandler.java new file mode 100644 index 0000000..8fbc4dd --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/GUIHandler.java @@ -0,0 +1,38 @@ +package com.JAWolfe.terrafirmapunktweaks.handlers; + +import com.JAWolfe.terrafirmapunktweaks.inventory.GUIBrickOven; +import com.JAWolfe.terrafirmapunktweaks.inventory.containers.ContainerBrickOven; +import com.JAWolfe.terrafirmapunktweaks.reference.GUIs; +import com.JAWolfe.terrafirmapunktweaks.tiles.TEBrickOven; + +import cpw.mods.fml.common.network.IGuiHandler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class GUIHandler implements IGuiHandler +{ + + @Override + public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) + { + TileEntity entity = world.getTileEntity(x, y, z); + + if(ID == GUIs.BRICKOVEN.ordinal() && entity != null && entity instanceof TEBrickOven) + return new ContainerBrickOven(player.inventory, (TEBrickOven)entity); + + return null; + } + + @Override + public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) + { + TileEntity entity = world.getTileEntity(x, y, z); + + if(ID == GUIs.BRICKOVEN.ordinal() && entity != null && entity instanceof TEBrickOven) + return new GUIBrickOven(player.inventory, (TEBrickOven)entity, world, x, y, z); + + return null; + } + +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/PlayerDamageHandler.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/PlayerDamageHandler.java index 3c7fe21..8327429 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/PlayerDamageHandler.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/handlers/PlayerDamageHandler.java @@ -35,11 +35,13 @@ public class PlayerDamageHandler **/ @SubscribeEvent public void onDamaged(LivingHurtEvent event) - { + { //Reset Attacking tag on attacking entity if(event.source.getEntity() != null && event.source.getEntity().getEntityData().hasKey("Attacking") && event.source.getEntity().getEntityData().getBoolean("Attacking")) + { event.source.getEntity().getEntityData().setBoolean("Attacking", false); + } //Check if damage is already processed by TFC if (event.source == DamageSource.onFire || event.source == DamageSource.fall || event.source == DamageSource.drown || @@ -91,7 +93,7 @@ public class PlayerDamageHandler */ @SubscribeEvent public void entityAttack(LivingAttackEvent event) - { + { //Don't run if client sided if(event.entityLiving.worldObj.isRemote) return; diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/GUIBrickOven.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/GUIBrickOven.java new file mode 100644 index 0000000..7f8bb16 --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/GUIBrickOven.java @@ -0,0 +1,55 @@ +package com.JAWolfe.terrafirmapunktweaks.inventory; + +import org.lwjgl.opengl.GL11; + +import com.JAWolfe.terrafirmapunktweaks.inventory.containers.ContainerBrickOven; +import com.JAWolfe.terrafirmapunktweaks.reference.References; +import com.JAWolfe.terrafirmapunktweaks.tiles.TEBrickOven; +import com.bioxx.tfc.Core.Player.PlayerInventory; +import com.bioxx.tfc.GUI.GuiContainerTFC; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; + +public class GUIBrickOven extends GuiContainerTFC +{ + public static ResourceLocation texture = new ResourceLocation(References.ModID.toLowerCase(), "textures/gui/BrickOvenGUI.png"); + private TEBrickOven teBrickOven; + + public GUIBrickOven(InventoryPlayer inventoryplayer, TEBrickOven te, World world, int x, int y, int z) + { + super(new ContainerBrickOven(inventoryplayer, te), 176, 85); + this.teBrickOven = te; + } + + @Override + protected void drawGuiContainerBackgroundLayer(float f, int i, int j) + { + if (texture != null) + { + Minecraft.getMinecraft().getTextureManager().bindTexture(texture); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + guiLeft = (width - xSize) / 2; + guiTop = (height - ySize) / 2; + int height = this.getShiftedYSize(); + + drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, height); + + drawForeground(guiLeft, guiTop); + } + + PlayerInventory.drawInventory(this, width, height, this.getShiftedYSize()); + } + + @Override + protected void drawForeground(int guiLeft, int guiTop) + { + if(teBrickOven != null) + { + int scale = teBrickOven.getTemperatureScaled(49); + drawTexturedModalRect(guiLeft + 30, guiTop + 65 - scale, 185, 31, 15, 6); + } + } +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/containers/ContainerBrickOven.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/containers/ContainerBrickOven.java new file mode 100644 index 0000000..d195ebd --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/containers/ContainerBrickOven.java @@ -0,0 +1,149 @@ +package com.JAWolfe.terrafirmapunktweaks.inventory.containers; + +import com.JAWolfe.terrafirmapunktweaks.handlers.FuelManager; +import com.JAWolfe.terrafirmapunktweaks.tiles.TEBrickOven; +import com.bioxx.tfc.Containers.ContainerTFC; +import com.bioxx.tfc.Containers.Slots.SlotFirepit; +import com.bioxx.tfc.Containers.Slots.SlotFirepitIn; +import com.bioxx.tfc.Containers.Slots.SlotFirepitOut; +import com.bioxx.tfc.Core.Player.PlayerInventory; +import com.bioxx.tfc.Items.ItemOre; +import com.bioxx.tfc.api.HeatRegistry; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.ICrafting; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerBrickOven extends ContainerTFC +{ + private TEBrickOven teBrickOven; + private float firetemp; + + public ContainerBrickOven(InventoryPlayer inventoryplayer, TEBrickOven BrickOven) + { + this.teBrickOven = BrickOven; + firetemp = -1111; + + //Input Slots + addSlotToContainer(new SlotFirepitIn(inventoryplayer.player, teBrickOven, 0, 84, 19)); + addSlotToContainer(new SlotFirepitIn(inventoryplayer.player, teBrickOven, 1, 102, 19)); + addSlotToContainer(new SlotFirepitIn(inventoryplayer.player, teBrickOven, 2, 120, 19)); + + //Output Slots + addSlotToContainer(new SlotFirepitOut(inventoryplayer.player, teBrickOven, 3, 84, 47)); + addSlotToContainer(new SlotFirepitOut(inventoryplayer.player, teBrickOven, 4, 102, 47)); + addSlotToContainer(new SlotFirepitOut(inventoryplayer.player, teBrickOven, 5, 120, 47)); + + //Fuel Slots + addSlotToContainer(new SlotBrickOvenFuel(inventoryplayer.player, teBrickOven, 6, 8, 7)); + addSlotToContainer(new SlotFirepit(inventoryplayer.player, teBrickOven, 7, 8, 25)); + addSlotToContainer(new SlotFirepit(inventoryplayer.player, teBrickOven, 8, 8, 43)); + addSlotToContainer(new SlotFirepit(inventoryplayer.player, teBrickOven, 9, 8, 61)); + + PlayerInventory.buildInventoryLayout(this, inventoryplayer, 8, 90, false, true); + } + + @Override + public ItemStack transferStackInSlotTFC(EntityPlayer entityPlayer, int slotIndex) + { + super.transferStackInSlotTFC(entityPlayer, slotIndex); + ItemStack origStack = null; + Slot slot = (Slot) inventorySlots.get(slotIndex); + Slot[] slotinput = {(Slot)inventorySlots.get(0), (Slot)inventorySlots.get(1), (Slot)inventorySlots.get(2)}; + Slot[] slotfuel = {(Slot)inventorySlots.get(6), (Slot)inventorySlots.get(7), (Slot)inventorySlots.get(8), (Slot)inventorySlots.get(9)}; + + if(slot != null && slot.getHasStack()) + { + ItemStack slotStack = slot.getStack(); + origStack = slotStack.copy(); + + // From firepit to inventory + if (slotIndex < 10) + { + if (!this.mergeItemStack(slotStack, 10, this.inventorySlots.size(), true)) + return null; + } + else + { + // Fuel to the fuel input slot + if (FuelManager.getInstance().isFuel(slotStack)) + { + if(slotfuel[0].getHasStack()) + return null; + ItemStack stack = slotStack.copy(); + stack.stackSize = 1; + slotfuel[0].putStack(stack); + slotStack.stackSize--; + } + // No ores, but anything else with a heat index to the input slot + else if (!(slotStack.getItem() instanceof ItemOre) && HeatRegistry.getInstance().findMatchingIndex(slotStack) != null) + { + int openSlot = 0; + for(openSlot = 0; openSlot <= 3; openSlot++) + { + if(openSlot == 3) + return null; + + if(!slotinput[openSlot].getHasStack()) + break; + } + + ItemStack stack = slotStack.copy(); + stack.stackSize = 1; + slotinput[openSlot].putStack(stack); + slotStack.stackSize--; + } + } + + if (slotStack.stackSize <= 0) + slot.putStack(null); + else + slot.onSlotChanged(); + + if (slotStack.stackSize == origStack.stackSize) + return null; + + slot.onPickupFromSlot(player, slotStack); + } + + return origStack; + } + + @SuppressWarnings("unchecked") + @Override + public void detectAndSendChanges() + { + super.detectAndSendChanges(); + for (int var1 = 0; var1 < this.inventorySlots.size(); ++var1) + { + ItemStack var2 = ((Slot)this.inventorySlots.get(var1)).getStack(); + ItemStack var3 = (ItemStack)this.inventoryItemStacks.get(var1); + + if (!ItemStack.areItemStacksEqual(var3, var2)) + { + var3 = var2 == null ? null : var2.copy(); + this.inventoryItemStacks.set(var1, var3); + + for (int var4 = 0; var4 < this.crafters.size(); ++var4) + ((ICrafting)this.crafters.get(var4)).sendSlotContents(this, var1, var3); + } + } + + for (int var1 = 0; var1 < this.crafters.size(); ++var1) + { + ICrafting var2 = (ICrafting)this.crafters.get(var1); + if (this.firetemp != this.teBrickOven.fireTemp) + var2.sendProgressBarUpdate(this, 0, (int)this.teBrickOven.fireTemp); + } + firetemp = this.teBrickOven.fireTemp; + } + + @Override + public void updateProgressBar(int par1, int par2) + { + if (par1 == 0) + this.teBrickOven.fireTemp = par2; + } +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/containers/SlotBrickOvenFuel.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/containers/SlotBrickOvenFuel.java new file mode 100644 index 0000000..410d899 --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/inventory/containers/SlotBrickOvenFuel.java @@ -0,0 +1,35 @@ +package com.JAWolfe.terrafirmapunktweaks.inventory.containers; + +import com.JAWolfe.terrafirmapunktweaks.handlers.FuelManager; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class SlotBrickOvenFuel extends Slot +{ + public SlotBrickOvenFuel(EntityPlayer entityplayer, IInventory iinventory, int i, int j, int k) + { + super(iinventory, i, j, k); + } + + @Override + public boolean isItemValid(ItemStack itemstack) + { + return FuelManager.getInstance().isFuel(itemstack); + } + + @Override + public int getSlotStackLimit() + { + return 1; + } + + @Override + public void putStack(ItemStack par1ItemStack) + { + if (par1ItemStack != null) par1ItemStack.stackSize = 1; + super.putStack(par1ItemStack); + } +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/BrickOven.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/BrickOven.java new file mode 100644 index 0000000..e49211f --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/BrickOven.java @@ -0,0 +1,129 @@ +package com.JAWolfe.terrafirmapunktweaks.minetweaker; + +import com.JAWolfe.terrafirmapunktweaks.handlers.FuelManager; + +import minetweaker.IUndoableAction; +import minetweaker.MineTweakerAPI; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.item.ItemStack; +import stanhebben.zenscript.annotations.ZenClass; +import stanhebben.zenscript.annotations.ZenMethod; + +@ZenClass("mods.tfptweaks.BrickOven") +public class BrickOven +{ + @ZenMethod + public static void addFuel(IItemStack Ifuel) + { + ItemStack fuel = MineTweakerMC.getItemStack(Ifuel); + + if(fuel == null || fuel.getItem() == null) + MineTweakerAPI.logError("Missing Fuel"); + else + MineTweakerAPI.apply(new addFuelAction(fuel)); + } + + @ZenMethod + public static void removeFuel(IItemStack Ifuel) + { + ItemStack fuel = MineTweakerMC.getItemStack(Ifuel); + + if(fuel == null || fuel.getItem() == null) + MineTweakerAPI.logError("Missing Fuel"); + else + MineTweakerAPI.apply(new removeFuelAction(fuel)); + } + + private static class addFuelAction implements IUndoableAction + { + private ItemStack Fuel; + + public addFuelAction(ItemStack fuel) + { + this.Fuel = fuel; + } + + @Override + public void apply() + { + FuelManager.getInstance().addFuel(Fuel); + } + + @Override + public String describe() + { + return "Adding item '" + Fuel.getDisplayName() + "' to the Brick Oven Fuel Registry."; + } + + @Override + public boolean canUndo() + { + return true; + } + + @Override + public void undo() + { + FuelManager.getInstance().removeFuel(Fuel); + } + + @Override + public String describeUndo() + { + return "Removing item '" + Fuel.getDisplayName() + "' from the Brick Oven Fuel Registry."; + } + + @Override + public Object getOverrideKey() + { + return null; + } + } + + private static class removeFuelAction implements IUndoableAction + { + private ItemStack Fuel; + + public removeFuelAction(ItemStack fuel) + { + this.Fuel = fuel; + } + + @Override + public void apply() + { + FuelManager.getInstance().removeFuel(Fuel); + } + + @Override + public String describe() + { + return "Removing item '" + Fuel.getDisplayName() + "' from the Brick Oven Fuel Registry."; + } + + @Override + public boolean canUndo() + { + return true; + } + + @Override + public void undo() + { + FuelManager.getInstance().addFuel(Fuel); + } + + @Override + public String describeUndo() + { + return "Adding item '" + Fuel.getDisplayName() + "' to the Brick Oven Fuel Registry."; + } + + @Override + public Object getOverrideKey() + { + return null; + } + } +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFC/Loom.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFC/Loom.java index 7df3772..fb7ca5f 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFC/Loom.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFC/Loom.java @@ -107,7 +107,7 @@ public class Loom { if (LoomList.get(i) != null) { - if (LoomList.get(i).matches(inputStack)) + if (LoomList.get(i).matches(inputStack) && LoomList.get(i).resultMatches(outputStack)) LoomList.remove(i--); } } diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFCTweaker.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFCTweaker.java index b7ed75e..eb5e9c4 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFCTweaker.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/minetweaker/TFCTweaker.java @@ -18,6 +18,8 @@ public class TFCTweaker { if (Loader.isModLoaded("MineTweaker3") && ConfigSettings.MineTweakerSupport) { + MineTweakerAPI.registerClass(BrickOven.class); + MineTweakerAPI.registerClass(ItemHeat.class); MineTweakerAPI.registerClass(Loom.class); MineTweakerAPI.registerClass(Quern.class); diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/ClientProxy.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/ClientProxy.java index 735af2c..29b3b49 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/ClientProxy.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/ClientProxy.java @@ -1,9 +1,25 @@ package com.JAWolfe.terrafirmapunktweaks.proxy; +import com.JAWolfe.terrafirmapunktweaks.blocks.TFPBlocks; +import com.JAWolfe.terrafirmapunktweaks.blocks.TFPBrickOvenRenderer; + +import cpw.mods.fml.client.registry.RenderingRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + public class ClientProxy extends CommonProxy { public void registerTileEntities() { super.registerTileEntities(); } + + @Override + @SideOnly(Side.CLIENT) + public void registerRenderInformation() + { + TFPBlocks.brickOvenRenderID = RenderingRegistry.getNextAvailableRenderId(); + + RenderingRegistry.registerBlockHandler(TFPBlocks.brickOvenRenderID, new TFPBrickOvenRenderer()); + } } diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/CommonProxy.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/CommonProxy.java index 16fcb81..b976bf8 100644 --- a/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/CommonProxy.java +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/proxy/CommonProxy.java @@ -3,6 +3,7 @@ package com.JAWolfe.terrafirmapunktweaks.proxy; import com.JAWolfe.terrafirmapunktweaks.blocks.TFPBlocks; import com.JAWolfe.terrafirmapunktweaks.items.TFPItems; import com.JAWolfe.terrafirmapunktweaks.tiles.TEBoiler; +import com.JAWolfe.terrafirmapunktweaks.tiles.TEBrickOven; import com.JAWolfe.terrafirmapunktweaks.tiles.TEFlashBoiler; import com.bioxx.tfc.api.TFCItems; import com.sirolf2009.necromancy.item.ItemGeneric; @@ -20,6 +21,8 @@ public class CommonProxy { public void registerTileEntities() { + GameRegistry.registerTileEntity(TEBrickOven.class, "TEBrickOven"); + if(Loader.isModLoaded("Steamcraft")) { GameRegistry.registerTileEntity(TEBoiler.class, "TEBoiler"); @@ -41,6 +44,11 @@ public class CommonProxy } } + public void registerRenderInformation() + { + //Not server-sided + } + public void registerWAILA() { FMLInterModComms.sendMessage("Waila", "register", "com.JAWolfe.terrafirmapunktweaks.WAILAInfo.callbackRegister"); diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/reference/GUIs.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/reference/GUIs.java new file mode 100644 index 0000000..c655900 --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/reference/GUIs.java @@ -0,0 +1,6 @@ +package com.JAWolfe.terrafirmapunktweaks.reference; + +public enum GUIs +{ + BRICKOVEN +} diff --git a/src/main/java/com/JAWolfe/terrafirmapunktweaks/tiles/TEBrickOven.java b/src/main/java/com/JAWolfe/terrafirmapunktweaks/tiles/TEBrickOven.java new file mode 100644 index 0000000..fc1f583 --- /dev/null +++ b/src/main/java/com/JAWolfe/terrafirmapunktweaks/tiles/TEBrickOven.java @@ -0,0 +1,541 @@ +package com.JAWolfe.terrafirmapunktweaks.tiles; + +import java.util.Random; + +import com.JAWolfe.terrafirmapunktweaks.handlers.FuelManager; +import com.bioxx.tfc.Core.TFC_Core; +import com.bioxx.tfc.Items.ItemMeltedMetal; +import com.bioxx.tfc.Items.ItemOre; +import com.bioxx.tfc.api.Food; +import com.bioxx.tfc.api.HeatIndex; +import com.bioxx.tfc.api.HeatRegistry; +import com.bioxx.tfc.api.TFCItems; +import com.bioxx.tfc.api.TFC_ItemHeat; +import com.bioxx.tfc.api.Enums.EnumFuelMaterial; +import com.bioxx.tfc.api.Events.ItemCookEvent; +import com.bioxx.tfc.api.Interfaces.ICookableFood; +import com.bioxx.tfc.api.TileEntities.TEFireEntity; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraftforge.common.MinecraftForge; + +public class TEBrickOven extends TEFireEntity implements ISidedInventory +{ + private static final int[] slotsTop = new int[] {0, 1, 2}; + private static final int[] slotsBottom = new int[] {3, 4, 5}; + private static final int[] slotsSides = new int[] {6}; + + public ItemStack[] ovenItemStacks = new ItemStack[10]; + private String invName; + + public TEBrickOven() + { + fuelTimeLeft = 0; + fuelBurnTemp = 0; + fireTemp = 0; + maxFireTempScale = 2000; + } + + @Override + public void updateEntity() + { + if(!worldObj.isRemote) + { + careForInventorySlot(this.ovenItemStacks[0]); + careForInventorySlot(this.ovenItemStacks[1]); + careForInventorySlot(this.ovenItemStacks[2]); + careForInventorySlot(this.ovenItemStacks[3]); + careForInventorySlot(this.ovenItemStacks[4]); + careForInventorySlot(this.ovenItemStacks[5]); + + cookItem(0); + cookItem(1); + cookItem(2); + + //Push the input fuel down the stack + handleFuelStack(); + + //Turn oven on and off. Meta 0-4 off, 5-8 on + int metadata = worldObj.getBlockMetadata(xCoord, yCoord, zCoord); + + if (fireTemp < 1 && metadata > 4) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, metadata - 4, 3); + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + else if (fireTemp >= 1 && metadata <= 4) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, metadata + 4, 3); + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + + metadata = worldObj.getBlockMetadata(xCoord, yCoord, zCoord); + //If the fire is still burning and has fuel + if(fuelTimeLeft > 0 && fireTemp >= 1) + { + if(worldObj.getBlockMetadata(xCoord, yCoord, zCoord) <= 4) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, metadata + 4, 3); + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + } + else if(fuelTimeLeft <= 0 && fireTemp >= 1 && ovenItemStacks[9] != null && + (!worldObj.canLightningStrikeAt(xCoord, yCoord, zCoord) && !worldObj.canLightningStrikeAt(xCoord, yCoord + 1, zCoord) || + !worldObj.isRaining())) + { + if(ovenItemStacks[9] != null) + { + EnumFuelMaterial m = TFC_Core.getFuelMaterial(ovenItemStacks[9]); + fuelTasteProfile = m.ordinal(); + ovenItemStacks[9] = null; + fuelTimeLeft = m.burnTimeMax; + fuelBurnTemp = m.burnTempMax; + } + } + + //Calculate the fire temp + float desiredTemp = handleTemp(); + + handleTempFlux(desiredTemp); + + //Here we handle the bellows + handleAirReduction(); + + //do a last minute check to verify stack size + if(ovenItemStacks[3] != null) + { + if(ovenItemStacks[3].stackSize <= 0) + ovenItemStacks[3].stackSize = 1; + } + + if(ovenItemStacks[4] != null) + { + if(ovenItemStacks[4].stackSize <= 0) + ovenItemStacks[4].stackSize = 1; + } + + if(ovenItemStacks[5] != null) + { + if(ovenItemStacks[5].stackSize <= 0) + ovenItemStacks[5].stackSize = 1; + } + + if(fuelTimeLeft <= 0) + TFC_Core.handleItemTicking(this, worldObj, xCoord, yCoord, zCoord); + } + } + + @Override + public void careForInventorySlot(ItemStack is) + { + if(is != null) + { + HeatRegistry manager = HeatRegistry.getInstance(); + HeatIndex index = manager.findMatchingIndex(is); + + if (index != null) + { + float temp = TFC_ItemHeat.getTemp(is); + if (fuelTimeLeft > 0 && is.getItem() instanceof ICookableFood) + { + float inc = Food.getCooked(is) + Math.min(fireTemp / 700, 2f); + Food.setCooked(is, inc); + temp = inc; + if (Food.isCooked(is)) + { + int[] cookedTasteProfile = new int[] + { 0, 0, 0, 0, 0 }; + Random r = new Random(((ICookableFood) is.getItem()).getFoodID() + (((int) Food.getCooked(is) - 600) / 120)); + cookedTasteProfile[0] = r.nextInt(31) - 15; + cookedTasteProfile[1] = r.nextInt(31) - 15; + cookedTasteProfile[2] = r.nextInt(31) - 15; + cookedTasteProfile[3] = r.nextInt(31) - 15; + cookedTasteProfile[4] = r.nextInt(31) - 15; + Food.setCookedProfile(is, cookedTasteProfile); + Food.setFuelProfile(is, EnumFuelMaterial.getFuelProfile(fuelTasteProfile)); + } + } + else if (fireTemp > temp && index.hasOutput()) + { + temp += TFC_ItemHeat.getTempIncrease(is); + } + else + temp -= TFC_ItemHeat.getTempDecrease(is); + TFC_ItemHeat.setTemp(is, temp); + } + } + } + + public void cookItem(int slot) + { + HeatRegistry manager = HeatRegistry.getInstance(); + Random r = new Random(); + if(ovenItemStacks[slot] != null) + { + HeatIndex index = manager.findMatchingIndex(ovenItemStacks[slot]); + if(index != null && TFC_ItemHeat.getTemp(ovenItemStacks[slot]) > index.meltTemp) + { + ItemStack output = index.getOutput(ovenItemStacks[slot], r); + ItemCookEvent eventMelt = new ItemCookEvent(ovenItemStacks[slot], output, this); + MinecraftForge.EVENT_BUS.post(eventMelt); + output = eventMelt.result; + int damage = 0; + ItemStack mold = null; + if(output != null) + { + damage = output.getItemDamage(); + if(output.getItem() == ovenItemStacks[slot].getItem()) + damage = ovenItemStacks[slot].getItemDamage(); + + //If the input is unshaped metal + if(ovenItemStacks[slot].getItem() instanceof ItemMeltedMetal) + { + //if both output slots are empty then just lower the input item into the first output slot + if(ovenItemStacks[3] == null && ovenItemStacks[4] == null && ovenItemStacks[5] == null) + { + ovenItemStacks[3] = ovenItemStacks[slot].copy(); + ovenItemStacks[slot] = null; + return; + } + //Otherwise if the first output has an item that doesnt match the input item then put the item in the second output slot + else if(ovenItemStacks[3] != null && ovenItemStacks[3].getItem() != TFCItems.ceramicMold && + (ovenItemStacks[3].getItem() != ovenItemStacks[slot].getItem() || ovenItemStacks[3].getItemDamage() == 0)) + { + if(ovenItemStacks[4] == null) + { + ovenItemStacks[4] = ovenItemStacks[slot].copy(); + ovenItemStacks[slot] = null; + return; + } + } + //Otherwise if both the first and second outputs have items that doesnt match the input item then put the item in the third output slot + else if(ovenItemStacks[4] != null && ovenItemStacks[4].getItem() != TFCItems.ceramicMold && + (ovenItemStacks[4].getItem() != ovenItemStacks[slot].getItem() || ovenItemStacks[4].getItemDamage() == 0)) + { + if(ovenItemStacks[5] == null) + { + ovenItemStacks[5] = ovenItemStacks[slot].copy(); + ovenItemStacks[slot] = null; + return; + } + } + mold = new ItemStack(TFCItems.ceramicMold, 1); + mold.stackSize = 1; + mold.setItemDamage(1); + } + } + //Morph the input + float temp = TFC_ItemHeat.getTemp(ovenItemStacks[slot]); + ovenItemStacks[slot] = index.getMorph(); + if(ovenItemStacks[slot] != null && manager.findMatchingIndex(ovenItemStacks[slot]) != null) + { + //if the input is a new item, then apply the old temperature to it + TFC_ItemHeat.setTemp(ovenItemStacks[slot], temp); + } + + //Check if we should combine the output with a pre-existing output + if(output != null && output.getItem() instanceof ItemMeltedMetal) + { + int leftover = 0; + boolean addLeftover = false; + int dest = 3; + if (ovenItemStacks[3] != null && output.getItem() == ovenItemStacks[3].getItem() && ovenItemStacks[3].getItemDamage() > 0) + { + combineMetals(output, mold, 3, slot, temp, damage, leftover, addLeftover); + } + else if (ovenItemStacks[4] != null && output.getItem() == ovenItemStacks[4].getItem() && ovenItemStacks[4].getItemDamage() > 0) + { + combineMetals(output, mold, 4, slot, temp, damage, leftover, addLeftover); + dest = 4; + } + else if (ovenItemStacks[5] != null && output.getItem() == ovenItemStacks[5].getItem() && ovenItemStacks[5].getItemDamage() > 0) + { + combineMetals(output, mold, 5, slot, temp, damage, leftover, addLeftover); + dest = 5; + } + else if (ovenItemStacks[3] != null && ovenItemStacks[3].getItem() == TFCItems.ceramicMold) + { + ovenItemStacks[3] = output.copy(); + ovenItemStacks[3].setItemDamage(damage); + + TFC_ItemHeat.setTemp(ovenItemStacks[3], temp); + } + else if (ovenItemStacks[4] != null && ovenItemStacks[4].getItem() == TFCItems.ceramicMold) + { + ovenItemStacks[4] = output.copy(); + ovenItemStacks[4].setItemDamage(damage); + + TFC_ItemHeat.setTemp(ovenItemStacks[4], temp); + } + else if (ovenItemStacks[5] != null && ovenItemStacks[5].getItem() == TFCItems.ceramicMold) + { + ovenItemStacks[5] = output.copy(); + ovenItemStacks[5].setItemDamage(damage); + + TFC_ItemHeat.setTemp(ovenItemStacks[5], temp); + } + + if (addLeftover) + { + if(ovenItemStacks[dest] != null && output.getItem() == ovenItemStacks[dest].getItem() && ovenItemStacks[dest].getItemDamage() > 0) + { + int amt1 = 100 - leftover;//the percentage of the output + int amt2 = 100 - ovenItemStacks[dest].getItemDamage();//the percentage currently in the out slot + int amt3 = amt1 + amt2;//combined amount + int amt4 = 100 - amt3;//convert the percent back to mc damage + if(amt4 < 0) + amt4 = 0;//stop the infinite glitch + ovenItemStacks[dest] = output.copy(); + ovenItemStacks[dest].setItemDamage(amt4); + + TFC_ItemHeat.setTemp(ovenItemStacks[dest], temp); + } + else if(ovenItemStacks[dest] != null && ovenItemStacks[dest].getItem() == TFCItems.ceramicMold) + { + ovenItemStacks[dest] = output.copy(); + ovenItemStacks[dest].setItemDamage(100 - leftover); + TFC_ItemHeat.setTemp(ovenItemStacks[dest], temp); + } + } + } + else if(output != null) + { + if(ovenItemStacks[3] == null) + { + ovenItemStacks[3] = output.copy(); + } + else if(ovenItemStacks[4] == null) + { + ovenItemStacks[4] = output.copy(); + } + else if(ovenItemStacks[5] == null) + { + ovenItemStacks[5] = output.copy(); + } + else if (ovenItemStacks[3] != null && ovenItemStacks[4] != null && ovenItemStacks[5] != null) + { + ovenItemStacks[slot] = output.copy(); + } + } + } + } + } + + private void combineMetals(ItemStack output, ItemStack mold, int outputSlot, int inputSlot, float temp, int damage, int leftover, boolean addLeftover) + { + int amt1 = 100 - damage;//the percentage of the output + int amt2 = 100 - ovenItemStacks[outputSlot].getItemDamage();//the percentage currently in the out slot + int amt3 = amt1 + amt2;//combined amount + leftover = amt3 - 100;//assign the leftover so that we can add to the other slot if applicable + if(leftover > 0) + addLeftover = true; + int amt4 = 100 - amt3;//convert the percent back to mc damage + if(amt4 < 0) + amt4 = 0;//stop the infinite glitch + ovenItemStacks[outputSlot] = output.copy(); + ovenItemStacks[outputSlot].setItemDamage(amt4); + + TFC_ItemHeat.setTemp(ovenItemStacks[outputSlot], temp); + + if(ovenItemStacks[inputSlot] == null && mold != null) + ovenItemStacks[inputSlot] = mold; + } + + public void handleFuelStack() + { + if(ovenItemStacks[7] == null && ovenItemStacks[6] != null) + { + ovenItemStacks[7] = ovenItemStacks[6]; + ovenItemStacks[6] = null; + } + if(ovenItemStacks[8] == null && ovenItemStacks[7] != null) + { + ovenItemStacks[8] = ovenItemStacks[7]; + ovenItemStacks[7] = null; + } + if(ovenItemStacks[9] == null && ovenItemStacks[8] != null) + { + ovenItemStacks[9] = ovenItemStacks[8]; + ovenItemStacks[8] = null; + } + } + + @Override + public int getSizeInventory() + { + return ovenItemStacks.length; + } + + @Override + public ItemStack getStackInSlot(int slot) + { + return this.ovenItemStacks[slot]; + } + + @Override + public ItemStack decrStackSize(int slot, int amount) + { + if (this.ovenItemStacks[slot] != null) + { + ItemStack itemstack; + + if (this.ovenItemStacks[slot].stackSize <= amount) + { + itemstack = this.ovenItemStacks[slot]; + this.ovenItemStacks[slot] = null; + return itemstack; + } + else + { + itemstack = this.ovenItemStacks[slot].splitStack(amount); + + if (this.ovenItemStacks[slot].stackSize == 0) + this.ovenItemStacks[slot] = null; + + return itemstack; + } + } + else + return null; + } + + @Override + public ItemStack getStackInSlotOnClosing(int slot) + { + if (this.ovenItemStacks[slot] != null) + { + ItemStack itemstack = this.ovenItemStacks[slot]; + this.ovenItemStacks[slot] = null; + return itemstack; + } + else + { + return null; + } + } + + @Override + public void setInventorySlotContents(int slot, ItemStack stack) + { + this.ovenItemStacks[slot] = stack; + + if (stack != null && stack.stackSize > this.getInventoryStackLimit()) + { + stack.stackSize = this.getInventoryStackLimit(); + } + } + + @Override + public String getInventoryName() + { + return this.hasCustomInventoryName() ? this.invName : "container.brickOven"; + } + + @Override + public boolean hasCustomInventoryName() + { + return this.invName != null && this.invName.length() > 0; + } + + public void setCustomInventoryName(String name) + { + this.invName = name; + } + + @Override + public int getInventoryStackLimit() + { + return 1; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer player) + { + return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : player.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + + @Override + public void openInventory() {} + + @Override + public void closeInventory() {} + + @Override + public boolean isItemValidForSlot(int slot, ItemStack item) + { + if(slot == slotsTop[0] && ovenItemStacks[slotsTop[0]] == null) + { + return !(item.getItem() instanceof ItemOre) && HeatRegistry.getInstance().findMatchingIndex(item) != null; + } + else if(slot == slotsTop[1] && ovenItemStacks[slotsTop[1]] == null) + { + return !(item.getItem() instanceof ItemOre) && HeatRegistry.getInstance().findMatchingIndex(item) != null; + } + else if(slot == slotsTop[2] && ovenItemStacks[slotsTop[2]] == null) + { + return !(item.getItem() instanceof ItemOre) && HeatRegistry.getInstance().findMatchingIndex(item) != null; + } + else if(slot == slotsSides[0] && ovenItemStacks[slotsSides[0]] == null) + { + return FuelManager.getInstance().isFuel(item); + } + + return false; + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) + { + return side == 0 ? slotsBottom : (side == 1 ? slotsTop : slotsSides); + } + + @Override + public boolean canInsertItem(int slot, ItemStack item, int side) + { + return this.isItemValidForSlot(slot, item); + } + + @Override + public boolean canExtractItem(int slot, ItemStack item, int side) + { + return side == 0 && (slot == 3 || slot == 4 || slot == 5); + } + + @Override + public void writeToNBT(NBTTagCompound nbttagcompound) + { + super.writeToNBT(nbttagcompound); + NBTTagList nbttaglist = new NBTTagList(); + for(int i = 0; i < ovenItemStacks.length; i++) + { + if(ovenItemStacks[i] != null) + { + NBTTagCompound nbttagcompound1 = new NBTTagCompound(); + nbttagcompound1.setByte("Slot", (byte)i); + ovenItemStacks[i].writeToNBT(nbttagcompound1); + nbttaglist.appendTag(nbttagcompound1); + } + } + nbttagcompound.setTag("Items", nbttaglist); + } + + @Override + public void readFromNBT(NBTTagCompound nbttagcompound) + { + super.readFromNBT(nbttagcompound); + NBTTagList nbttaglist = nbttagcompound.getTagList("Items", 10); + this.ovenItemStacks = new ItemStack[getSizeInventory()]; + + for(int i = 0; i < nbttaglist.tagCount(); i++) + { + NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i); + byte byte0 = nbttagcompound1.getByte("Slot"); + if(byte0 >= 0 && byte0 < ovenItemStacks.length) + ovenItemStacks[byte0] = ItemStack.loadItemStackFromNBT(nbttagcompound1); + } + } +} diff --git a/src/main/resources/assets/terrafirmapunktweaks/lang/en_US.lang b/src/main/resources/assets/terrafirmapunktweaks/lang/en_US.lang index a81c782..691b16f 100644 --- a/src/main/resources/assets/terrafirmapunktweaks/lang/en_US.lang +++ b/src/main/resources/assets/terrafirmapunktweaks/lang/en_US.lang @@ -32,6 +32,27 @@ effect.bleed.postfix=Potion of Bleeding #= Blocks = #========== tile.tfpBlood.name=Blood +tile.TFPBrickOven Granite.name=Granite Brick Oven +tile.TFPBrickOven Diorite.name=Diorite Brick Oven +tile.TFPBrickOven Gabbro.name=Gabbro Brick Oven +tile.TFPBrickOven Shale.name=Shale Brick Oven +tile.TFPBrickOven Claystone.name=Claystone Brick Oven +tile.TFPBrickOven Rock Salt.name=Rock Salt Brick Oven +tile.TFPBrickOven Limestone.name=Limestone Brick Oven +tile.TFPBrickOven Conglomerate.name=Conglomerate Brick Oven +tile.TFPBrickOven Dolomite.name=Dolomite Brick Oven +tile.TFPBrickOven Chert.name=Chert Brick Oven +tile.TFPBrickOven Chalk.name=Chalk Brick Oven +tile.TFPBrickOven Rhyolite.name=Rhyolite Brick Oven +tile.TFPBrickOven Basalt.name=Basalt Brick Oven +tile.TFPBrickOven Andesite.name=Andesite Brick Oven +tile.TFPBrickOven Dacite.name=Dacite Brick Oven +tile.TFPBrickOven Quartzite.name=Quartzite Brick Oven +tile.TFPBrickOven Slate.name=Slate Brick Oven +tile.TFPBrickOven Phyllite.name=Phyllite Brick Oven +tile.TFPBrickOven Schist.name=Schist Brick Oven +tile.TFPBrickOven Gneiss.name=Gneiss Brick Oven +tile.TFPBrickOven Marble.name=Marble Brick Oven #========== #= Fluids = diff --git a/src/main/resources/assets/terrafirmapunktweaks/textures/blocks/TFPOvenFrontOff.png b/src/main/resources/assets/terrafirmapunktweaks/textures/blocks/TFPOvenFrontOff.png new file mode 100644 index 0000000..acb1b5f Binary files /dev/null and b/src/main/resources/assets/terrafirmapunktweaks/textures/blocks/TFPOvenFrontOff.png differ diff --git a/src/main/resources/assets/terrafirmapunktweaks/textures/blocks/TFPOvenFrontOn.png b/src/main/resources/assets/terrafirmapunktweaks/textures/blocks/TFPOvenFrontOn.png new file mode 100644 index 0000000..69cd838 Binary files /dev/null and b/src/main/resources/assets/terrafirmapunktweaks/textures/blocks/TFPOvenFrontOn.png differ diff --git a/src/main/resources/assets/terrafirmapunktweaks/textures/gui/BrickOvenGUI.png b/src/main/resources/assets/terrafirmapunktweaks/textures/gui/BrickOvenGUI.png new file mode 100644 index 0000000..de05692 Binary files /dev/null and b/src/main/resources/assets/terrafirmapunktweaks/textures/gui/BrickOvenGUI.png differ