From 09add3e8ac3be54b1e6c068e87d4fb5143c6d785 Mon Sep 17 00:00:00 2001 From: Dream-Master Date: Tue, 21 Jun 2016 18:50:29 +0200 Subject: even with Blood asp experimental branch --- .../common/items/armor/ArmorCalculation.java | 413 +++++++++++++++++++ .../gregtech/common/items/armor/ArmorData.java | 345 ++++++++++++++++ .../common/items/armor/ContainerBasicArmor.java | 48 +++ .../items/armor/ContainerElectricArmor1.java | 53 +++ .../common/items/armor/ContainerModularArmor.java | 171 ++++++++ .../common/items/armor/ElectricModularArmor1.java | 42 ++ .../gregtech/common/items/armor/FluidSync.java | 67 +++ .../gregtech/common/items/armor/FluidSync2.java | 67 +++ .../common/items/armor/GuiElectricArmor1.java | 310 ++++++++++++++ .../common/items/armor/GuiModularArmor.java | 196 +++++++++ .../common/items/armor/InventoryArmor.java | 235 +++++++++++ .../common/items/armor/ModularArmor_Item.java | 447 +++++++++++++++++++++ .../gregtech/common/items/armor/SlotFluid.java | 33 ++ .../gregtech/common/items/armor/SlotLocked.java | 33 ++ .../java/gregtech/common/items/armor/Values.java | 125 ++++++ .../java/gregtech/common/items/armor/Vector3.java | 278 +++++++++++++ 16 files changed, 2863 insertions(+) create mode 100644 src/main/java/gregtech/common/items/armor/ArmorCalculation.java create mode 100644 src/main/java/gregtech/common/items/armor/ArmorData.java create mode 100644 src/main/java/gregtech/common/items/armor/ContainerBasicArmor.java create mode 100644 src/main/java/gregtech/common/items/armor/ContainerElectricArmor1.java create mode 100644 src/main/java/gregtech/common/items/armor/ContainerModularArmor.java create mode 100644 src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java create mode 100644 src/main/java/gregtech/common/items/armor/FluidSync.java create mode 100644 src/main/java/gregtech/common/items/armor/FluidSync2.java create mode 100644 src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java create mode 100644 src/main/java/gregtech/common/items/armor/GuiModularArmor.java create mode 100644 src/main/java/gregtech/common/items/armor/InventoryArmor.java create mode 100644 src/main/java/gregtech/common/items/armor/ModularArmor_Item.java create mode 100644 src/main/java/gregtech/common/items/armor/SlotFluid.java create mode 100644 src/main/java/gregtech/common/items/armor/SlotLocked.java create mode 100644 src/main/java/gregtech/common/items/armor/Values.java create mode 100644 src/main/java/gregtech/common/items/armor/Vector3.java (limited to 'src/main/java/gregtech/common/items/armor') diff --git a/src/main/java/gregtech/common/items/armor/ArmorCalculation.java b/src/main/java/gregtech/common/items/armor/ArmorCalculation.java new file mode 100644 index 0000000000..8915ce6f52 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ArmorCalculation.java @@ -0,0 +1,413 @@ +package gregtech.common.items.armor; + +import java.util.List; + +import thaumcraft.api.nodes.IRevealer; +import cpw.mods.fml.common.Loader; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +public class ArmorCalculation { + public static float[] calculateArmor(ItemStack[] parts) { + float[] def = new float[32]; + def[0] = 0; // Weight + def[1] = 1; // physical Def + def[2] = 1; // projectileDef + def[3] = 1; // fireDef + def[4] = 1; // magicDef + def[5] = 1; // explosionDef + def[6] = 0; // radiationDef + def[7] = 0; // electricDef + def[8] = 0; // witherDef + def[9] = 0; // fallDef + def[10] = 0; // Thorns + def[11] = 0; // ItemMagnet + def[12] = 0; // ItemCharge + def[13] = 0; // Thaumcraft goggles + def[14] = 0; // Nightvision + def[15] = 0; // tankCap + def[16] = 0; // motorPower + def[17] = 0; // motorEU + def[18] = 0; // pistonPower + def[19] = 0; // pistonEU + def[20] = 0; // ElectrolyzerPower + def[21] = 0; // ElectrolyzerEU + def[22] = 0; // FieldEmmiterPower + def[23] = 0; // FieldEmmiterEU + def[24] = 0; // JetpackFuelPower + def[25] = 0; // FuelUsage + def[26] = 0; // JetpackEUPower + def[27] = 0; // JetpackEU + def[28] = 0; // AntiGravPower + def[29] = 0; // AntiGravEU + def[30] = 0; // ProcessingPower + def[31] = 0; // ProcessingPowerUsed + + if (parts != null) { + def[12] = 0.0f; + for (int i = 0; i < parts.length; i++) { + if (parts[i] != null) { + ItemData data = GT_OreDictUnificator.getItemData(parts[i]); + if (data != null && (data.mPrefix == OrePrefixes.plate || data.mPrefix == OrePrefixes.plateAlloy)) { + // Weight + def[0] = def[0] + Values.INSTANCE.getValues(data.mMaterial.mMaterial).weight; + if (data.mPrefix == OrePrefixes.plateAlloy && data.mMaterial.mMaterial == Materials.Iridium) { + def[0] = def[0] - 20; + } + // physicalDef + float tmp = Values.INSTANCE.getValues(data.mMaterial.mMaterial).physicalDef; + if (data.mPrefix == OrePrefixes.plateAlloy && data.mMaterial.mMaterial == Materials.Iridium) { + tmp = 0.27f; + } + if (tmp > 0.0f) { + def[1] = def[1] - (tmp * def[1]); + } + // projectileDef + tmp = Values.INSTANCE.getValues(data.mMaterial.mMaterial).projectileDef; + if (data.mPrefix == OrePrefixes.plateAlloy && data.mMaterial.mMaterial == Materials.Iridium) { + tmp = 0.27f; + } + if (tmp > 0.0f) { + def[2] = def[2] - (tmp * def[2]); + } + // fireDef + tmp = Values.INSTANCE.getValues(data.mMaterial.mMaterial).fireDef; + if (data.mPrefix == OrePrefixes.plateAlloy && data.mMaterial.mMaterial == Materials.Iridium) { + tmp = 0.25f; + } + if (tmp > 0.0f) { + def[3] = def[3] - (tmp * def[3]); + } + // magicDef + tmp = Values.INSTANCE.getValues(data.mMaterial.mMaterial).magicDef; + if (data.mPrefix == OrePrefixes.plateAlloy && data.mMaterial.mMaterial == Materials.Iridium) { + tmp = 0.25f; + } + if (tmp > 0.0f) { + def[4] = def[4] - (tmp * def[4]); + } + // explosionDef + tmp = Values.INSTANCE.getValues(data.mMaterial.mMaterial).explosionDef; + if (data.mPrefix == OrePrefixes.plateAlloy && data.mMaterial.mMaterial == Materials.Iridium) { + tmp = 0.27f; + } + if (tmp > 0.0f) { + def[5] = def[5] - (tmp * def[5]); + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.Rubber) { + def[7] = def[7] + 0.25f; + def[9] = def[9] + 2.0f; + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.Lead) { + def[6] = def[6] + 0.30f; + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.Plastic) { + def[7] = def[7] + 0.25f; + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.NeodymiumMagnetic) { + def[11] = def[11] + 2.0f; + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.NetherStar) { + def[8] = def[8] + 0.20f; + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.InfusedFire) { + def[10] = def[10] + 3.0f; + } + if (data.mPrefix == OrePrefixes.plate && data.mMaterial.mMaterial == Materials.InfusedEntropy) { + def[10] = def[10] + 4.0f; + } + } else if (GT_ModHandler.isChargerItem(parts[i])) { + def[12] = def[12] + (float) ic2.api.item.ElectricItem.manager.getCharge(parts[i]); + def[0] = (float) (def[0] + Math.pow(ic2.api.item.ElectricItem.manager.getCharge(parts[i]), 0.33f)); + } + else if (Loader.isModLoaded("Thaumcraft") && parts[i].getItem() instanceof IRevealer) { + def[13] = 1; + def[31] += 100; + } + else if (parts[i].getItem().getUnlocalizedName().equals("ic2.itemNightvisionGoggles")) { + def[14] = 1; + def[31] += 100; + } else if (parts[i].getItem().getUnlocalizedName().equals("gt.meta.spring")) {// Once readded: GT Motors + switch (parts[i].getItem().getDamage(parts[i])) { + case 8630: + def[16] += 200; // motorPower + def[17] += 50; + def[31] += 10; + break; + case 8631: + def[16] += 300; // motorPower + def[17] += 100; + def[31] += 20; + break; + case 8632: + def[16] += 400; // motorPower + def[17] += 200; + def[31] += 50; + break; + case 8633: + def[16] += 500; // motorPower + def[17] += 400; + def[31] += 100; + break; + case 8634: + def[16] += 600; // motorPower + def[17] += 800; + def[31] += 200; + break; + } + } else if (parts[i].getItem().getUnlocalizedName().equals("gt.meta.springSmall")) {// Once Readded: GT Electric Pistons + switch (parts[i].getItem().getDamage(parts[i])) { + case 8630: + def[18] += 3; + def[19] += 200; + def[31] += 10; + break; + case 8631: + def[18] += 4; + def[19] += 300; + def[31] += 20; + break; + case 8632: + def[18] += 5; + def[19] += 450; + def[31] += 50; + break; + case 8633: + def[18] += 6; + def[19] += 800; + def[31] += 100; + break; + case 8634: + def[18] += 7; + def[19] += 1600; + def[31] += 200; + break; + } + } else if (parts[i].getItem().getUnlocalizedName().equals("gt.meta.Electrolyzer")) {// Once Readded: GT Electrolyzer + switch (parts[i].getItem().getDamage(parts[i])) { + case 8630: + def[20] += 10; // ElectrolyzerPower + def[21] += 1; // ElectrolyzerEU + def[31] += 50; + break; + case 8631: + def[20] += 20; // ElectrolyzerPower + def[21] += 4; // ElectrolyzerEU + def[31] += 100; + break; + case 8632: + def[20] += 40; // ElectrolyzerPower + def[21] += 16; // ElectrolyzerEU + def[31] += 150; + break; + case 8633: + def[20] += 80; // ElectrolyzerPower + def[21] += 64; // ElectrolyzerEU + def[31] += 200; + break; + case 8634: + def[20] += 160; // ElectrolyzerPower + def[21] += 256; // ElectrolyzerEU + def[31] += 250; + break; + } + } else if (parts[i].getItem().equals(ItemList.Cell_Empty.getItem())) { + def[15] += 8000; + } else if (parts[i].getItem().getUnlocalizedName().equals("gt.meta.cell")) {// Once Readded: GT Fluid Cells (tank) + switch (parts[i].getItem().getDamage(parts[i])) { + case 8630: // steel fluid cell + def[15] += 16000; + break; + case 8631: // tungsten fluid cell + def[15] += 64000; + break; + } + } else if (parts[i].getItem().getUnlocalizedName().equals("gt.meta.emmiter")) {// Once Readded: GT Field Emmiter + switch (parts[i].getItem().getDamage(parts[i])) { + case 8630: + def[22] += 1; // FieldEmmiterPower + def[23] += 1; // FieldEmmiterEU + def[31] += 100; + break; + case 8631: + def[22] += 2; // FieldEmmiterPower + def[23] += 4; // FieldEmmiterEU + def[31] += 200; + break; + case 8632: + def[22] += 3; // FieldEmmiterPower + def[23] += 16; // FieldEmmiterEU + def[31] += 300; + break; + case 8633: + def[22] += 4; // FieldEmmiterPower + def[23] += 64; // FieldEmmiterEU + def[31] += 400; + break; + case 8634: + def[22] += 5; // FieldEmmiterPower + def[23] += 512; // FieldEmmiterEU + def[31] += 500; + break; + } + } else if (data !=null && data.mPrefix == OrePrefixes.circuit) {// processing power stuff + if (data.mMaterial.mMaterial == Materials.Basic) { + def[30] += 100; + } else if (data.mMaterial.mMaterial == Materials.Good) { + def[30] += 200; + } else if (data.mMaterial.mMaterial == Materials.Advanced) { + def[30] += 300; + } else if (data.mMaterial.mMaterial == Materials.Data) { + def[30] += 400; + } else if (data.mMaterial.mMaterial == Materials.Elite) { + def[30] += 500; + } else if (data.mMaterial.mMaterial == Materials.Master) { + def[30] += 600; + } + } else if (parts[i].getItem().getUnlocalizedName().equals("gte.meta.jetpack")) {// jeptack parts + switch (parts[i].getItem().getDamage(parts[i])) { + case 0: + def[24] += 50; // JetpackFuelPower + def[25] += 1; // FuelUsage + def[31] += 10; + break; + case 1: + def[24] += 75; // JetpackFuelPower + def[25] += 2; // FuelUsage + def[31] += 20; + break; + case 2: + def[24] += 100; // JetpackFuelPower + def[25] += 4; // FuelUsage + def[31] += 30; + break; + case 3: + def[24] += 125; // JetpackFuelPower + def[25] += 8; // FuelUsage + def[31] += 40; + break; + case 4: + def[24] += 150; // JetpackFuelPower + def[25] += 16; // FuelUsage + def[31] += 50; + break; + case 5: + def[26] += 20; // JetpackEUPower + def[27] += 8; // JetpackEU + def[31] += 30; + break; + case 6: + def[26] += 30; // JetpackEUPower + def[27] += 16; // JetpackEU + def[31] += 60; + break; + case 7: + def[26] += 40; // JetpackEUPower + def[27] += 32; // JetpackEU + def[31] += 90; + break; + case 8: + def[26] += 50; // JetpackEUPower + def[27] += 64; // JetpackEU + def[31] += 120; + break; + case 9: + def[26] += 60; // JetpackEUPower + def[27] += 128; // JetpackEU + def[31] += 150; + break; + case 10: + def[28] += 100; // AntiGravPower + def[29] += 32; // AntiGravEU + def[31] += 100; + break; + case 11: + def[28] += 133; // AntiGravPower + def[29] += 64; // AntiGravEU + def[31] += 200; + break; + case 12: + def[28] += 166; // AntiGravPower + def[29] += 128; // AntiGravEU + def[31] += 300; + break; + case 13: + def[28] += 200; // AntiGravPower + def[29] += 256; // AntiGravEU + def[31] += 400; + break; + case 14: + def[28] += 233; // AntiGravPower + def[29] += 512; // AntiGravEU + def[31] += 500; + break; + } + } else if (true) { + //System.out.println("Unknown Item: " + parts[i].getItem().getUnlocalizedName()); + } + } + } + } + def[1] = 1 - def[1]; + def[2] = 1 - def[2]; + def[3] = 1 - def[3]; + def[4] = 1 - def[4]; + def[5] = 1 - def[5]; + if (def[7] > 0.95) { + def[7] = 1.0f; + } + if (def[8] > 0.98) { + def[8] = 1.0f; + } + return def; + } + + public static int deChargeBatterys(ItemStack[] parts, int amount) { + // System.out.println("deCharge " + amount); + int decharged = 0; + for (int i = 0; decharged < amount && i < parts.length; i++) { + if (GT_ModHandler.isChargerItem(parts[i])) { + decharged = (int) (decharged + ic2.api.item.ElectricItem.manager.discharge(parts[i], amount - decharged, 10, false, false, false)); + } + } + return decharged; + } + + public static FluidStack getFluid(ItemStack[] parts, int tankCap) { + int fluidAmount; + if (parts.length > 12 && parts[12] != null) { + NBTTagCompound nbt = parts[12].getTagCompound(); + if (nbt != null) { + fluidAmount = (int) nbt.getLong("mFluidDisplayAmount"); + if (fluidAmount > tankCap) { + nbt.setLong("mFluidDisplayAmount", tankCap); + parts[12].setTagCompound(nbt); + fluidAmount = tankCap; + } + return new FluidStack(parts[12].getItemDamage(), fluidAmount); + } + + } + return null; + } + + public static void useFluid(ItemStack[] parts, int usedAmount) { + int fluidAmount; + if (parts.length > 12 && parts[12] != null) { + NBTTagCompound nbt = parts[12].getTagCompound(); + if (nbt != null) { + fluidAmount = (int) nbt.getLong("mFluidDisplayAmount"); + nbt.setLong("mFluidDisplayAmount", fluidAmount - usedAmount); + parts[12].setTagCompound(nbt); + } + } + } +} diff --git a/src/main/java/gregtech/common/items/armor/ArmorData.java b/src/main/java/gregtech/common/items/armor/ArmorData.java new file mode 100644 index 0000000000..79c6a20ffa --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ArmorData.java @@ -0,0 +1,345 @@ +package gregtech.common.items.armor; + +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.text.NumberFormat; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Random; + +import gregtech.api.damagesources.GT_DamageSources; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.util.DamageSource; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +public class ArmorData { + + public int type; // 0 = helmet; 1 = chestplate; 2 = leggings; 3 = boots; + public int armorTier; // 0 = Basic Modular Armor; 1 = Modular Exoskeleton; 2= Modular Nanosuit; 3 = Heavy Power Armor + public List info; // needs Localization + public boolean isTopItem; + public int tooltipUpdate; + public boolean openGui; + + public ArmorData helmet; + public ArmorData chestplate; + public ArmorData leggings; + public ArmorData boots; + + public boolean fullArmor; + public boolean fullRadiationDef; + public boolean fullElectricDef; + + public float fallDef; + public float physicalDef; + public float projectileDef; + public float fireDef; + public float magicDef; + public float explosionDef; + public float radiationDef; + public float electricDef; + public float witherDef; + + public float thorns; + public float thornsSingle; + public int magnet; + public int magnetSingle; + + public int partsCharge; + public int maxCharge; + public int charge; + public boolean thaumicGoggles; + public boolean nightVision; + public boolean potionInjector; + public boolean autoFeeder; + + public FluidStack fluid; + public int tankCap; + + public int weight; + public int maxWeight; + public int processingPower; + public int processingPowerUsed; + public int partProcessing; + public int partProcessingUsed; + + public int motorPower; + public int motorEUusage; + public int pistonJumpboost; + public int pistonEUusage; + public int electrolyzerProd; + public int electrolyzerEUusage; + public int fieldGenCap; + public int fieldGenEUusage; + + public int jetpackMaxWeight; + public int antiGravMaxWeight; + + public ArmorData(EntityPlayer player, ItemStack stack, int type, int tier) { + this.type = type; + this.armorTier = tier; + ContainerModularArmor tmp = new ContainerBasicArmor((EntityPlayer) player, new InventoryArmor(ModularArmor_Item.class, stack)); + calculateArmor(tmp.mInvArmor.parts); + switch (tier) { + case 0: + maxCharge = 0; + break; + case 1: + maxCharge = 250000; + break; + case 2: + maxCharge = 1000000; + } + readNBT(stack.getTagCompound()); + } + + private void readNBT(NBTTagCompound nbt) { + if (nbt == null) { + return; + } + if (nbt.hasKey("Charge")) { + this.charge = nbt.getInteger("Charge"); + } + } + + public void writeToNBT(NBTTagCompound nbt) { + if (nbt == null) { + return; + } + nbt.setInteger("Charge", this.charge); + } + + public ArmorData calculateArmor(ItemStack[] parts) { + float[] def = ArmorCalculation.calculateArmor(parts); + weight = (int) def[0]; + physicalDef = def[1]; + projectileDef = def[2]; + fireDef = def[3]; + magicDef = def[4]; + explosionDef = def[5]; + radiationDef = def[6]; + electricDef = def[7]; + witherDef = def[8]; + fallDef = def[9]; + thornsSingle = def[10]; + magnetSingle = (int) def[11]; + if (armorTier > 0) { + partsCharge = (int) def[12]; + thaumicGoggles = def[13] > 0.5f; + nightVision = def[14] > 0.5f; + tankCap = (int) def[15]; // tankCap + motorPower = (int) def[16]; // motorPower + motorEUusage = (int) def[17]; // motorEU + pistonJumpboost = (int) def[18]; // pistonPower + fallDef += pistonJumpboost; + pistonEUusage = (int) def[19]; // pistonEU + electrolyzerProd = (int) def[20]; // ElectrolyzerPower + electrolyzerEUusage = (int) def[21]; // ElectrolyzerEU + fieldGenCap = (int) def[22]; // FieldEmmiterPower + fieldGenEUusage = (int) def[23]; // FieldEmmiterEU + jetpackMaxWeight = (int) def[24] + (int) def[26]; // JetpackFuelPower// JetpackEUPower + def[25] = 0; // FuelUsage + def[27] = 0; // JetpackEU + antiGravMaxWeight = (int) def[28]; // AntiGravPower + def[29] = 0; // AntiGravEU + if (armorTier == 2) { + partProcessing = (int) def[30] + 500; // ProcessingPower + } else { + partProcessing = (int) def[30] + 300; // ProcessingPower + } + partProcessingUsed = (int) def[31]; // ProcessingPowerUsed + } + updateTooltip(); + return this; + } + + public void updateTooltip() { + List tagList = new ArrayList(); + String tmp2 = ""; + if (maxWeight > 4000) { + tmp2 = " " + GT_LanguageManager.getTranslation("hav"); + } + if (maxCharge != 0) { + DecimalFormat formatter = (DecimalFormat) NumberFormat.getInstance(Locale.US); + DecimalFormatSymbols symbols = formatter.getDecimalFormatSymbols(); + symbols.setGroupingSeparator(' '); + if (type == 0) { + if (thaumicGoggles) { + tagList.add(GT_LanguageManager.getTranslation("thaum")); + } + if (nightVision) { + tagList.add(GT_LanguageManager.getTranslation("night")); + } + } + tagList.add("EU: " + formatter.format(charge + partsCharge)); + if (type == 2) { + tagList.add(GT_LanguageManager.getTranslation("jum") + ": " + pistonJumpboost / 3 + "m"); + } + if (type == 2 && pistonJumpboost > 0) { + tagList.add(GT_LanguageManager.getTranslation("uph")); + } + if (type == 2 && motorPower > 0) { + tagList.add(GT_LanguageManager.getTranslation("speass") + ": " + motorPower); + tagList.add(GT_LanguageManager.getTranslation("motuse") + ": " + motorEUusage + " EU"); + if (maxWeight > 4000) { + tagList.add(GT_LanguageManager.getTranslation("over")); + } + } + tagList.add(GT_LanguageManager.getTranslation("pro1") + " " + partProcessing + " " + GT_LanguageManager.getTranslation("pro3")); + tagList.add(GT_LanguageManager.getTranslation("pro2") + ": " + partProcessingUsed + " " + GT_LanguageManager.getTranslation("pro3")); + if (type == 0 && electrolyzerProd > 0) { + tagList.add(GT_LanguageManager.getTranslation("elec1") + " " + electrolyzerProd / 2 + GT_LanguageManager.getTranslation("elec2")); + } + if (tankCap > 0) { + if (fluid != null) { + tagList.add(GT_LanguageManager.getTranslation("tank") + ": " + fluid.getLocalizedName() + " " + fluid.amount + "L (" + tankCap + ")"); + } else { + tagList.add(GT_LanguageManager.getTranslation("tankcap") + ": " + tankCap); + } + } + } + tagList.add(GT_LanguageManager.getTranslation("weight") + ": " + weight + tmp2); + tagList.add(GT_LanguageManager.getTranslation("phydef") + ": " + (Math.round(physicalDef * 1000) / 10.0) + "%"); + tagList.add(GT_LanguageManager.getTranslation("prodef") + ": " + (Math.round(projectileDef * 1000) / 10.0) + "%"); + tagList.add(GT_LanguageManager.getTranslation("firedef") + ": " + (Math.round(fireDef * 1000) / 10.0) + "%"); + tagList.add(GT_LanguageManager.getTranslation("magdef") + ": " + (Math.round(magicDef * 1000) / 10.0) + "%"); + tagList.add(GT_LanguageManager.getTranslation("expdef") + ": " + (Math.round(explosionDef * 1000) / 10.0) + "%"); + if (fallDef > 0 && type == 3) { + tagList.add(GT_LanguageManager.getTranslation("abs1") + " " + fallDef + GT_LanguageManager.getTranslation("abs2")); + } + if (thorns > 0) { + tagList.add(GT_LanguageManager.getTranslation("thorns") + ": " + (int) thorns); + } + if (magnet > 0) { + tagList.add(GT_LanguageManager.getTranslation("magnet") + ": " + magnet + "m"); + } + if (fullRadiationDef) { + tagList.add(GT_LanguageManager.getTranslation("radim")); + } else { + if (radiationDef > 0.01d) { + tagList.add(GT_LanguageManager.getTranslation("raddef") + ": " + (Math.round(radiationDef * 1000) / 10.0) + "%"); + } + } + info = tagList; + } + + public void armorPartsEquipped(EntityPlayer aPlayer) { + helmet = null; + chestplate = null; + leggings = null; + boots = null; + for (int i = 1; i < 5; i++) { + ItemStack stack = aPlayer.getEquipmentInSlot(i); + if (stack != null && stack.getItem() instanceof ModularArmor_Item) { + ModularArmor_Item tmp = (ModularArmor_Item) stack.getItem(); + ContainerModularArmor tmp2 = new ContainerBasicArmor(aPlayer, new InventoryArmor(ModularArmor_Item.class, stack)); + if ((this.type + i) == 4) { + fluid = ArmorCalculation.getFluid(tmp2.mInvArmor.parts, tankCap); + } + if (maxCharge > 0 && charge < maxCharge) { + int loaded = ArmorCalculation.deChargeBatterys(tmp2.mInvArmor.parts, maxCharge - charge); + charge = charge + loaded; + tmp.data.partsCharge -= loaded; + + } + switch (tmp.armorType) { + case 0: + helmet = tmp.data; + break; + case 1: + chestplate = tmp.data; + break; + case 2: + leggings = tmp.data; + break; + case 3: + boots = tmp.data; + break; + default: + break; + } + writeToNBT(stack.getTagCompound()); + } + } + if (helmet != null && chestplate != null && leggings != null && boots != null) { + fullArmor = true; + } else { + fullArmor = false; + } + fullRadiationDef = fullArmor && helmet.radiationDef > 0.9f && chestplate.radiationDef > 0.9f && leggings.radiationDef > 0.9f && boots.radiationDef > 0.9f; + fullElectricDef = fullArmor && helmet.electricDef > 0.9f && chestplate.electricDef > 0.9f && leggings.electricDef > 0.9f && boots.electricDef > 0.9f; + magnet = 0; + thorns = 0; + processingPower = 0; + processingPowerUsed = 0; + if (helmet != null) { + magnet += helmet.magnetSingle; + thorns += helmet.thornsSingle; + processingPower += helmet.partProcessing; + processingPowerUsed += helmet.partProcessingUsed; + } + if (chestplate != null) { + magnet += chestplate.magnetSingle; + thorns += chestplate.thornsSingle; + processingPower += chestplate.partProcessing; + processingPowerUsed += chestplate.partProcessingUsed; + } + if (leggings != null) { + magnet += leggings.magnetSingle; + thorns += leggings.thornsSingle; + processingPower += leggings.partProcessing; + processingPowerUsed += leggings.partProcessingUsed; + } + if (boots != null) { + magnet += boots.magnetSingle; + thorns += boots.thornsSingle; + processingPower += boots.partProcessing; + processingPowerUsed += boots.partProcessingUsed; + } + isTopItem = false; + if (type == 0) { + isTopItem = true; + } else if (helmet == null && type == 1) { + isTopItem = true; + } else if (helmet == null && chestplate == null && type == 2) { + isTopItem = true; + } else if (helmet == null && chestplate == null && leggings == null && type == 3) { + isTopItem = true; + } + if (helmet != null) { + maxWeight = helmet.weight; + } + if (chestplate != null) { + maxWeight += chestplate.weight; + } + if (leggings != null) { + maxWeight += leggings.weight; + } + if (boots != null) { + maxWeight += boots.weight; + } + } + + public double getBaseAbsorptionRatio() { + switch (this.type) { + case 0: + return 0.15; + case 1: + return 0.40; + case 2: + return 0.30; + case 3: + return 0.15; + default: + return 0.00; + } + } +} diff --git a/src/main/java/gregtech/common/items/armor/ContainerBasicArmor.java b/src/main/java/gregtech/common/items/armor/ContainerBasicArmor.java new file mode 100644 index 0000000000..108d813707 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ContainerBasicArmor.java @@ -0,0 +1,48 @@ +package gregtech.common.items.armor; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerBasicArmor extends ContainerModularArmor { + + public ContainerBasicArmor(EntityPlayer player, InventoryArmor aInvArmor) { + super(player, aInvArmor); + } + + public void addSlots(InventoryPlayer aInventoryPlayer) { + addSlotToContainer(new Slot(mInvArmor, 0, 118, 6)); + addSlotToContainer(new Slot(mInvArmor, 1, 136, 6)); + addSlotToContainer(new Slot(mInvArmor, 2, 154, 6)); + addSlotToContainer(new Slot(mInvArmor, 3, 118, 24)); + addSlotToContainer(new Slot(mInvArmor, 4, 136, 24)); + addSlotToContainer(new Slot(mInvArmor, 5, 154, 24)); + addSlotToContainer(new Slot(mInvArmor, 6, 118, 42)); + addSlotToContainer(new Slot(mInvArmor, 7, 136, 42)); + addSlotToContainer(new Slot(mInvArmor, 8, 154, 42)); + + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 9; j++) { + addSlotToContainer(new Slot(aInventoryPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18)); + } + } + + for (int i = 0; i < 9; i++) { + ItemStack stackInSlot = aInventoryPlayer.getStackInSlot(i); + if(isIdenticalItem(mInvArmor.parent,stackInSlot)){ + addSlotToContainer(new SlotLocked(aInventoryPlayer,i,8+i*18,142)); + }else{ + addSlotToContainer(new Slot(aInventoryPlayer, i, 8 + i * 18, 142));} + } + } + + public int getSlotCount() { + return 9; + } + + public int getShiftClickSlotCount() { + return 9; + } + +} diff --git a/src/main/java/gregtech/common/items/armor/ContainerElectricArmor1.java b/src/main/java/gregtech/common/items/armor/ContainerElectricArmor1.java new file mode 100644 index 0000000000..063807275c --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ContainerElectricArmor1.java @@ -0,0 +1,53 @@ +package gregtech.common.items.armor; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerElectricArmor1 extends ContainerBasicArmor { + + public ContainerElectricArmor1(EntityPlayer player, InventoryArmor aInvArmor) { + super(player, aInvArmor); + } + + public void addSlots(InventoryPlayer aInventoryPlayer) { + addSlotToContainer(new Slot(mInvArmor, 0, 118, 6)); + addSlotToContainer(new Slot(mInvArmor, 1, 136, 6)); + addSlotToContainer(new Slot(mInvArmor, 2, 154, 6)); + addSlotToContainer(new Slot(mInvArmor, 3, 118, 24)); + addSlotToContainer(new Slot(mInvArmor, 4, 136, 24)); + addSlotToContainer(new Slot(mInvArmor, 5, 154, 24)); + addSlotToContainer(new Slot(mInvArmor, 6, 118, 42)); + addSlotToContainer(new Slot(mInvArmor, 7, 136, 42)); + addSlotToContainer(new Slot(mInvArmor, 8, 154, 42)); + addSlotToContainer(new Slot(mInvArmor, 9, 118, 60)); + addSlotToContainer(new Slot(mInvArmor, 10, 136, 60)); + addSlotToContainer(new Slot(mInvArmor, 11, 154, 60)); + + addSlotToContainer(new SlotFluid(mInvArmor,12,94,32)); + + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 9; j++) { + addSlotToContainer(new Slot(aInventoryPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18)); + } + } + + for (int i = 0; i < 9; i++) { + ItemStack stackInSlot = aInventoryPlayer.getStackInSlot(i); + if(isIdenticalItem(mInvArmor.parent,stackInSlot)){ + addSlotToContainer(new SlotLocked(aInventoryPlayer,i,8+i*18,142)); + }else{ + addSlotToContainer(new Slot(aInventoryPlayer, i, 8 + i * 18, 142));} + } + } + + public int getSlotCount() { + return 12; + } + + public int getShiftClickSlotCount() { + return 12; + } + +} diff --git a/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java b/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java new file mode 100644 index 0000000000..88f1a71599 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java @@ -0,0 +1,171 @@ +package gregtech.common.items.armor; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +public abstract class ContainerModularArmor extends Container { + + public InventoryArmor mInvArmor; + + public ContainerModularArmor(EntityPlayer player, InventoryArmor aInvArmor) { + this.mInvArmor = aInvArmor; + addSlots(player.inventory); + } + + public ArmorData getData(EntityPlayer aPlayer){ + + + + return null; + } + + @Override + public boolean canInteractWith(EntityPlayer aPlayer) { + return true; + } + + public abstract void addSlots(InventoryPlayer aInventoryPlayer); + + public abstract int getSlotCount(); + + public abstract int getShiftClickSlotCount(); + + public void saveInventory(EntityPlayer entityplayer) { + mInvArmor.onGuiSaved(entityplayer); + } + + @Override + public void onContainerClosed(EntityPlayer player) { + super.onContainerClosed(player); + if (!player.worldObj.isRemote) { + saveInventory(player); + } + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer player, int slotIndex) { + if (player == null) { + return null; + } + + ItemStack originalStack = null; + Slot slot = (Slot) inventorySlots.get(slotIndex); + int numSlots = inventorySlots.size(); + if (slot != null && slot.getHasStack()) { + ItemStack stackInSlot = slot.getStack(); + originalStack = stackInSlot.copy(); + if (slotIndex >= numSlots - 9 * 4 && tryShiftItem(stackInSlot, numSlots)) { + } else if (slotIndex >= numSlots - 9 * 4 && slotIndex < numSlots - 9) { + if (!shiftItemStack(stackInSlot, numSlots - 9, numSlots)) { + return null; + } + } else if (slotIndex >= numSlots - 9 && slotIndex < numSlots) { + if (!shiftItemStack(stackInSlot, numSlots - 9 * 4, numSlots - 9)) { + return null; + } + } else if (!shiftItemStack(stackInSlot, numSlots - 9 * 4, numSlots)) { + return null; + } + slot.onSlotChange(stackInSlot, originalStack); + if (stackInSlot.stackSize <= 0) { + slot.putStack(null); + } else { + slot.onSlotChanged(); + } + if (stackInSlot.stackSize == originalStack.stackSize) { + return null; + } + slot.onPickupFromSlot(player, stackInSlot); + } + return originalStack; + } + + private boolean tryShiftItem(ItemStack stackToShift, int numSlots) { + for (int machineIndex = 0; machineIndex < numSlots - 9 * 4; machineIndex++) { + Slot slot = (Slot) inventorySlots.get(machineIndex); + if (slot.getHasStack()) { + continue; + } + if(slot instanceof SlotLocked){ + continue; + } + if(slot instanceof SlotFluid){ + continue; + } + + if (!slot.isItemValid(stackToShift)) { + continue; + } + if (shiftItemStack(stackToShift, machineIndex, machineIndex + 1)) { + return true; + } + } + return false; + } + + protected boolean shiftItemStack(ItemStack stackToShift, int start, int end) { + boolean changed = false; + if (stackToShift.isStackable()) { + for (int slotIndex = start; stackToShift.stackSize > 0 && slotIndex < end; slotIndex++) { + Slot slot = (Slot) inventorySlots.get(slotIndex); + ItemStack stackInSlot = slot.getStack(); + if (stackInSlot != null && isIdenticalItem(stackInSlot, stackToShift)) { + int resultingStackSize = stackInSlot.stackSize + stackToShift.stackSize; + int max = Math.min(stackToShift.getMaxStackSize(), slot.getSlotStackLimit()); + if (resultingStackSize <= max) { + stackToShift.stackSize = 0; + stackInSlot.stackSize = resultingStackSize; + slot.onSlotChanged(); + changed = true; + } else if (stackInSlot.stackSize < max) { + stackToShift.stackSize -= max - stackInSlot.stackSize; + stackInSlot.stackSize = max; + slot.onSlotChanged(); + changed = true; + } + } + } + } + if (stackToShift.stackSize > 0) { + for (int slotIndex = start; stackToShift.stackSize > 0 && slotIndex < end; slotIndex++) { + Slot slot = (Slot) inventorySlots.get(slotIndex); + ItemStack stackInSlot = slot.getStack(); + if (stackInSlot == null) { + int max = Math.min(stackToShift.getMaxStackSize(), slot.getSlotStackLimit()); + stackInSlot = stackToShift.copy(); + stackInSlot.stackSize = Math.min(stackToShift.stackSize, max); + stackToShift.stackSize -= stackInSlot.stackSize; + slot.putStack(stackInSlot); + slot.onSlotChanged(); + changed = true; + } + } + } + return changed; + } + + public static boolean isIdenticalItem(ItemStack lhs, ItemStack rhs) { + if (lhs == null || rhs == null) { + return false; + } + + if (lhs.getItem() != rhs.getItem()) { + return false; + } + + if (lhs.getItemDamage() != OreDictionary.WILDCARD_VALUE) { + if (lhs.getItemDamage() != rhs.getItemDamage()) { + return false; + } + } + + return ItemStack.areItemStackTagsEqual(lhs, rhs); + } + +} diff --git a/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java b/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java new file mode 100644 index 0000000000..5d8bfd82f0 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java @@ -0,0 +1,42 @@ +package gregtech.common.items.armor; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidContainerItem; + +public class ElectricModularArmor1 extends ModularArmor_Item{ + + public boolean mChargeProvider=false; + + public ElectricModularArmor1(int aArmorIndex, int aType, String name,int gui) { + super(aArmorIndex, aType, name,gui); + } + + public boolean canProvideEnergy(ItemStack aStack) { + return mChargeProvider; + } + + public Item getChargedItem(ItemStack aStack) { + return this; + } + + public Item getEmptyItem(ItemStack aStack) { + return this; + } + + public int getMaxCharge(ItemStack aStack) { + return data.charge; + } + + public int getTier(ItemStack aStack) { + return 2; + } + + public int getTransferLimit(ItemStack aStack) { + return openGuiNr==1?128:512; + } +} diff --git a/src/main/java/gregtech/common/items/armor/FluidSync.java b/src/main/java/gregtech/common/items/armor/FluidSync.java new file mode 100644 index 0000000000..70ee268188 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/FluidSync.java @@ -0,0 +1,67 @@ +package gregtech.common.items.armor; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.WorldServer; +import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.google.common.base.Charsets; +import com.google.common.io.ByteArrayDataInput; +import com.google.common.io.ByteArrayDataOutput; +import com.google.common.io.ByteStreams; + +public class FluidSync /**implements IPacket**/ { + String playerName; + int amount; + String fluid; + +// @Override + public byte getPacketID() { + return 0; + } + + public FluidSync(String player, int amount, String fluid) { + this.playerName = player; + this.amount = amount; + this.fluid = fluid.toLowerCase(); + } + +// @Override + public ByteArrayDataOutput encode() { + ByteArrayDataOutput rOut = ByteStreams.newDataOutput(4); + rOut.writeUTF(playerName + ";" + amount + ";" + fluid); + return rOut; + } + +// @Override +// public IPacket decode(ByteArrayDataInput aData) { +// String tmp = aData.readUTF(); +// String[] tmp2 = tmp.split(";"); +// return new FluidSync(tmp2[0], Integer.parseInt(tmp2[1]), tmp2[2].toLowerCase()); +// } +// +// @Override +// public void process(IBlockAccess aWorld, INetworkHandler aNetworkHandler) { +// WorldServer[] worlds = DimensionManager.getWorlds(); +// EntityPlayer tmp; +// for (int i = 0; i < worlds.length; i++) { +// tmp = worlds[i].getPlayerEntityByName(playerName); +// if (tmp != null) { +// try { +// if (fluid.equals("null")) { +// tmp.openContainer.getSlot(12).putStack(null); +// } else { +// tmp.openContainer.getSlot(12).putStack(UT.Fluids.display(new FluidStack(FluidRegistry.getFluid(fluid), amount), true)); +// } +// tmp.openContainer.detectAndSendChanges(); +// } catch (Exception e) { +// e.printStackTrace(); +// } +// +// } +// } +// } + +} diff --git a/src/main/java/gregtech/common/items/armor/FluidSync2.java b/src/main/java/gregtech/common/items/armor/FluidSync2.java new file mode 100644 index 0000000000..de801aad8a --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/FluidSync2.java @@ -0,0 +1,67 @@ +package gregtech.common.items.armor; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.WorldServer; +import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.google.common.base.Charsets; +import com.google.common.io.ByteArrayDataInput; +import com.google.common.io.ByteArrayDataOutput; +import com.google.common.io.ByteStreams; + +public class FluidSync2 /**implements IPacket**/ { + String playerName; + +// @Override + public byte getPacketID() { + return 1; + } + + public FluidSync2(String player) { + this.playerName = player; + } + +// @Override + public ByteArrayDataOutput encode() { + ByteArrayDataOutput rOut = ByteStreams.newDataOutput(4); + rOut.writeUTF(playerName); + return rOut; + } + +// @Override +// public IPacket decode(ByteArrayDataInput aData) { +// return new FluidSync2(aData.readUTF()); +// } +// +// @Override +// public void process(IBlockAccess aWorld, INetworkHandler aNetworkHandler) { +// WorldServer[] worlds = DimensionManager.getWorlds(); +// EntityPlayer tmp; +// for (int i = 0; i < worlds.length; i++) { +// tmp = worlds[i].getPlayerEntityByName(playerName); +// if (tmp != null) { +// try { +// ItemStack tmp2 = tmp.inventory.getItemStack(); +// ItemStack tmp3 = UT.Fluids.getContainerForFilledItem(tmp2, true); +// if (tmp2.stackSize <= 1) { +// tmp2 = null; +// } else { +// tmp2.stackSize--; +// } +// tmp.inventory.setItemStack(tmp2); +// if(tmp3!=null){ +// tmp3.stackSize=1; +// tmp.inventory.addItemStackToInventory(tmp3);} +// } catch (Exception e) { +// e.printStackTrace(); +// } +// +// } +// } +// } + +} diff --git a/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java b/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java new file mode 100644 index 0000000000..136630124f --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java @@ -0,0 +1,310 @@ +package gregtech.common.items.armor; + +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.text.NumberFormat; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidContainerItem; + +@SideOnly(Side.CLIENT) +public class GuiElectricArmor1 extends GuiContainer { + ContainerModularArmor cont; + EntityPlayer player; + private int tab; + + public GuiElectricArmor1(ContainerModularArmor containerModularArmor, EntityPlayer aPlayer) { + super(containerModularArmor); + player = aPlayer; + cont = containerModularArmor; + tab = 0; + } + + public String seperateNumber(long number){ + DecimalFormat formatter = (DecimalFormat) NumberFormat.getInstance(Locale.US); + DecimalFormatSymbols symbols = formatter.getDecimalFormatSymbols(); + symbols.setGroupingSeparator(' '); + return formatter.format(number); + } + + @Override + protected void drawGuiContainerForegroundLayer(int x, int y) { + int xStart = (width - xSize) / 2; + int yStart = (height - ySize) / 2; + int x2 = x - xStart; + int y2 = y - yStart; + drawTooltip(x2, y2 + 5); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) { + GL11.glColor4f(1F, 1F, 1F, 1F); + this.mc.getTextureManager().bindTexture(new ResourceLocation("gregtech", "textures/gui/armorgui3x4.png")); + int xStart = (width - xSize) / 2; + int yStart = (height - ySize) / 2; + //Draw background + drawTexturedModalRect(xStart, yStart, 0, 0, xSize, ySize); + //Draw active arrows + drawTexturedModalRect(xStart + 10, yStart + 70, 219, 11, 14, 5); + //Draw active armor symbol + switch (cont.mInvArmor.data.type) { + case 0: + drawTexturedModalRect(xStart + 73, yStart + 68, 177, 10, 10, 9); + break; + case 1: + drawTexturedModalRect(xStart + 83, yStart + 68, 187, 10, 10, 9); + break; + case 2: + drawTexturedModalRect(xStart + 93, yStart + 68, 197, 10, 10, 9); + break; + case 3: + drawTexturedModalRect(xStart + 103, yStart + 68, 207, 10, 10, 9); + break; + default: + break; + } + //Draw active tab + switch(tab){ + case 0: + break; + case 1: + drawTexturedModalRect(xStart + 7, yStart + 14, 2, 167, 104, 54); + break; + case 2: + drawTexturedModalRect(xStart + 7, yStart + 14, 107, 167, 104, 54); + break; + default: + break; + } + + if(cont.mInvArmor.data.tankCap>0){ + drawTexturedModalRect(xStart + 94, yStart + 32, 231, 69, 16, 34); + } + + int bar = (int) Math.floor(18 * (cont.mInvArmor.data.weight/(float)1000)); + drawTexturedModalRect(xStart + 15, yStart + 7, 217, 26, bar, 5); + drawTexturedModalRect(xStart + bar + 15, yStart + 7, 197+bar, 26, 18-bar, 5); + + if(tab==0){ + //processing power bar + bar = Math.min((int) Math.floor(52 * ((float)cont.mInvArmor.data.processingPowerUsed/(float)cont.mInvArmor.data.processingPower)),52); + drawTexturedModalRect(xStart + 17, yStart + 17, 177, 146, bar, 5); + drawTexturedModalRect(xStart + bar + 17, yStart + 17, 177+bar, 139, 52-bar, 5); + }else if(tab==1){ + + }else{ + //Def tab values + if(cont.mInvArmor.data.physicalDef>0)drawTexturedModalRect(xStart + 30, yStart + 20, 186, 33, 7, 7); + drawBars(31, 20, cont.mInvArmor.data.physicalDef); + if(cont.mInvArmor.data.projectileDef>0)drawTexturedModalRect(xStart + 30, yStart + 29, 186, 42, 7, 7); + drawBars(31, 29, cont.mInvArmor.data.projectileDef); + if(cont.mInvArmor.data.fireDef>0)drawTexturedModalRect(xStart + 30, yStart + 38, 186, 51, 7, 7); + drawBars(31, 38, cont.mInvArmor.data.fireDef); + if(cont.mInvArmor.data.magicDef>0)drawTexturedModalRect(xStart + 30, yStart + 47, 186, 60, 7, 7); + drawBars(31, 47, cont.mInvArmor.data.magicDef); + if(cont.mInvArmor.data.explosionDef>0)drawTexturedModalRect(xStart + 30, yStart + 56, 186, 69, 7, 7); + drawBars(31, 56, cont.mInvArmor.data.explosionDef); + if(cont.mInvArmor.data.radiationDef>0)drawTexturedModalRect(xStart + 61, yStart + 20, 186, 87, 7, 7); + drawBars(62, 20, cont.mInvArmor.data.radiationDef); + if(cont.mInvArmor.data.electricDef>0)drawTexturedModalRect(xStart + 61, yStart + 29, 186, 96, 7, 7); + drawBars(62, 29, cont.mInvArmor.data.electricDef); + if(cont.mInvArmor.data.witherDef>0)drawTexturedModalRect(xStart + 61, yStart + 38, 186, 105, 7, 7); + drawBars(62, 38, cont.mInvArmor.data.witherDef); + if(cont.mInvArmor.data.fallDef>0)drawTexturedModalRect(xStart + 61, yStart + 47, 186, 114, 7, 7); + if(cont.mInvArmor.data.thorns>0)drawTexturedModalRect(xStart + 61, yStart + 56, 186, 123, 7, 7); + if(cont.mInvArmor.data.magnet>0)drawTexturedModalRect(xStart + 70, yStart + 56, 186, 78, 7, 7); + } + + + } + + protected void mouseClicked(int mouseX, int mouseY, int mouseBtn) { + int xStart = mouseX-((width - xSize) / 2); + int yStart = mouseY-((height - ySize) / 2); + if(yStart>68&&yStart<77){ + if(xStart>18&&xStart<26){ + tab++; + }else if(xStart>8&&xStart<17){ + tab--; + } + if(tab>2){tab=0;} + if(tab<0){tab=2;} + if(xStart>72&&xStart<112){ + if(xStart>72&&xStart<81&&cont.mInvArmor.data.helmet!=null){cont.mInvArmor.data.helmet.openGui=true;player.closeScreen();} + if(xStart>82&&xStart<91&&cont.mInvArmor.data.chestplate!=null){cont.mInvArmor.data.chestplate.openGui=true;player.closeScreen();} + if(xStart>92&&xStart<101&&cont.mInvArmor.data.leggings!=null){cont.mInvArmor.data.leggings.openGui=true;player.closeScreen();} + if(xStart>102&&xStart<112&&cont.mInvArmor.data.boots!=null){cont.mInvArmor.data.boots.openGui=true;player.closeScreen();} + } + } +// Slot slot = getSlotAtPosition(mouseX, mouseY); +// if (slot != null && slot instanceof SlotFluid && player != null) { +// ItemStack tmp = player.inventory.getItemStack(); +// if (tmp == null) { +// GTExtras.NET.sendToServer(new FluidSync(player.getCommandSenderName(), 0, "null")); +// } +// if (tmp != null && tmp.getItem() instanceof IFluidContainerItem) { +// FluidStack tmp2 = ((IFluidContainerItem) tmp.getItem()).getFluid(tmp); +// if (!slot.getHasStack() && tmp2 != null) { +// slot.putStack(UT.Fluids.display(tmp2, true)); +// GTExtras.NET.sendToServer(new FluidSync(player.getCommandSenderName(), tmp2.amount, UT.Fluids.name(tmp2, false))); +// ItemStack tmp4 = UT.Fluids.getContainerForFilledItem(tmp, true); +// tmp4.stackSize = 1; +// if (tmp.stackSize > 1) { +// player.inventory.addItemStackToInventory(tmp4); +// tmp.stackSize--; +// player.inventory.setItemStack(tmp); +// GTExtras.NET.sendToServer(new FluidSync2(player.getCommandSenderName())); +// } else { +// player.inventory.setItemStack(null); +// player.inventory.addItemStackToInventory(tmp4); +// GTExtras.NET.sendToServer(new FluidSync2(player.getCommandSenderName())); +// } +// +// } else if (slot.getHasStack() && tmp2 != null) { +// Item fluidSlot = slot.getStack().getItem(); +// if (fluidSlot.getDamage(slot.getStack()) == tmp2.getFluidID()) { +// NBTTagCompound nbt = slot.getStack().getTagCompound(); +// if (nbt != null) { +// tmp2.amount += nbt.getLong("mFluidDisplayAmount"); +// ItemStack tmp3 = player.inventory.getItemStack(); +// if (tmp3.stackSize <= 1) { +// tmp3 = null; +// } else { +// tmp3.stackSize--; +// } +// player.inventory.setItemStack(tmp3); +// GTExtras.NET.sendToServer(new FluidSync2(player.getCommandSenderName())); +// slot.putStack(UT.Fluids.display(tmp2, true)); +// GTExtras.NET.sendToServer(new FluidSync(player.getCommandSenderName(), tmp2.amount, UT.Fluids.name(tmp2, false))); +// } +// } +// } +// } +// } + super.mouseClicked(mouseX, mouseY, mouseBtn); + } + + protected void drawTooltip(int x, int y) { + List list = new ArrayList(); + //General tooltips + if(x>=7&&y>=11&&x<=33&&y<=17){ + list.add(GT_LanguageManager.getTranslation("weight") + ": " + cont.mInvArmor.data.weight); + list.add("Total Weight: "+cont.mInvArmor.data.maxWeight); + if (cont.mInvArmor.data.weight > 1000) + list.add("Too Heavy!"); + } + if(x>=56&&y>=11&&x<=112&&y<=17){ + list.add("Stored Energy: "+seperateNumber(cont.mInvArmor.data.charge)+" EU"); + } + if(y>74&&y<83){ + if(x>8&&x<17){ + list.add("Previous Page"); + }else if(x>18&&x<27){ + list.add("Next Page"); + }else if(x>72&&x<80){ + list.add("Helmet"); + }else if(x>81&&x<90){ + list.add("Chestplate"); + }else if(x>91&&x<100){ + list.add("Leggings"); + }else if(x>101&&x<110){ + list.add("Boots"); + } + } + if(tab==0){ + if(x>=93&&y>=36&&x<=110&&y<=71){list.add("Tank Capacity: "+cont.mInvArmor.data.tankCap+"L"); + } + if(x>=7&&y>=22&&x<=70&&y<=28){list.add("Processing Power Provided: "+cont.mInvArmor.data.processingPower); + list.add("Processing Power Used: "+cont.mInvArmor.data.processingPowerUsed); + } + }else if(tab==1){ + + }else{ + if (x >= 28 && x <= 58) { + if (y >= 25 && y <= 32) { + list.add(GT_LanguageManager.getTranslation("phydef") + ": " + (Math.round(cont.mInvArmor.data.physicalDef * 1000) / 10.0) + "%"); + } else if (y >= 33 && y <= 41) { + list.add(GT_LanguageManager.getTranslation("prodef") + ": " + (Math.round(cont.mInvArmor.data.projectileDef * 1000) / 10.0) + "%"); + } else if (y >= 42 && y <= 50) { + list.add(GT_LanguageManager.getTranslation("firedef") + ": " + (Math.round(cont.mInvArmor.data.fireDef * 1000) / 10.0) + "%"); + } else if (y >= 51 && y <= 59) { + list.add(GT_LanguageManager.getTranslation("magdef") + ": " + (Math.round(cont.mInvArmor.data.magicDef * 1000) / 10.0) + "%"); + } else if (y >= 60 && y <= 68) { + list.add(GT_LanguageManager.getTranslation("expdef") + ": " + (Math.round(cont.mInvArmor.data.explosionDef * 1000) / 10.0) + "%"); + } + } else if (x >= 59 && x <= 90) { + if (y >= 25 && y <= 32) { + list.add(GT_LanguageManager.getTranslation("raddef") + ": " + (Math.round(cont.mInvArmor.data.radiationDef * 1000) / 10.0) + "%"); + if(cont.mInvArmor.data.fullRadiationDef){ + list.add("Radiation Immunity");} + } else if (y >= 33 && y <= 41) { + list.add(GT_LanguageManager.getTranslation("eledef") + ": " + (Math.round(cont.mInvArmor.data.electricDef * 1000) / 10.0) + "%"); + if(cont.mInvArmor.data.fullElectricDef){ + list.add("Electric Immunity");} + } else if (y >= 42 && y <= 50) { + list.add(GT_LanguageManager.getTranslation("whidef") + ": " + (Math.round(cont.mInvArmor.data.witherDef * 1000) / 10.0) + "%"); + } else if (y >= 51 && y <= 59) { + if(cont.mInvArmor.data.type!=3){ + list.add("Fall Damage absorbtion"); + list.add("Only for Boots"); + }else{ + list.add(GT_LanguageManager.getTranslation("abs1") + " " + (int) Math.round(cont.mInvArmor.data.fallDef) + GT_LanguageManager.getTranslation("abs2"));} + } else if (y >= 60 && y <= 68) { + if(x<69){ + list.add(GT_LanguageManager.getTranslation("thorns") + ": " + (int) Math.round(cont.mInvArmor.data.thornsSingle) + " Dmg"); + list.add("Total "+GT_LanguageManager.getTranslation("thorns") + ": " + (int) Math.round(cont.mInvArmor.data.thorns) + " Dmg"); + }else{ + list.add(GT_LanguageManager.getTranslation("magnet") + ": " + cont.mInvArmor.data.magnetSingle + " m"); + list.add("Total "+GT_LanguageManager.getTranslation("magnet") + ": " + cont.mInvArmor.data.magnet + " m");} + } + } + } + if (!list.isEmpty()) + drawHoveringText(list, x, y, fontRendererObj); + } + + public void drawBars(int x, int y, float value) { + + int bar = (int) Math.floor(18 * value); + int xStart = (width - xSize) / 2; + int yStart = (height - ySize) / 2; + xStart += 8; + yStart += 1; + drawTexturedModalRect(xStart + x, yStart + y, 217, 26, bar, 5); + drawTexturedModalRect(xStart+ bar + x, yStart + y, 197+bar, 26, 18-bar, 5); + } + + protected Slot getSlotAtPosition(int p_146975_1_, int p_146975_2_) { + for (int k = 0; k < cont.inventorySlots.size(); ++k) { + Slot slot = (Slot) cont.inventorySlots.get(k); + if (this.isMouseOverSlot(slot, p_146975_1_, p_146975_2_)) { + return slot; + } + } + return null; + } + + private boolean isMouseOverSlot(Slot p_146981_1_, int p_146981_2_, int p_146981_3_) { + return this.func_146978_c(p_146981_1_.xDisplayPosition, p_146981_1_.yDisplayPosition, 16, 16, p_146981_2_, p_146981_3_); + } +} diff --git a/src/main/java/gregtech/common/items/armor/GuiModularArmor.java b/src/main/java/gregtech/common/items/armor/GuiModularArmor.java new file mode 100644 index 0000000000..17fd84b2fb --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/GuiModularArmor.java @@ -0,0 +1,196 @@ +package gregtech.common.items.armor; + +import gregtech.api.util.GT_LanguageManager; + +import java.util.ArrayList; +import java.util.List; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.util.ResourceLocation; + +@SideOnly(Side.CLIENT) +public class GuiModularArmor extends GuiContainer { + ContainerModularArmor cont; + EntityPlayer player; + + public GuiModularArmor(ContainerModularArmor containerModularArmor,EntityPlayer aPlayer) { + super(containerModularArmor); + cont = containerModularArmor; + this.player = aPlayer; + } + + @Override + protected void drawGuiContainerForegroundLayer(int x, int y) { + int xStart = (width - xSize) / 2; + int yStart = (height - ySize) / 2; + int x2 = x - xStart; + int y2 = y - yStart; + drawTooltip(x2, y2 + 5); + } + + protected void drawTooltip(int x, int y) { + List list = new ArrayList(); + if (x >= 10 && x <= 17) { + if (y >= 20 && y <= 27) { + list.add(GT_LanguageManager.getTranslation("weight") + ": " + cont.mInvArmor.data.weight); + list.add("Total Weight: "+cont.mInvArmor.data.maxWeight); + if (cont.mInvArmor.data.weight > 1000) + list.add("Too Heavy!"); + } else if (y >= 29 && y <= 36) { + list.add(GT_LanguageManager.getTranslation("phydef") + ": " + (Math.round(cont.mInvArmor.data.physicalDef * 1000) / 10.0) + "%"); + } else if (y >= 38 && y <= 45) { + list.add(GT_LanguageManager.getTranslation("prodef") + ": " + (Math.round(cont.mInvArmor.data.projectileDef * 1000) / 10.0) + "%"); + } else if (y >= 47 && y <= 54) { + list.add(GT_LanguageManager.getTranslation("firedef") + ": " + (Math.round(cont.mInvArmor.data.fireDef * 1000) / 10.0) + "%"); + } else if (y >= 56 && y <= 63) { + list.add(GT_LanguageManager.getTranslation("magdef") + ": " + (Math.round(cont.mInvArmor.data.magicDef * 1000) / 10.0) + "%"); + } else if (y >= 65 && y <= 72) { + list.add(GT_LanguageManager.getTranslation("expdef") + ": " + (Math.round(cont.mInvArmor.data.explosionDef * 1000) / 10.0) + "%"); + } + } else if (x >= 59 && x <= 66) { + if (y >= 20 && y <= 27) { + list.add(GT_LanguageManager.getTranslation("thorns") + ": " + (int) Math.round(cont.mInvArmor.data.thornsSingle) + " Dmg"); + list.add("Total "+GT_LanguageManager.getTranslation("thorns") + ": " + (int) Math.round(cont.mInvArmor.data.thorns) + " Dmg"); + } else if (y >= 29 && y <= 36) { + list.add(GT_LanguageManager.getTranslation("magnet") + ": " + cont.mInvArmor.data.magnetSingle + " m"); + list.add("Total "+GT_LanguageManager.getTranslation("magnet") + ": " + cont.mInvArmor.data.magnet + " m"); + } else if (y >= 38 && y <= 45) { + list.add(GT_LanguageManager.getTranslation("raddef") + ": " + (Math.round(cont.mInvArmor.data.radiationDef * 1000) / 10.0) + "%"); + if(cont.mInvArmor.data.fullRadiationDef){ + list.add("Radiation Immunity");} + } else if (y >= 47 && y <= 54) { + list.add(GT_LanguageManager.getTranslation("eledef") + ": " + (Math.round(cont.mInvArmor.data.electricDef * 1000) / 10.0) + "%"); + if(cont.mInvArmor.data.fullElectricDef){ + list.add("Electric Immunity");} + } else if (y >= 56 && y <= 63) { + list.add(GT_LanguageManager.getTranslation("whidef") + ": " + (Math.round(cont.mInvArmor.data.witherDef * 1000) / 10.0) + "%"); + } else if (y >= 65 && y <= 72) { + if(cont.mInvArmor.data.type!=3){ + list.add("Fall Damage absorbtion"); + list.add("Only for Boots"); + }else{ + list.add(GT_LanguageManager.getTranslation("abs1") + " " + (int) Math.round(cont.mInvArmor.data.fallDef) + GT_LanguageManager.getTranslation("abs2"));} + } + } + if (!list.isEmpty()) + drawHoveringText(list, x, y, fontRendererObj); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) { + GL11.glColor4f(1F, 1F, 1F, 1F); + this.mc.getTextureManager().bindTexture(new ResourceLocation("gregtech", "textures/gui/armorgui3x3.png")); + int xStart = (width - xSize) / 2; + int yStart = (height - ySize) / 2; + drawTexturedModalRect(xStart, yStart, 0, 0, xSize, ySize); + + switch (cont.mInvArmor.data.type) { + case 0: + drawTexturedModalRect(xStart + 124, yStart + 67, 177, 10, 10, 9); + break; + case 1: + drawTexturedModalRect(xStart + 134, yStart + 67, 187, 10, 10, 9); + break; + case 2: + drawTexturedModalRect(xStart + 144, yStart + 67, 197, 10, 10, 9); + break; + case 3: + drawTexturedModalRect(xStart + 154, yStart + 67, 207, 10, 10, 9); + break; + default: + break; + } + + // Weight: 10, 15 =191, 20 + if(cont.mInvArmor.data.weight>0){ + drawTexturedModalRect(xStart + 10, yStart + 15, 191, 20, 7, 7); + } + // Physical Def: 10, 24 =191, 29 + if(cont.mInvArmor.data.physicalDef>0){ + drawTexturedModalRect(xStart + 10, yStart + 24, 191, 29, 7, 7); + } + // Projectile Def: 10, 33 =191, 38 + if(cont.mInvArmor.data.projectileDef>0){ + drawTexturedModalRect(xStart + 10, yStart + 33, 191, 38, 7, 7); + } + // Fire Def: 10, 42 =191, 47 + if(cont.mInvArmor.data.fireDef>0){ + drawTexturedModalRect(xStart + 10, yStart + 42, 191, 47, 7, 7); + } + // Magic Def: 10, 51 =191, 56 + if(cont.mInvArmor.data.magicDef>0){ + drawTexturedModalRect(xStart + 10, yStart + 51, 191, 56, 7, 7); + } + // Explosive Def: 10, 60 =191, 65 + if(cont.mInvArmor.data.explosionDef>0){ + drawTexturedModalRect(xStart + 10, yStart + 60, 191, 65, 7, 7); + } + // Thorns: 59, 15 =198, 20 + if(cont.mInvArmor.data.thorns>0){ + drawTexturedModalRect(xStart + 59, yStart + 15, 198, 20, 7, 7); + } + // Magnet: 59, 24 =198, 29 + if(cont.mInvArmor.data.magnetSingle>0){ + drawTexturedModalRect(xStart + 59, yStart + 24, 198, 29, 7, 7); + } + // Radiation Def: 59, 33 =198, 38 + if(cont.mInvArmor.data.radiationDef>0){ + drawTexturedModalRect(xStart + 59, yStart + 33, 198, 38, 7, 7); + } + // Electric Def: 59, 42 =198, 47 + if(cont.mInvArmor.data.electricDef>0){ + drawTexturedModalRect(xStart + 59, yStart + 42, 198, 47, 7, 7); + } + // Wither Def: 59, 51 =198, 56 + if(cont.mInvArmor.data.witherDef>0){ + drawTexturedModalRect(xStart + 59, yStart + 51, 198, 56, 7, 7); + } + // Fall Reduction: 59, 60 =198, 65 + if(cont.mInvArmor.data.fallDef>0){ + drawTexturedModalRect(xStart + 59, yStart + 60, 198, 65, 7, 7); + } + + drawBars(10, 24, cont.mInvArmor.data.physicalDef); + drawBars(10, 33, cont.mInvArmor.data.projectileDef); + drawBars(10, 42, cont.mInvArmor.data.fireDef); + drawBars(10, 51, cont.mInvArmor.data.magicDef); + drawBars(10, 60, cont.mInvArmor.data.explosionDef); + drawBars(59, 33, cont.mInvArmor.data.radiationDef); + drawBars(59, 42, cont.mInvArmor.data.electricDef); + drawBars(59, 51, cont.mInvArmor.data.witherDef); + } + + public void drawBars(int x, int y, float value) { + + int bar = (int) Math.floor(35 * value); + int xStart = (width - xSize) / 2; + int yStart = (height - ySize) / 2; + xStart += 8; + yStart += 1; + //drawRect(x + xStart, y + yStart, x + bar + xStart, y + 5 + yStart, 0x8000FF00); + //drawRect(x + bar + xStart, y + yStart, x + 36 + xStart, y + 5 + yStart, 0x80FF0000); + drawTexturedModalRect(xStart + x, yStart + y, 177, 78, bar, 5); + drawTexturedModalRect(xStart+ bar + x, yStart + y, 177, 73, 35-bar, 5); + } + + protected void mouseClicked(int mouseX, int mouseY, int mouseBtn) { + int xStart = mouseX-((width - xSize) / 2); + int yStart = mouseY-((height - ySize) / 2); + if(yStart>67&&yStart<77){ + if(xStart>124&&xStart<163){ + if(xStart>124&&xStart<133&&cont.mInvArmor.data.helmet!=null){cont.mInvArmor.data.helmet.openGui=true;player.closeScreen();} + if(xStart>134&&xStart<143&&cont.mInvArmor.data.chestplate!=null){cont.mInvArmor.data.chestplate.openGui=true;player.closeScreen();} + if(xStart>144&&xStart<153&&cont.mInvArmor.data.leggings!=null){cont.mInvArmor.data.leggings.openGui=true;player.closeScreen();} + if(xStart>154&&xStart<163&&cont.mInvArmor.data.boots!=null){cont.mInvArmor.data.boots.openGui=true;player.closeScreen();} + } + } + super.mouseClicked(mouseX, mouseY, mouseBtn); + } + +} diff --git a/src/main/java/gregtech/common/items/armor/InventoryArmor.java b/src/main/java/gregtech/common/items/armor/InventoryArmor.java new file mode 100644 index 0000000000..0d615ed732 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/InventoryArmor.java @@ -0,0 +1,235 @@ +package gregtech.common.items.armor; + +import gregtech.api.util.GT_Utility; + +import java.util.Random; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.oredict.OreDictionary; + +public class InventoryArmor implements IInventory { + + public ItemStack[] parts; + public ItemStack parent; +// float[] def = new float[32]; + public int maxCharge; + public int charge; + public ArmorData data; + + public InventoryArmor(Class class1, ItemStack currentEquippedItem) { + this.parts = new ItemStack[16]; + this.parent = currentEquippedItem; + setUID(false); + readFromNBT(currentEquippedItem.getTagCompound()); +// for (int i = 0; i < def.length; i++) { +// def[i] = 0.0f; +// } + if(currentEquippedItem.getItem() instanceof ModularArmor_Item){ + data = ((ModularArmor_Item)currentEquippedItem.getItem()).data; + } + + } + + @Override + public int getSizeInventory() { + return this.parts.length; + } + + @Override + public ItemStack getStackInSlot(int i) { + return parts[i]; + } + + @Override + public ItemStack decrStackSize(int i, int j) { + if (parts[i] == null) { + return null; + } + + ItemStack product; + if (parts[i].stackSize <= j) { + product = parts[i]; + parts[i] = null; +// def = ArmorCalculation.calculateArmor(parts); + data.calculateArmor(parts); + return product; + } else { + product = parts[i].splitStack(j); + if (parts[i].stackSize == 0) { + parts[i] = null; + } +// def = ArmorCalculation.calculateArmor(parts); + data.calculateArmor(parts); + return product; + } + } + + @Override + public ItemStack getStackInSlotOnClosing(int slot) { + if (parts[slot] == null) { + return null; + } + ItemStack toReturn = parts[slot]; + parts[slot] = null; + return toReturn; + } + + @Override + public void setInventorySlotContents(int i, ItemStack itemstack) { + parts[i] = itemstack; +// def = ArmorCalculation.calculateArmor(parts); + data.calculateArmor(parts); + } + + @Override + public String getInventoryName() { + return "container.armor"; + } + + @Override + public boolean hasCustomInventoryName() { + return true; + } + + @Override + public int getInventoryStackLimit() { + return 1; + } + + @Override + public void markDirty() { + } + + @Override + public boolean isUseableByPlayer(EntityPlayer p_70300_1_) { + return true; + } + + @Override + public void openInventory() { + } + + @Override + public void closeInventory() { + } + + @Override + public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) { + return true; + } + + public void onGuiSaved(EntityPlayer entityplayer) { + parent = findParentInInventory(entityplayer); + if (parent != null) { + save(); + } + } + + public void save() { + NBTTagCompound nbt = parent.getTagCompound(); + if (nbt == null) { + nbt = new NBTTagCompound(); + } + writeToNBT(nbt); + ModularArmor_Item tmp = (ModularArmor_Item) parent.getItem(); + tmp.data.calculateArmor(parts); + parent.setTagCompound(nbt); + } + + public void writeToNBT(NBTTagCompound nbt) { + NBTTagList nbttaglist = new NBTTagList(); + for (int i = 0; i < parts.length; i++) { + if (parts[i] != null) { + NBTTagCompound nbttagcompound1 = new NBTTagCompound(); + nbttagcompound1.setByte("Slot", (byte) i); + parts[i].writeToNBT(nbttagcompound1); + nbttaglist.appendTag(nbttagcompound1); + } + } + nbt.setTag("Items", nbttaglist); + } + + public ItemStack findParentInInventory(EntityPlayer player) { + for (int i = 0; i < player.inventory.getSizeInventory(); i++) { + ItemStack stack = player.inventory.getStackInSlot(i); + if (isIdenticalItem(stack, parent)) { + return stack; + } + } + return parent; + } + + public static boolean isIdenticalItem(ItemStack lhs, ItemStack rhs) { + if (lhs == null || rhs == null) { + return false; + } + + if (lhs.getItem() != rhs.getItem()) { + return false; + } + + if (lhs.getItemDamage() != OreDictionary.WILDCARD_VALUE) { + if (lhs.getItemDamage() != rhs.getItemDamage()) { + return false; + } + } + + return ItemStack.areItemStackTagsEqual(lhs, rhs); + } + + public void readFromNBT(NBTTagCompound nbt) { + if (nbt == null) { + return; + } + if (nbt.hasKey("Items")) { + NBTTagList nbttaglist = nbt.getTagList("Items", 10); + parts = 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 < parts.length) { + parts[byte0] = ItemStack.loadItemStackFromNBT(nbttagcompound1); + //parts[12]= UT.Fluids.display(UT.Fluids.water(1234), true); + } + } + } + + } + + protected void setUID(boolean override) { + if (parent.getTagCompound() == null) { + parent.setTagCompound(new NBTTagCompound()); + } + NBTTagCompound nbt = parent.getTagCompound(); + if (override || !nbt.hasKey("UID")) { + nbt.setInteger("UID", new Random().nextInt()); + } + } + + public static int getOccupiedSlotCount(ItemStack itemStack) { + NBTTagCompound nbt = itemStack.getTagCompound(); + if (nbt == null) { + return 0; + } + + int count = 0; + if (nbt.hasKey("Items")) { + NBTTagList nbttaglist = nbt.getTagList("Items", 10); + for (int i = 0; i < nbttaglist.tagCount(); i++) { + NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i); + ItemStack itemStack1 = ItemStack.loadItemStackFromNBT(nbttagcompound1); + if (itemStack1 != null && itemStack1.stackSize > 0) { + count++; + } + } + } + return count; + } + +} diff --git a/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java b/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java new file mode 100644 index 0000000000..c305278543 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java @@ -0,0 +1,447 @@ +package gregtech.common.items.armor; + +import gregtech.api.damagesources.GT_DamageSources; +import gregtech.api.enums.GT_Values; +import ic2.core.IC2; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Random; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.Optional; +import thaumcraft.api.IGoggles; +import thaumcraft.api.nodes.IRevealer; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.client.settings.GameSettings; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.Item; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemArmor.ArmorMaterial; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.DamageSource; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraftforge.common.ISpecialArmor; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.event.entity.living.LivingFallEvent; + +@Optional.InterfaceList(value = { @Optional.Interface(iface = "thaumcraft.api.IGoggles", modid = "Thaumcraft", striprefs = true), + @Optional.Interface(iface = "thaumcraft.api.nodes.IRevealer", modid = "Thaumcraft", striprefs = true) }) +public class ModularArmor_Item extends ItemArmor implements ISpecialArmor, IGoggles, IRevealer { + + public String mName; + public int timer = 160; + public Item repairMaterial; + public int openGuiNr; + public ArmorData data; + public int jumpticks; + + // public int maxEU; + + public ModularArmor_Item(int aArmorIndex, int aType, String name, int gui) { + super(ArmorMaterial.DIAMOND, aArmorIndex, aType); + MinecraftForge.EVENT_BUS.register(this); + setUnlocalizedName("gregtech:" + name); + GameRegistry.registerItem(this, name); + mName = name; + int mMaxDamage = (gui + 1) * 1024; + mMaxDamage *= getBaseAbsorptionRatio() * 2.5; + setMaxDamage(mMaxDamage); + repairMaterial = Items.leather; + openGuiNr = gui; + } + + @Override + public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + if (data == null) { + data = fillArmorData(aPlayer, aStack); + } + if (!aWorld.isRemote) { + aPlayer.openGui(GT_Values.GT, openGuiNr+1000, aWorld, (int) aPlayer.posX, (int) aPlayer.posY, (int) aPlayer.posZ); + } + return aStack; + } + + @Override + public ISpecialArmor.ArmorProperties getProperties(EntityLivingBase player, ItemStack armor, DamageSource source, double damage, int slot) { + if (data == null) { + data = fillArmorData((EntityPlayer) player, armor); + } + if (player != null && armor != null && source != null) { + double tmp = 0.0d; + if (source.isMagicDamage()) { + tmp = data.magicDef; + } else if (source == GT_DamageSources.getRadioactiveDamage()) { + tmp = data.radiationDef; + } else if (source == GT_DamageSources.getElectricDamage()) { + tmp = data.electricDef; + } else if (source == DamageSource.wither) { + tmp = data.witherDef; + } else if (source.isFireDamage() || source == GT_DamageSources.getHeatDamage()) { + tmp = data.fireDef; + } else if (source.isExplosion()) { + tmp = data.explosionDef; + } else if (source.isProjectile()) { + tmp = data.projectileDef; + } else { + tmp = data.physicalDef; + } + if (data.thorns > 0.1d && source != DamageSource.fall && source.getSourceOfDamage() != null) { + source.getSourceOfDamage().attackEntityFrom(new DamageSource("Thorns"), data.thorns); + } + + // fallDamage + if (source == DamageSource.fall) { + int fallDef = 0; + ItemStack stack = player.getEquipmentInSlot(1); + if (stack != null && stack.getItem() instanceof ModularArmor_Item) { + fallDef = (int) data.boots.fallDef; + } + tmp = 1.0d - (fallDef > damage ? 0.0d : (1.0d - tmp) * 0.5d); + } + if (tmp == 0.0d) { + tmp = data.physicalDef; + } + if (openGuiNr == 2) { + tmp = 1.0f - ((1.0f - tmp) / 2.0f); + } + return new ISpecialArmor.ArmorProperties(0, data.getBaseAbsorptionRatio() * tmp, 1000); + + } else { + return new ISpecialArmor.ArmorProperties(0, 0, 0); + } + } + + @Override + public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slot) { + if (data == null) { + data = fillArmorData(player, armor); + } + int tmp = (int) -Math.floor(-(data.getBaseAbsorptionRatio() * 20 * data.physicalDef)); + + return tmp; + } + + public void addInformation(ItemStack itemStack, EntityPlayer player, List info, boolean b) { + if (data == null) { + data = fillArmorData(player, itemStack); + } + if (data.info != null) + info.addAll(data.info); + } + + @Override + public void damageArmor(EntityLivingBase entity, ItemStack stack, DamageSource source, int damage, int slot) { + if (data == null) { + data = fillArmorData((EntityPlayer) entity, stack); + } + stack.damageItem(damage, entity); + ContainerModularArmor tmp = new ContainerBasicArmor((EntityPlayer) entity, new InventoryArmor(ModularArmor_Item.class, stack)); + if (stack.getItemDamage() > stack.getMaxDamage() / 2 && new Random().nextInt(100) < 5) { + tmp.getSlot(new Random().nextInt(tmp.getSlotCount())).decrStackSize(1); + tmp.mInvArmor.onGuiSaved((EntityPlayer) entity); + + /*public void eject(ItemStack drop) + { + if ((!IC2.platform.isSimulating()) || (drop == null)) { + return; + } + float f = 0.7F; + double d = this.worldObj.rand.nextFloat() * f + (1.0F - f) * 0.5D; + double d1 = this.worldObj.rand.nextFloat() * f + (1.0F - f) * 0.5D; + double d2 = this.worldObj.rand.nextFloat() * f + (1.0F - f) * 0.5D; + EntityItem entityitem = new EntityItem(this.worldObj, this.xCoord + d, this.yCoord + d1, this.zCoord + d2, drop); + entityitem.delayBeforeCanPickup = 10; + this.worldObj.spawnEntityInWorld(entityitem); + }*/ + + } + } + + @SubscribeEvent + public void onEntityLivingFallEvent(LivingFallEvent event) { + if (FMLCommonHandler.instance().getEffectiveSide().isServer() && event.entity instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) event.entity; + ItemStack armor = player.inventory.armorInventory[0]; + if (data != null && event != null && data.type == 3 && data.charge >= data.pistonEUusage && event.distance - 3 <= data.fallDef) { + event.setCanceled(true); + } else if (data != null && event != null && data.type == 3 && data.charge >= data.pistonEUusage) { + event.distance -= data.fallDef; + } + } + } + + @Override + public void onArmorTick(World aWorld, EntityPlayer aPlayer, ItemStack aStack) { + if (data == null) { + data = fillArmorData(aPlayer, aStack); + } + if (data.tooltipUpdate > 40) { + data.armorPartsEquipped(aPlayer); + data.tooltipUpdate = 0; + data.updateTooltip(); + } else { + data.tooltipUpdate++; + } + if (aPlayer.onGround) { + jumpticks = 4; + } else { + jumpticks--; + } + + // Breathing + if (data.type == 0 && aPlayer.getAir() < 100) { + int air = 0; + if (data.fluid.getUnlocalizedName().equals("fluid.oxygen") && data.fluid.amount >= 150) { + aPlayer.setAir(aPlayer.getAir() + 150); + air = 150; + } else if (data.fluid.getUnlocalizedName().equals("fluid.air") && data.fluid.amount >= 500) { + aPlayer.setAir(aPlayer.getAir() + 100); + air = 500; + } + if (air > 0) { + data.fluid.amount -= air; + ItemStack stack = aPlayer.getEquipmentInSlot(4); + if (stack != null && stack.getItem() instanceof ModularArmor_Item) { + ModularArmor_Item tmp = (ModularArmor_Item) stack.getItem(); + ContainerModularArmor tmp2 = new ContainerBasicArmor(aPlayer, new InventoryArmor(ModularArmor_Item.class, stack)); + ArmorCalculation.useFluid(tmp2.mInvArmor.parts, air); + } + } + } + // Fill Air Tank + if (data.tooltipUpdate == 40 && data.processingPower > data.processingPowerUsed && data.type == 0 && data.fluid != null + && data.fluid.getUnlocalizedName().equals("oxygen") && data.fluid.amount < data.tankCap && data.charge > data.electrolyzerEUusage) { + data.charge -= data.electrolyzerEUusage; + ItemStack stack = aPlayer.getEquipmentInSlot(4); + if (stack != null && stack.getItem() instanceof ModularArmor_Item) { + ModularArmor_Item tmp = (ModularArmor_Item) stack.getItem(); + ContainerModularArmor tmp2 = new ContainerBasicArmor(aPlayer, new InventoryArmor(ModularArmor_Item.class, stack)); + ArmorCalculation.useFluid(tmp2.mInvArmor.parts, -data.electrolyzerProd); + } + } + + if (data.isTopItem) { + if(IC2.keyboard.isModeSwitchKeyDown(aPlayer)&&!aWorld.isRemote){ + int typeMod=0; + switch(data.type){ + case 0: + typeMod=400; + break; + case 1: + typeMod=300; + break; + case 2: + typeMod=200; + break; + case 3: + typeMod=100; + break; + } + aPlayer.openGui(GT_Values.GT, openGuiNr+(typeMod), aWorld, (int) aPlayer.posX, (int) aPlayer.posY, (int) aPlayer.posZ); + } + if(data.helmet!=null&&data.helmet.openGui){data.helmet.openGui=false;aPlayer.openGui(GT_Values.GT, openGuiNr+400, aWorld, (int) aPlayer.posX, (int) aPlayer.posY, (int) aPlayer.posZ);} + if(data.chestplate!=null&&data.chestplate.openGui){data.chestplate.openGui=false;aPlayer.openGui(GT_Values.GT, openGuiNr+300, aWorld, (int) aPlayer.posX, (int) aPlayer.posY, (int) aPlayer.posZ);} + if(data.leggings!=null&&data.leggings.openGui){data.leggings.openGui=false;aPlayer.openGui(GT_Values.GT, openGuiNr+200, aWorld, (int) aPlayer.posX, (int) aPlayer.posY, (int) aPlayer.posZ);} + if(data.boots!=null&&data.boots.openGui){data.boots.openGui=false;aPlayer.openGui(GT_Values.GT, openGuiNr+100, aWorld, (int) aPlayer.posX, (int) aPlayer.posY, (int) aPlayer.posZ);} + // Night Vision + if (timer >= 200) { + timer = 0; + if (data.processingPower > data.processingPowerUsed && data.helmet != null && data.helmet.nightVision && data.charge > 3) { + aPlayer.addPotionEffect(new PotionEffect(Potion.nightVision.getId(), 500, -3)); + data.charge -= 4; + } else { + PotionEffect nv = aPlayer.getActivePotionEffect(Potion.nightVision); + if (nv != null && nv.getAmplifier() == -3) { + if (aPlayer.worldObj.isRemote) { + aPlayer.removePotionEffectClient(Potion.nightVision.id); + } else { + aPlayer.removePotionEffect(Potion.nightVision.id); + } + } + } + } else { + timer++; + } + + // Item Magnet + if (data.magnet > 1) { + double x = aPlayer.posX; + double y = aPlayer.posY - (aPlayer.worldObj.isRemote ? 1.62 : 0) + 0.75; + double z = aPlayer.posZ; + List items = aPlayer.worldObj.getEntitiesWithinAABB(EntityItem.class, + AxisAlignedBB.getBoundingBox(x - data.magnet, y - data.magnet, z - data.magnet, x + data.magnet, y + data.magnet, z + data.magnet)); + for (EntityItem item : items) { + ItemStack stack = item.getEntityItem(); + if (!item.isDead && stack != null) { + setEntityMotionFromVector(item, new Vector3(x, y, z), 0.45F); + } + } + } + // Weight limit calcuation + double motorSpeed = 0; + if (data.leggings != null) { + motorSpeed = data.leggings.motorPower; + } + if (data.maxWeight > 4000) { + if (data.leggings != null && data.leggings.charge > data.leggings.motorEUusage) { + motorSpeed -= data.maxWeight - 4000; + data.leggings.charge -= (data.leggings.motorEUusage / 100); + } else { + aPlayer.motionX *= (4000.0d / data.maxWeight); + aPlayer.motionZ *= (4000.0d / data.maxWeight); + } + } + if (data.leggings != null && data.leggings.charge > data.leggings.motorEUusage && data.processingPower > data.processingPowerUsed && motorSpeed > 0 + && aPlayer.isSprinting() && jumpticks > 0 + && (aPlayer.onGround && Math.abs(aPlayer.motionX) + Math.abs(aPlayer.motionZ) > 0.10000000149011612D)) { + data.leggings.charge -= data.leggings.motorEUusage; + motorSpeed = Math.sqrt(motorSpeed) / 3; + + float var7 = (float) (0.02f * motorSpeed); + if (aPlayer.isInWater()) { + var7 = 0.1F; + if (aPlayer.motionY > 0) { + aPlayer.motionY += 0.10000000149011612D; + } + } + + if (var7 > 0.0F) { + aPlayer.moveFlying(0.0F, 1.0F, var7); + } + } + + // jump+step up assist + if (data.processingPower > data.processingPowerUsed && data.leggings != null) { + double stepup = data.leggings.pistonJumpboost; + if (stepup > 1) { + aPlayer.stepHeight = 1.0f; + } + if (GameSettings.isKeyDown(Minecraft.getMinecraft().gameSettings.keyBindJump)) { + if (stepup > 0 && jumpticks > 0) { + if (data.maxWeight > 2000) { + stepup *= 2000.0D / data.maxWeight; + } + aPlayer.motionY += 0.04 * stepup; + } + aPlayer.jumpMovementFactor = aPlayer.getAIMoveSpeed() * .2f; + } + + } + + // immune effect removal + List effects = new LinkedList(aPlayer.getActivePotionEffects()); + for (PotionEffect effect : effects) { + int id = effect.getPotionID(); + if (id == 24 && data.fullRadiationDef) { + aPlayer.removePotionEffect(id); + } + } + } + } + + public void setEntityMotionFromVector(Entity entity, Vector3 originalPosVector, float modifier) { + Vector3 entityVector = Vector3.fromEntityCenter(entity); + Vector3 finalVector = originalPosVector.copy().subtract(entityVector); + if (finalVector.mag() > 1) + finalVector.normalize(); + entity.motionX = finalVector.x * modifier; + entity.motionY = finalVector.y * modifier; + entity.motionZ = finalVector.z * modifier; + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack itemstack1, ItemStack itemstack2) { + return false; + } + + @Override + public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack) { + return true; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aIconRegister) { + this.itemIcon = aIconRegister.registerIcon(GT_Values.MOD_ID+":" + mName); + } + + @SideOnly(Side.CLIENT) + public String getArmorTexture(ItemStack stack, Entity entity, int slot, String type) { + String armor=GT_Values.RES_PATH_ITEM+"armorhelmet.png"; + String tier=""; + try{ + if (data == null) { + data = fillArmorData((EntityPlayer) entity, stack); + } + if(this.data.armorTier==0){ + tier="basic"; + }else if(this.data.armorTier==1){ + tier="e1"; + }else if(this.data.armorTier==2){ + tier="e2"; + } + if(this.data.type==0||this.data.type==1||this.data.type==3){ + armor = GT_Values.RES_PATH_MODEL+"armor/"+tier+"_helmet_chest.png"; + }else{ + armor = GT_Values.RES_PATH_MODEL+"armor/"+tier+"_leggings_boots.png"; + }}catch(Exception e){System.err.println(e);} + return armor; + } + + @Override + public boolean showNodes(ItemStack aStack, EntityLivingBase aPlayer) { + if (data == null) { + data = fillArmorData((EntityPlayer) aPlayer, aStack); + } + return data.thaumicGoggles && data.armorTier > 0 && data.charge > 0; + } + + @Override + public boolean showIngamePopups(ItemStack aStack, EntityLivingBase aPlayer) { + if (data == null) { + data = fillArmorData((EntityPlayer) aPlayer, aStack); + } + return data.thaumicGoggles && data.armorTier > 0 && data.charge > 0; + } + + public ArmorData fillArmorData(EntityPlayer player, ItemStack stack) { + return new ArmorData(player, stack, this.armorType, openGuiNr); + } + + public double getBaseAbsorptionRatio() { + switch (this.armorType) { + case 0: + return 0.15; + case 1: + return 0.40; + case 2: + return 0.30; + case 3: + return 0.15; + default: + return 0.00; + } + } +} diff --git a/src/main/java/gregtech/common/items/armor/SlotFluid.java b/src/main/java/gregtech/common/items/armor/SlotFluid.java new file mode 100644 index 0000000000..9636cb4549 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/SlotFluid.java @@ -0,0 +1,33 @@ +package gregtech.common.items.armor; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import scala.reflect.internal.Trees.This; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.FluidRegistry; + +public class SlotFluid extends Slot{ + + public SlotFluid(IInventory inventory, int slot_index, int x, int y) { + super(inventory, slot_index, x, y); + } + + @Override + public boolean canTakeStack(EntityPlayer p_82869_1_) + { + return false; + } + + @Override + public boolean isItemValid(ItemStack p_75214_1_) + { + return false; + } + +} diff --git a/src/main/java/gregtech/common/items/armor/SlotLocked.java b/src/main/java/gregtech/common/items/armor/SlotLocked.java new file mode 100644 index 0000000000..b54d8d1027 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/SlotLocked.java @@ -0,0 +1,33 @@ +package gregtech.common.items.armor; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + + +public class SlotLocked extends Slot{ + + public SlotLocked(IInventory par1iInventory, int par2, int par3, int par4) { + super(par1iInventory, par2, par3, par4); + } + @Override + public void onPickupFromSlot(EntityPlayer player, ItemStack itemStack) { + } + @Override + public boolean isItemValid(ItemStack par1ItemStack) { + return false; + } + @Override + public boolean getHasStack() { + return false; + } + @Override + public ItemStack decrStackSize(int i) { + return null; + } + + @Override + public boolean canTakeStack(EntityPlayer stack) { + return false;} + +} diff --git a/src/main/java/gregtech/common/items/armor/Values.java b/src/main/java/gregtech/common/items/armor/Values.java new file mode 100644 index 0000000000..cad53d645f --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/Values.java @@ -0,0 +1,125 @@ +package gregtech.common.items.armor; + +import java.util.HashMap; +import java.util.Map; + +import gregtech.api.enums.Materials; + +public class Values { + public static Values INSTANCE; + public static final Map MATERIAL_MAP = new HashMap(); + + public int weight; + public float physicalDef; + public float projectileDef; + public float fireDef; + public float magicDef; + public float explosionDef; + + public Values(Materials material, int weight, float physicalDef, float projectileDef, float fireDef, float magicDef, float explosionDef) { + this.weight = weight; + this.physicalDef = physicalDef; + this.projectileDef = projectileDef; + this.fireDef = fireDef; + this.magicDef = magicDef; + this.explosionDef = explosionDef; + } + + public Values() { + INSTANCE = this; + MATERIAL_MAP.put(Materials._NULL, new Values(Materials._NULL, 0, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f)); + MATERIAL_MAP.put(Materials.Rubber, new Values(Materials.Rubber, 60, 0.06f, 0.06f, 0.02f, 0.1f, 0.1f)); + MATERIAL_MAP.put(Materials.Wood, new Values(Materials.Wood, 80, 0.08f, 0.09f, 0.02f, 0.08f, 0.08f)); + MATERIAL_MAP.put(Materials.Brass, new Values(Materials.Brass, 140, 0.12f, 0.12f, 0.10f, 0.10f, 0.12f)); + MATERIAL_MAP.put(Materials.Copper, new Values(Materials.Copper, 140, 0.11f, 0.11f, 0.10f, 0.10f, 0.11f)); + MATERIAL_MAP.put(Materials.Lead, new Values(Materials.Lead, 280, 0.05f, 0.05f, 0.05f, 0.05f, 0.05f)); + MATERIAL_MAP.put(Materials.Plastic, new Values(Materials.Plastic, 60, 0.10f, 0.10f, 0.02f, 0.02f, 0.10f)); + MATERIAL_MAP.put(Materials.Aluminium, new Values(Materials.Aluminium, 120, 0.14f, 0.14f, 0.12f, 0.12f, 0.14f)); + MATERIAL_MAP.put(Materials.AstralSilver, new Values(Materials.AstralSilver, 180, 0.10f, 0.10f, 0.10f, 0.18f, 0.10f)); + MATERIAL_MAP.put(Materials.BismuthBronze, new Values(Materials.BismuthBronze, 160, 0.12f, 0.12f, 0.10f, 0.10f, 0.12f)); + MATERIAL_MAP.put(Materials.BlackBronze, new Values(Materials.BlackBronze, 160, 0.13f, 0.13f, 0.10f, 0.10f, 0.13f)); + MATERIAL_MAP.put(Materials.BlackSteel, new Values(Materials.BlackSteel, 200, 0.19f, 0.19f, 0.17f, 0.17f, 0.19f)); + MATERIAL_MAP.put(Materials.BlueSteel, new Values(Materials.BlueSteel, 200, 0.21f, 0.21f, 0.19f, 0.19f, 0.21f)); + MATERIAL_MAP.put(Materials.Bronze, new Values(Materials.Bronze, 160, 0.13f, 0.13f, 0.12f, 0.12f, 0.13f)); + MATERIAL_MAP.put(Materials.CobaltBrass, new Values(Materials.CobaltBrass, 180, 0.15f, 0.15f, 0.14f, 0.14f, 0.15f)); + MATERIAL_MAP.put(Materials.DamascusSteel, new Values(Materials.DamascusSteel, 200, 0.22f, 0.22f, 0.20f, 0.20f, 0.22f)); + MATERIAL_MAP.put(Materials.Electrum, new Values(Materials.Electrum, 250, 0.11f, 0.11f, 0.10f, 0.10f, 0.11f)); + MATERIAL_MAP.put(Materials.Emerald, new Values(Materials.Emerald, 160, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Gold, new Values(Materials.Gold, 300, 0.09f, 0.09f, 0.05f, 0.25f, 0.09f)); + MATERIAL_MAP.put(Materials.GreenSapphire, new Values(Materials.GreenSapphire, 160, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Invar, new Values(Materials.Invar, 190, 0.10f, 0.10f, 0.22f, 0.22f, 0.10f)); + MATERIAL_MAP.put(Materials.Iron, new Values(Materials.Iron, 200, 0.12f, 0.12f, 0.10f, 0.10f, 0.12f)); + MATERIAL_MAP.put(Materials.IronWood, new Values(Materials.IronWood, 150, 0.17f, 0.17f, 0.02f, 0.02f, 0.17f)); + MATERIAL_MAP.put(Materials.Magnalium, new Values(Materials.Magnalium, 120, 0.15f, 0.15f, 0.17f, 0.17f, 0.15f)); + MATERIAL_MAP.put(Materials.NeodymiumMagnetic, new Values(Materials.NeodymiumMagnetic, 220, 0.14f, 0.14f, 0.14f, 0.14f, 0.14f)); + MATERIAL_MAP.put(Materials.Manganese, new Values(Materials.Manganese, 180, 0.15f, 0.15f, 0.14f, 0.14f, 0.15f)); + MATERIAL_MAP.put(Materials.MeteoricIron, new Values(Materials.MeteoricIron, 200, 0.18f, 0.18f, 0.16f, 0.16f, 0.18f)); + MATERIAL_MAP.put(Materials.MeteoricSteel, new Values(Materials.MeteoricSteel, 200, 0.21f, 0.21f, 0.19f, 0.19f, 0.21f)); + MATERIAL_MAP.put(Materials.Molybdenum, new Values(Materials.Molybdenum, 140, 0.14f, 0.14f, 0.14f, 0.14f, 0.14f)); + MATERIAL_MAP.put(Materials.Nickel, new Values(Materials.Nickel, 180, 0.12f, 0.12f, 0.15f, 0.15f, 0.12f)); + MATERIAL_MAP.put(Materials.Olivine, new Values(Materials.Olivine, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Opal, new Values(Materials.Opal, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Palladium, new Values(Materials.Palladium, 280, 0.14f, 0.14f, 0.12f, 0.12f, 0.14f)); + MATERIAL_MAP.put(Materials.Platinum, new Values(Materials.Platinum, 290, 0.15f, 0.15f, 0.13f, 0.13f, 0.15f)); + MATERIAL_MAP.put(Materials.GarnetRed, new Values(Materials.GarnetRed, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.RedSteel, new Values(Materials.RedSteel, 200, 0.20f, 0.20f, 0.18f, 0.18f, 0.20f)); + MATERIAL_MAP.put(Materials.RoseGold, new Values(Materials.RoseGold, 240, 0.10f, 0.10f, 0.08f, 0.18f, 0.10f)); + MATERIAL_MAP.put(Materials.Ruby, new Values(Materials.Ruby, 180, 0.10f, 0.10f, 0.20f, 0.20f, 0.10f)); + MATERIAL_MAP.put(Materials.Sapphire, new Values(Materials.Sapphire, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Silver, new Values(Materials.Silver, 220, 0.11f, 0.11f, 0.07f, 0.24f, 0.11f)); + MATERIAL_MAP.put(Materials.StainlessSteel, new Values(Materials.StainlessSteel, 200, 0.16f, 0.16f, 0.21f, 0.21f, 0.16f)); + MATERIAL_MAP.put(Materials.Steel, new Values(Materials.Steel, 200, 0.18f, 0.18f, 0.16f, 0.16f, 0.18f)); + MATERIAL_MAP.put(Materials.SterlingSilver, new Values(Materials.SterlingSilver, 210, 0.15f, 0.15f, 0.13f, 0.13f, 0.15f)); + MATERIAL_MAP.put(Materials.Tanzanite, new Values(Materials.Tanzanite, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Thorium, new Values(Materials.Thorium, 280, 0.13f, 0.13f, 0.16f, 0.16f, 0.13f)); + MATERIAL_MAP.put(Materials.WroughtIron, new Values(Materials.WroughtIron, 200, 0.14f, 0.14f, 0.12f, 0.12f, 0.14f)); + MATERIAL_MAP.put(Materials.GarnetYellow, new Values(Materials.GarnetYellow, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Carbon, new Values(Materials.Carbon, 60, 0.06f, 0.23f, 0.05f, 0.05f, 0.06f)); + MATERIAL_MAP.put(Materials.InfusedAir,new Values(Materials.InfusedAir, 10, 0.10f, 0.10f, 0.10f,0.10f, 0.10f)); + MATERIAL_MAP.put(Materials.Amethyst, new Values(Materials.Amethyst, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.InfusedWater,new Values(Materials.InfusedWater, 150, 0.10f, 0.10f,0.20f, 0.20f, 0.10f)); + MATERIAL_MAP.put(Materials.BlueTopaz, new Values(Materials.BlueTopaz, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Chrome, new Values(Materials.Chrome, 200, 0.12f, 0.12f, 0.21f, 0.21f, 0.12f)); + MATERIAL_MAP.put(Materials.Cobalt, new Values(Materials.Cobalt, 220, 0.16f, 0.16f, 0.14f, 0.14f, 0.16f)); + MATERIAL_MAP.put(Materials.DarkIron, new Values(Materials.DarkIron, 200, 0.21f, 0.21f, 0.19f, 0.19f, 0.21f)); + MATERIAL_MAP.put(Materials.Diamond, new Values(Materials.Diamond, 200, 0.20f, 0.20f, 0.22f, 0.22f, 0.20f)); + MATERIAL_MAP.put(Materials.Enderium, new Values(Materials.Enderium, 250, 0.22f, 0.22f, 0.21f, 0.21f, 0.22f)); + MATERIAL_MAP.put(Materials.ElectrumFlux,new Values(Materials.ElectrumFlux, 180, 0.19f, 0.19f, 0.16f, 0.16f, 0.19f)); + MATERIAL_MAP.put(Materials.Force, new Values(Materials.Force, 180, 0.10f, 0.10f, 0.20f, 0.20f, 0.10f)); + MATERIAL_MAP.put(Materials.HSLA, new Values(Materials.HSLA, 200, 0.21f, 0.21f, 0.17f, 0.17f, 0.21f)); + MATERIAL_MAP.put(Materials.InfusedFire,new Values(Materials.InfusedFire, 150, 0.12f, 0.10f, 0.30f, 0.30f, 0.12f)); + MATERIAL_MAP.put(Materials.InfusedGold, new Values(Materials.InfusedGold, 300, 0.15f, 0.15f, 0.05f, 0.05f, 0.15f)); + MATERIAL_MAP.put(Materials.Mithril, new Values(Materials.Mithril, 200, 0.25f, 0.25f, 0.10f, 0.30f, 0.25f)); + MATERIAL_MAP.put(Materials.InfusedOrder,new Values(Materials.InfusedOrder, 150, 0.18f, 0.22f,0.22f, 0.25f, 0.22f)); + MATERIAL_MAP.put(Materials.Steeleaf, new Values(Materials.Steeleaf, 120, 0.16f, 0.16f, 0.06f, 0.06f, 0.16f)); + MATERIAL_MAP.put(Materials.InfusedEarth,new Values(Materials.InfusedEarth, 350, 0.30f, 0.30f,0.30f, 0.30f, 0.30f)); + MATERIAL_MAP.put(Materials.Thaumium, new Values(Materials.Thaumium, 200, 0.18f, 0.19f, 0.20f, 0.30f, 0.18f)); + MATERIAL_MAP.put(Materials.Titanium, new Values(Materials.Titanium, 140, 0.20f, 0.20f, 0.18f, 0.18f, 0.20f)); + MATERIAL_MAP.put(Materials.Tungsten, new Values(Materials.Tungsten, 270, 0.27f, 0.26f, 0.23f, 0.26f, 0.26f)); + MATERIAL_MAP.put(Materials.Topaz, new Values(Materials.Topaz, 180, 0.10f, 0.10f, 0.14f, 0.14f, 0.10f)); + MATERIAL_MAP.put(Materials.Ultimet, new Values(Materials.Ultimet, 180, 0.21f, 0.21f, 0.19f, 0.19f, 0.21f)); + MATERIAL_MAP.put(Materials.Uranium, new Values(Materials.Uranium, 290, 0.27f, 0.23f, 0.20f, 0.15f, 0.21f)); + MATERIAL_MAP.put(Materials.Vinteum, new Values(Materials.Vinteum, 180, 0.10f, 0.12f, 0.14f, 0.28f, 0.12f)); + MATERIAL_MAP.put(Materials.Duranium, new Values(Materials.Duranium, 140, 0.24f, 0.24f, 0.24f, 0.24f, 0.24f)); + MATERIAL_MAP.put(Materials.Iridium, new Values(Materials.Iridium, 220, 0.24f, 0.24f, 0.22f, 0.22f, 0.24f)); + MATERIAL_MAP.put(Materials.Osmiridium, new Values(Materials.Osmiridium, 240, 0.18f, 0.18f, 0.16f, 0.16f, 0.18f)); + MATERIAL_MAP.put(Materials.Osmium, new Values(Materials.Osmium, 250, 0.12f, 0.12f, 0.10f, 0.10f, 0.12f)); + MATERIAL_MAP.put(Materials.Naquadah, new Values(Materials.Naquadah, 250, 0.27f, 0.27f, 0.25f, 0.25f, 0.27f)); + MATERIAL_MAP.put(Materials.NetherStar, new Values(Materials.NetherStar, 140, 0.22f, 0.22f, 0.24f, 0.24f, 0.22f)); + MATERIAL_MAP.put(Materials.InfusedEntropy,new Values(Materials.InfusedEntropy, 150, 0.10f, 0.10f,0.10f, 0.10f, 0.10f)); + MATERIAL_MAP.put(Materials.Tritanium, new Values(Materials.Tritanium, 140, 0.26f, 0.26f, 0.26f, 0.26f, 0.26f)); + MATERIAL_MAP.put(Materials.TungstenSteel, new Values(Materials.TungstenSteel, 270, 0.30f, 0.28f, 0.25f, 0.28f, 0.30f)); + MATERIAL_MAP.put(Materials.Adamantium, new Values(Materials.Adamantium, 200, 0.28f, 0.28f, 0.26f, 0.30f, 0.30f)); + MATERIAL_MAP.put(Materials.NaquadahAlloy, new Values(Materials.NaquadahAlloy, 300, 0.33f, 0.33f, 0.33f, 0.33f, 0.33f)); + MATERIAL_MAP.put(Materials.Neutronium, new Values(Materials.Neutronium, 600, 0.50f, 0.50f, 0.50f, 0.50f, 0.50f)); + } + + public Values getValues(Materials mat) { + Values tmp = MATERIAL_MAP.get(mat); + + if (tmp == null) { + return MATERIAL_MAP.get(Materials._NULL); + } + return tmp; + } +} diff --git a/src/main/java/gregtech/common/items/armor/Vector3.java b/src/main/java/gregtech/common/items/armor/Vector3.java new file mode 100644 index 0000000000..590f544546 --- /dev/null +++ b/src/main/java/gregtech/common/items/armor/Vector3.java @@ -0,0 +1,278 @@ +package gregtech.common.items.armor; + +import java.math.BigDecimal; +import java.math.MathContext; +import java.math.RoundingMode; +import net.minecraft.entity.Entity; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.Vec3; +import org.lwjgl.opengl.GL11; +import org.lwjgl.util.vector.Vector3f; +import org.lwjgl.util.vector.Vector4f; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class Vector3 { + public static Vector3 zero = new Vector3(); + public static Vector3 one = new Vector3(1, 1, 1); + public static Vector3 center = new Vector3(0.5, 0.5, 0.5); + public double x; + public double y; + public double z; + + public Vector3() { + } + + public Vector3(double d, double d1, double d2) { + x = d; + y = d1; + z = d2; + } + + public Vector3(Vector3 vec) { + x = vec.x; + y = vec.y; + z = vec.z; + } + + public Vector3(Vec3 vec) { + x = vec.xCoord; + y = vec.yCoord; + z = vec.zCoord; + } + + public Vector3 copy() { + return new Vector3(this); + } + + public static Vector3 fromEntity(Entity e) { + return new Vector3(e.posX, e.posY, e.posZ); + } + + public static Vector3 fromEntityCenter(Entity e) { + return new Vector3(e.posX, e.posY - e.yOffset + e.height / 2, e.posZ); + } + + public static Vector3 fromTileEntity(TileEntity e) { + return new Vector3(e.xCoord, e.yCoord, e.zCoord); + } + + public static Vector3 fromTileEntityCenter(TileEntity e) { + return new Vector3(e.xCoord + 0.5, e.yCoord + 0.5, e.zCoord + 0.5); + } + + public Vector3 set(double d, double d1, double d2) { + x = d; + y = d1; + z = d2; + return this; + } + + public Vector3 set(Vector3 vec) { + x = vec.x; + y = vec.y; + z = vec.z; + return this; + } + + public double dotProduct(Vector3 vec) { + double d = vec.x * x + vec.y * y + vec.z * z; + if (d > 1 && d < 1.00001) + d = 1; + else if (d < -1 && d > -1.00001) + d = -1; + return d; + } + + public double dotProduct(double d, double d1, double d2) { + return d * x + d1 * y + d2 * z; + } + + public Vector3 crossProduct(Vector3 vec) { + double d = y * vec.z - z * vec.y; + double d1 = z * vec.x - x * vec.z; + double d2 = x * vec.y - y * vec.x; + x = d; + y = d1; + z = d2; + return this; + } + + public Vector3 add(double d, double d1, double d2) { + x += d; + y += d1; + z += d2; + return this; + } + + public Vector3 add(Vector3 vec) { + x += vec.x; + y += vec.y; + z += vec.z; + return this; + } + + public Vector3 add(double d) { + return add(d, d, d); + } + + public Vector3 sub(Vector3 vec) { + return subtract(vec); + } + + public Vector3 subtract(Vector3 vec) { + x -= vec.x; + y -= vec.y; + z -= vec.z; + return this; + } + + public Vector3 negate(Vector3 vec) { + x = -x; + y = -y; + z = -z; + return this; + } + + public Vector3 multiply(double d) { + x *= d; + y *= d; + z *= d; + return this; + } + + public Vector3 multiply(Vector3 f) { + x *= f.x; + y *= f.y; + z *= f.z; + return this; + } + + public Vector3 multiply(double fx, double fy, double fz) { + x *= fx; + y *= fy; + z *= fz; + return this; + } + + public double mag() { + return Math.sqrt(x * x + y * y + z * z); + } + + public double magSquared() { + return x * x + y * y + z * z; + } + + public Vector3 normalize() { + double d = mag(); + if (d != 0) + multiply(1 / d); + return this; + } + + @Override + public String toString() { + MathContext cont = new MathContext(4, RoundingMode.HALF_UP); + return "Vector3(" + new BigDecimal(x, cont) + ", " + new BigDecimal(y, cont) + ", " + new BigDecimal(z, cont) + ")"; + } + + public Vector3 perpendicular() { + if (z == 0) + return zCrossProduct(); + return xCrossProduct(); + } + + public Vector3 xCrossProduct() { + double d = z; + double d1 = -y; + x = 0; + y = d; + z = d1; + return this; + } + + public Vector3 zCrossProduct() { + double d = y; + double d1 = -x; + x = d; + y = d1; + z = 0; + return this; + } + + public Vector3 yCrossProduct() { + double d = -z; + double d1 = x; + x = d; + y = 0; + z = d1; + return this; + } + + public Vec3 toVec3D() { + return Vec3.createVectorHelper(x, y, z); + } + + public double angle(Vector3 vec) { + return Math.acos(copy().normalize().dotProduct(vec.copy().normalize())); + } + + public boolean isInside(AxisAlignedBB aabb) { + return x >= aabb.minX && y >= aabb.maxY && z >= aabb.minZ && x < aabb.maxX && y < aabb.maxY && z < aabb.maxZ; + } + + public boolean isZero() { + return x == 0 && y == 0 && z == 0; + } + + public boolean isAxial() { + return x == 0 ? y == 0 || z == 0 : y == 0 && z == 0; + } + + @SideOnly(Side.CLIENT) + public Vector3f vector3f() { + return new Vector3f((float) x, (float) y, (float) z); + } + + @SideOnly(Side.CLIENT) + public Vector4f vector4f() { + return new Vector4f((float) x, (float) y, (float) z, 1); + } + + @SideOnly(Side.CLIENT) + public void glVertex() { + GL11.glVertex3d(x, y, z); + } + + public Vector3 negate() { + x = -x; + y = -y; + z = -z; + return this; + } + + public double scalarProject(Vector3 b) { + double l = b.mag(); + return l == 0 ? 0 : dotProduct(b) / l; + } + + public Vector3 project(Vector3 b) { + double l = b.magSquared(); + if (l == 0) { + set(0, 0, 0); + return this; + } + double m = dotProduct(b) / l; + set(b).multiply(m); + return this; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Vector3)) + return false; + Vector3 v = (Vector3) o; + return x == v.x && y == v.y && z == v.z; + } +} -- cgit From be22a87f84e020f0f396edfd148ef9070c4631c0 Mon Sep 17 00:00:00 2001 From: Technus Date: Sat, 8 Oct 2016 09:58:24 +0200 Subject: Optimize imports (Intelli J) --- .../gregtech/api/items/GT_MetaGenerated_Item.java | 5 ++++- .../GT_MetaTileEntity_BasicGenerator.java | 2 +- .../GT_MetaTileEntity_Hatch_Muffler.java | 1 - .../GT_MetaTileEntity_TieredMachineBlock.java | 1 - src/main/java/gregtech/api/util/GT_BaseCrop.java | 2 -- src/main/java/gregtech/api/util/GT_ModHandler.java | 3 --- src/main/java/gregtech/api/util/GT_Utility.java | 3 --- src/main/java/gregtech/common/GT_Pollution.java | 3 ++- .../gregtech/common/blocks/GT_Block_Metal.java | 1 - .../common/blocks/GT_Block_Reinforced.java | 6 ++---- .../gregtech/common/blocks/GT_Item_Casings1.java | 4 ++-- .../gregtech/common/blocks/GT_Item_Casings5.java | 4 ++-- .../common/blocks/GT_Item_Casings_Abstract.java | 4 ++-- .../common/covers/GT_Cover_FluidRegulator.java | 1 - .../common/covers/GT_Cover_Fluidfilter.java | 14 +----------- .../gregtech/common/gui/GT_Container_Filter.java | 1 - .../common/items/GT_MetaGenerated_Tool_01.java | 1 - src/main/java/gregtech/common/items/ItemComb.java | 2 -- .../common/items/armor/ArmorCalculation.java | 5 +---- .../gregtech/common/items/armor/ArmorData.java | 19 ++++++---------- .../common/items/armor/ContainerModularArmor.java | 2 -- .../common/items/armor/ElectricModularArmor1.java | 5 ----- .../gregtech/common/items/armor/FluidSync.java | 9 -------- .../gregtech/common/items/armor/FluidSync2.java | 10 --------- .../common/items/armor/GuiElectricArmor1.java | 25 ++++++---------------- .../common/items/armor/GuiModularArmor.java | 13 +++++------ .../common/items/armor/InventoryArmor.java | 8 ++----- .../common/items/armor/ModularArmor_Item.java | 24 ++++++++------------- .../gregtech/common/items/armor/SlotFluid.java | 7 ------ .../java/gregtech/common/items/armor/Values.java | 4 ++-- .../java/gregtech/common/items/armor/Vector3.java | 11 +++++----- .../items/behaviors/Behaviour_Plunger_Fluid.java | 1 - .../basic/GT_MetaTileEntity_CuringOven.java | 4 +--- .../basic/GT_MetaTileEntity_Massfabricator.java | 1 - ..._MetaTileEntity_MicrowaveEnergyTransmitter.java | 1 - .../machines/basic/GT_MetaTileEntity_Scanner.java | 7 +----- .../basic/GT_MetaTileEntity_Teleporter.java | 6 ++++-- .../multi/GT_MetaTileEntity_DistillationTower.java | 5 ----- .../GT_MetaTileEntity_LargeTurbine_Plasma.java | 3 +-- .../multi/GT_MetaTileEntity_MultiFurnace.java | 4 ++-- .../multi/GT_MetaTileEntity_OilCracker.java | 4 ++-- .../multi/GT_MetaTileEntity_ProcessingArray.java | 1 - .../multi/GT_MetaTileEntity_PyrolyseOven.java | 4 ++-- .../gregtech/common/tools/GT_Tool_Chainsaw_LV.java | 8 +++---- .../gregtech/loaders/misc/GT_BeeDefinition.java | 6 +++--- src/main/java/gregtech/loaders/misc/GT_Bees.java | 6 ------ .../gregtech/loaders/misc/GT_BranchDefinition.java | 2 -- .../loaders/oreprocessing/ProcessingWire01.java | 7 +++--- .../loaders/oreprocessing/ProcessingWire02.java | 2 -- .../loaders/oreprocessing/ProcessingWire04.java | 2 -- .../loaders/oreprocessing/ProcessingWire08.java | 2 -- .../loaders/oreprocessing/ProcessingWire12.java | 2 -- .../loaders/postload/GT_CraftingRecipeLoader.java | 1 - .../loaders/postload/GT_MachineRecipeLoader.java | 3 --- .../loaders/preload/GT_Loader_OreDictionary.java | 1 - .../java/speiger/src/crops/api/ICropCardInfo.java | 4 ++-- 56 files changed, 79 insertions(+), 208 deletions(-) (limited to 'src/main/java/gregtech/common/items/armor') diff --git a/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java index 9020eb09e8..95a6e124b1 100644 --- a/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java +++ b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java @@ -30,7 +30,10 @@ import net.minecraft.world.World; import squeek.applecore.api.food.FoodValues; import squeek.applecore.api.food.IEdible; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.BitSet; +import java.util.List; import java.util.concurrent.ConcurrentHashMap; import static gregtech.api.enums.GT_Values.*; diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java index e8c8ce5d98..c583187c6f 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java @@ -5,8 +5,8 @@ import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_Recipe.GT_Recipe_Map; -import gregtech.common.GT_Pollution; import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Pollution; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java index 1bb1e6fa48..6ea0304509 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java @@ -8,7 +8,6 @@ import gregtech.api.objects.GT_RenderedTexture; import gregtech.common.GT_Pollution; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; -import net.minecraft.util.EnumChatFormatting; import net.minecraft.world.ChunkPosition; public class GT_MetaTileEntity_Hatch_Muffler extends GT_MetaTileEntity_Hatch { diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_TieredMachineBlock.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_TieredMachineBlock.java index 54cede85c3..5355892d44 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_TieredMachineBlock.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_TieredMachineBlock.java @@ -1,6 +1,5 @@ package gregtech.api.metatileentity.implementations; -import gregtech.api.enums.GT_Values; import gregtech.api.interfaces.ITexture; import gregtech.api.metatileentity.MetaTileEntity; diff --git a/src/main/java/gregtech/api/util/GT_BaseCrop.java b/src/main/java/gregtech/api/util/GT_BaseCrop.java index 0171e35ff2..38b88cc4fa 100644 --- a/src/main/java/gregtech/api/util/GT_BaseCrop.java +++ b/src/main/java/gregtech/api/util/GT_BaseCrop.java @@ -1,7 +1,6 @@ package gregtech.api.util; import cpw.mods.fml.common.Loader; -import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.enums.ConfigCategories; import gregtech.api.enums.Materials; @@ -21,7 +20,6 @@ import speiger.src.crops.api.ICropCardInfo; import java.util.ArrayList; import java.util.List; -import java.util.Random; import static gregtech.api.enums.GT_Values.E; diff --git a/src/main/java/gregtech/api/util/GT_ModHandler.java b/src/main/java/gregtech/api/util/GT_ModHandler.java index 4822c0bef5..df6071acac 100644 --- a/src/main/java/gregtech/api/util/GT_ModHandler.java +++ b/src/main/java/gregtech/api/util/GT_ModHandler.java @@ -1,9 +1,7 @@ package gregtech.api.util; -import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.event.FMLInterModComms; import cpw.mods.fml.common.registry.GameRegistry; -import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.enums.*; import gregtech.api.interfaces.IDamagableItem; @@ -39,7 +37,6 @@ import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.oredict.ShapedOreRecipe; import net.minecraftforge.oredict.ShapelessOreRecipe; -import java.lang.reflect.Method; import java.util.*; import java.util.Map.Entry; diff --git a/src/main/java/gregtech/api/util/GT_Utility.java b/src/main/java/gregtech/api/util/GT_Utility.java index 748f2c99c8..8debfd1e58 100644 --- a/src/main/java/gregtech/api/util/GT_Utility.java +++ b/src/main/java/gregtech/api/util/GT_Utility.java @@ -42,11 +42,8 @@ import net.minecraft.nbt.NBTBase.NBTPrimitive; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; import net.minecraft.nbt.NBTTagString; -import net.minecraft.network.play.server.S07PacketRespawn; -import net.minecraft.network.play.server.S1DPacketEntityEffect; import net.minecraft.potion.Potion; import net.minecraft.potion.PotionEffect; -import net.minecraft.server.MinecraftServer; import net.minecraft.tileentity.TileEntity; import net.minecraft.tileentity.TileEntityChest; import net.minecraft.util.AxisAlignedBB; diff --git a/src/main/java/gregtech/common/GT_Pollution.java b/src/main/java/gregtech/common/GT_Pollution.java index b3cb94fad6..56f9c58926 100644 --- a/src/main/java/gregtech/common/GT_Pollution.java +++ b/src/main/java/gregtech/common/GT_Pollution.java @@ -5,7 +5,6 @@ import gregtech.api.objects.XSTR; import gregtech.api.util.GT_Utility; import net.minecraft.block.Block; import net.minecraft.block.material.Material; -//import net.minecraft.entity.EntityLiving; import net.minecraft.entity.EntityLivingBase; import net.minecraft.init.Blocks; import net.minecraft.potion.Potion; @@ -18,6 +17,8 @@ import net.minecraftforge.common.DimensionManager; import java.util.ArrayList; import java.util.List; +//import net.minecraft.entity.EntityLiving; + public class GT_Pollution { diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Metal.java b/src/main/java/gregtech/common/blocks/GT_Block_Metal.java index 58e1996b9b..f3347772ce 100644 --- a/src/main/java/gregtech/common/blocks/GT_Block_Metal.java +++ b/src/main/java/gregtech/common/blocks/GT_Block_Metal.java @@ -5,7 +5,6 @@ import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; import gregtech.api.interfaces.IIconContainer; import gregtech.api.util.GT_LanguageManager; -import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import net.minecraft.block.material.Material; import net.minecraft.item.ItemStack; diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Reinforced.java b/src/main/java/gregtech/common/blocks/GT_Block_Reinforced.java index 99c16b1db9..caa8baed80 100644 --- a/src/main/java/gregtech/common/blocks/GT_Block_Reinforced.java +++ b/src/main/java/gregtech/common/blocks/GT_Block_Reinforced.java @@ -13,8 +13,9 @@ import gregtech.api.objects.MaterialStack; import gregtech.api.util.GT_LanguageManager; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; +import ic2.core.block.EntityIC2Explosive; +import ic2.core.block.EntityItnt; import net.minecraft.block.Block; -import net.minecraft.block.material.Material; import net.minecraft.client.renderer.texture.IIconRegister; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.Entity; @@ -30,9 +31,6 @@ import net.minecraft.util.StatCollector; import net.minecraft.world.Explosion; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; -import ic2.core.IC2; -import ic2.core.block.EntityIC2Explosive; -import ic2.core.block.EntityItnt; import java.util.List; import java.util.Random; diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Casings1.java b/src/main/java/gregtech/common/blocks/GT_Item_Casings1.java index 8b4348e254..680942d9fd 100644 --- a/src/main/java/gregtech/common/blocks/GT_Item_Casings1.java +++ b/src/main/java/gregtech/common/blocks/GT_Item_Casings1.java @@ -1,7 +1,5 @@ package gregtech.common.blocks; -import java.util.List; - import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; import net.minecraft.block.Block; @@ -9,6 +7,8 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; +import java.util.List; + public class GT_Item_Casings1 extends GT_Item_Casings_Abstract { public GT_Item_Casings1(Block par1) { diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Casings5.java b/src/main/java/gregtech/common/blocks/GT_Item_Casings5.java index 36e7fea047..09d79b75dc 100644 --- a/src/main/java/gregtech/common/blocks/GT_Item_Casings5.java +++ b/src/main/java/gregtech/common/blocks/GT_Item_Casings5.java @@ -1,13 +1,13 @@ package gregtech.common.blocks; -import java.util.List; - import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import java.util.List; + public class GT_Item_Casings5 extends GT_Item_Casings_Abstract { public GT_Item_Casings5(Block par1) { diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Casings_Abstract.java b/src/main/java/gregtech/common/blocks/GT_Item_Casings_Abstract.java index 64242840f8..62e64f2680 100644 --- a/src/main/java/gregtech/common/blocks/GT_Item_Casings_Abstract.java +++ b/src/main/java/gregtech/common/blocks/GT_Item_Casings_Abstract.java @@ -1,7 +1,5 @@ package gregtech.common.blocks; -import java.util.List; - import gregtech.api.GregTech_API; import gregtech.api.util.GT_LanguageManager; import net.minecraft.block.Block; @@ -9,6 +7,8 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import java.util.List; + public abstract class GT_Item_Casings_Abstract extends ItemBlock { protected final String mNoMobsToolTip = GT_LanguageManager.addStringLocalization("gt.nomobspawnsonthisblock", "Mobs cannot Spawn on this Block"); diff --git a/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java b/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java index e0057cf1a8..94fcba6b66 100644 --- a/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java +++ b/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java @@ -1,7 +1,6 @@ package gregtech.common.covers; import gregtech.api.interfaces.tileentity.ICoverable; -import gregtech.api.interfaces.tileentity.IMachineProgress; import gregtech.api.util.GT_CoverBehavior; import gregtech.api.util.GT_Utility; import net.minecraft.entity.player.EntityPlayer; diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java b/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java index 75c6c4dc3a..2ae8119b6e 100644 --- a/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java +++ b/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java @@ -1,23 +1,11 @@ package gregtech.common.covers; -import gregtech.api.GregTech_API; import gregtech.api.interfaces.tileentity.ICoverable; -import gregtech.api.interfaces.tileentity.IMachineProgress; -import gregtech.api.objects.ItemData; import gregtech.api.util.GT_CoverBehavior; -import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; -import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidContainerRegistry; -import net.minecraftforge.fluids.FluidRegistry; -import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.FluidTankInfo; -import net.minecraftforge.fluids.IFluidContainerItem; -import net.minecraftforge.fluids.IFluidHandler; +import net.minecraftforge.fluids.*; public class GT_Cover_Fluidfilter extends GT_CoverBehavior { diff --git a/src/main/java/gregtech/common/gui/GT_Container_Filter.java b/src/main/java/gregtech/common/gui/GT_Container_Filter.java index 6a43788637..0355aa1753 100644 --- a/src/main/java/gregtech/common/gui/GT_Container_Filter.java +++ b/src/main/java/gregtech/common/gui/GT_Container_Filter.java @@ -3,7 +3,6 @@ package gregtech.common.gui; import gregtech.api.gui.GT_ContainerMetaTile_Machine; import gregtech.api.gui.GT_Slot_Holo; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; -import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_Utility; import gregtech.common.tileentities.automation.GT_MetaTileEntity_Filter; import net.minecraft.entity.player.EntityPlayer; diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java index dc9d9d67d0..9946240d24 100644 --- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java @@ -6,7 +6,6 @@ import gregtech.api.items.GT_MetaGenerated_Tool; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.common.tools.*; -import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; diff --git a/src/main/java/gregtech/common/items/ItemComb.java b/src/main/java/gregtech/common/items/ItemComb.java index 071b38171b..0b7b68875a 100644 --- a/src/main/java/gregtech/common/items/ItemComb.java +++ b/src/main/java/gregtech/common/items/ItemComb.java @@ -1,7 +1,6 @@ package gregtech.common.items; import com.google.common.collect.ImmutableMap; - import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -12,7 +11,6 @@ import gregtech.api.enums.GT_Values; import gregtech.api.enums.ItemList; import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; -import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; import net.minecraft.client.renderer.texture.IIconRegister; diff --git a/src/main/java/gregtech/common/items/armor/ArmorCalculation.java b/src/main/java/gregtech/common/items/armor/ArmorCalculation.java index 8915ce6f52..440d6aaef9 100644 --- a/src/main/java/gregtech/common/items/armor/ArmorCalculation.java +++ b/src/main/java/gregtech/common/items/armor/ArmorCalculation.java @@ -1,8 +1,5 @@ package gregtech.common.items.armor; -import java.util.List; - -import thaumcraft.api.nodes.IRevealer; import cpw.mods.fml.common.Loader; import gregtech.api.enums.ItemList; import gregtech.api.enums.Materials; @@ -12,8 +9,8 @@ import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; +import thaumcraft.api.nodes.IRevealer; public class ArmorCalculation { public static float[] calculateArmor(ItemStack[] parts) { diff --git a/src/main/java/gregtech/common/items/armor/ArmorData.java b/src/main/java/gregtech/common/items/armor/ArmorData.java index 79c6a20ffa..be73ec4229 100644 --- a/src/main/java/gregtech/common/items/armor/ArmorData.java +++ b/src/main/java/gregtech/common/items/armor/ArmorData.java @@ -1,24 +1,17 @@ package gregtech.common.items.armor; +import gregtech.api.util.GT_LanguageManager; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; + import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; import java.text.NumberFormat; import java.util.ArrayList; import java.util.List; import java.util.Locale; -import java.util.Random; - -import gregtech.api.damagesources.GT_DamageSources; -import gregtech.api.util.GT_LanguageManager; -import gregtech.api.util.GT_Utility; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.nbt.NBTTagList; -import net.minecraft.util.DamageSource; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidRegistry; -import net.minecraftforge.fluids.FluidStack; public class ArmorData { diff --git a/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java b/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java index 88f1a71599..22b31aa3d3 100644 --- a/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java +++ b/src/main/java/gregtech/common/items/armor/ContainerModularArmor.java @@ -3,9 +3,7 @@ package gregtech.common.items.armor; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.Container; -import net.minecraft.inventory.IInventory; import net.minecraft.inventory.Slot; -import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraftforge.oredict.OreDictionary; diff --git a/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java b/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java index 5d8bfd82f0..d310fa4c96 100644 --- a/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java +++ b/src/main/java/gregtech/common/items/armor/ElectricModularArmor1.java @@ -1,12 +1,7 @@ package gregtech.common.items.armor; -import net.minecraft.entity.EntityLivingBase; -import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; -import net.minecraft.world.World; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.IFluidContainerItem; public class ElectricModularArmor1 extends ModularArmor_Item{ diff --git a/src/main/java/gregtech/common/items/armor/FluidSync.java b/src/main/java/gregtech/common/items/armor/FluidSync.java index 70ee268188..876b220b15 100644 --- a/src/main/java/gregtech/common/items/armor/FluidSync.java +++ b/src/main/java/gregtech/common/items/armor/FluidSync.java @@ -1,14 +1,5 @@ package gregtech.common.items.armor; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.world.IBlockAccess; -import net.minecraft.world.WorldServer; -import net.minecraftforge.common.DimensionManager; -import net.minecraftforge.fluids.FluidRegistry; -import net.minecraftforge.fluids.FluidStack; - -import com.google.common.base.Charsets; -import com.google.common.io.ByteArrayDataInput; import com.google.common.io.ByteArrayDataOutput; import com.google.common.io.ByteStreams; diff --git a/src/main/java/gregtech/common/items/armor/FluidSync2.java b/src/main/java/gregtech/common/items/armor/FluidSync2.java index de801aad8a..35d1d395bf 100644 --- a/src/main/java/gregtech/common/items/armor/FluidSync2.java +++ b/src/main/java/gregtech/common/items/armor/FluidSync2.java @@ -1,15 +1,5 @@ package gregtech.common.items.armor; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.item.ItemStack; -import net.minecraft.world.IBlockAccess; -import net.minecraft.world.WorldServer; -import net.minecraftforge.common.DimensionManager; -import net.minecraftforge.fluids.FluidRegistry; -import net.minecraftforge.fluids.FluidStack; - -import com.google.common.base.Charsets; -import com.google.common.io.ByteArrayDataInput; import com.google.common.io.ByteArrayDataOutput; import com.google.common.io.ByteStreams; diff --git a/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java b/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java index 136630124f..6857535d65 100644 --- a/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java +++ b/src/main/java/gregtech/common/items/armor/GuiElectricArmor1.java @@ -1,7 +1,13 @@ package gregtech.common.items.armor; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; import gregtech.api.util.GT_LanguageManager; -import gregtech.api.util.GT_Utility; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; @@ -10,23 +16,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Locale; -import org.lwjgl.opengl.GL11; - -import cpw.mods.fml.relauncher.Side; -import cpw.mods.fml.relauncher.SideOnly; -import net.minecraft.client.gui.inventory.GuiContainer; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.init.Items; -import net.minecraft.inventory.Container; -import net.minecraft.inventory.Slot; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.util.ResourceLocation; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.IFluidContainerItem; - @SideOnly(Side.CLIENT) public class GuiElectricArmor1 extends GuiContainer { ContainerModularArmor cont; diff --git a/src/main/java/gregtech/common/items/armor/GuiModularArmor.java b/src/main/java/gregtech/common/items/armor/GuiModularArmor.java index 17fd84b2fb..1c47f2489f 100644 --- a/src/main/java/gregtech/common/items/armor/GuiModularArmor.java +++ b/src/main/java/gregtech/common/items/armor/GuiModularArmor.java @@ -1,18 +1,15 @@ package gregtech.common.items.armor; -import gregtech.api.util.GT_LanguageManager; - -import java.util.ArrayList; -import java.util.List; - -import org.lwjgl.opengl.GL11; - import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.util.GT_LanguageManager; import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.Container; import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; + +import java.util.ArrayList; +import java.util.List; @SideOnly(Side.CLIENT) public class GuiModularArmor extends GuiContainer { diff --git a/src/main/java/gregtech/common/items/armor/InventoryArmor.java b/src/main/java/gregtech/common/items/armor/InventoryArmor.java index 0d615ed732..3357e2f489 100644 --- a/src/main/java/gregtech/common/items/armor/InventoryArmor.java +++ b/src/main/java/gregtech/common/items/armor/InventoryArmor.java @@ -1,18 +1,14 @@ package gregtech.common.items.armor; -import gregtech.api.util.GT_Utility; - -import java.util.Random; - import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.Container; import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; -import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.oredict.OreDictionary; +import java.util.Random; + public class InventoryArmor implements IInventory { public ItemStack[] parts; diff --git a/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java b/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java index c305278543..8122dede83 100644 --- a/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java +++ b/src/main/java/gregtech/common/items/armor/ModularArmor_Item.java @@ -1,22 +1,14 @@ package gregtech.common.items.armor; -import gregtech.api.damagesources.GT_DamageSources; -import gregtech.api.enums.GT_Values; -import ic2.core.IC2; - -import java.util.ArrayList; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; - import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.Optional; -import thaumcraft.api.IGoggles; -import thaumcraft.api.nodes.IRevealer; import cpw.mods.fml.common.eventhandler.SubscribeEvent; import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.damagesources.GT_DamageSources; +import gregtech.api.enums.GT_Values; +import ic2.core.IC2; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.texture.IIconRegister; import net.minecraft.client.settings.GameSettings; @@ -25,21 +17,23 @@ import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Items; -import net.minecraft.inventory.IInventory; import net.minecraft.item.Item; import net.minecraft.item.ItemArmor; import net.minecraft.item.ItemStack; -import net.minecraft.item.ItemArmor.ArmorMaterial; import net.minecraft.potion.Potion; import net.minecraft.potion.PotionEffect; import net.minecraft.util.AxisAlignedBB; import net.minecraft.util.DamageSource; -import net.minecraft.util.MathHelper; import net.minecraft.world.World; import net.minecraftforge.common.ISpecialArmor; import net.minecraftforge.common.MinecraftForge; -import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.event.entity.living.LivingFallEvent; +import thaumcraft.api.IGoggles; +import thaumcraft.api.nodes.IRevealer; + +import java.util.LinkedList; +import java.util.List; +import java.util.Random; @Optional.InterfaceList(value = { @Optional.Interface(iface = "thaumcraft.api.IGoggles", modid = "Thaumcraft", striprefs = true), @Optional.Interface(iface = "thaumcraft.api.nodes.IRevealer", modid = "Thaumcraft", striprefs = true) }) diff --git a/src/main/java/gregtech/common/items/armor/SlotFluid.java b/src/main/java/gregtech/common/items/armor/SlotFluid.java index 9636cb4549..d8e5ef605f 100644 --- a/src/main/java/gregtech/common/items/armor/SlotFluid.java +++ b/src/main/java/gregtech/common/items/armor/SlotFluid.java @@ -1,16 +1,9 @@ package gregtech.common.items.armor; -import cpw.mods.fml.relauncher.Side; -import cpw.mods.fml.relauncher.SideOnly; -import scala.reflect.internal.Trees.This; -import net.minecraft.client.renderer.texture.TextureMap; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.IInventory; import net.minecraft.inventory.Slot; import net.minecraft.item.ItemStack; -import net.minecraft.util.IIcon; -import net.minecraft.util.ResourceLocation; -import net.minecraftforge.fluids.FluidRegistry; public class SlotFluid extends Slot{ diff --git a/src/main/java/gregtech/common/items/armor/Values.java b/src/main/java/gregtech/common/items/armor/Values.java index cad53d645f..6ccf204d01 100644 --- a/src/main/java/gregtech/common/items/armor/Values.java +++ b/src/main/java/gregtech/common/items/armor/Values.java @@ -1,10 +1,10 @@ package gregtech.common.items.armor; +import gregtech.api.enums.Materials; + import java.util.HashMap; import java.util.Map; -import gregtech.api.enums.Materials; - public class Values { public static Values INSTANCE; public static final Map MATERIAL_MAP = new HashMap(); diff --git a/src/main/java/gregtech/common/items/armor/Vector3.java b/src/main/java/gregtech/common/items/armor/Vector3.java index 590f544546..2f79ff4c69 100644 --- a/src/main/java/gregtech/common/items/armor/Vector3.java +++ b/src/main/java/gregtech/common/items/armor/Vector3.java @@ -1,8 +1,7 @@ package gregtech.common.items.armor; -import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; import net.minecraft.entity.Entity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.AxisAlignedBB; @@ -10,8 +9,10 @@ import net.minecraft.util.Vec3; import org.lwjgl.opengl.GL11; import org.lwjgl.util.vector.Vector3f; import org.lwjgl.util.vector.Vector4f; -import cpw.mods.fml.relauncher.Side; -import cpw.mods.fml.relauncher.SideOnly; + +import java.math.BigDecimal; +import java.math.MathContext; +import java.math.RoundingMode; public class Vector3 { public static Vector3 zero = new Vector3(); diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java index e4773356f6..11a1125eea 100644 --- a/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java @@ -5,7 +5,6 @@ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.items.GT_MetaBase_Item; import gregtech.api.items.GT_MetaGenerated_Tool; -import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicBatteryBuffer; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; import gregtech.api.util.GT_LanguageManager; import gregtech.api.util.GT_Utility; diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java index 7d0de3fcc2..a4bd99dfca 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java @@ -1,8 +1,6 @@ package gregtech.common.tileentities.machines.basic; -import java.util.Iterator; - import gregtech.api.enums.ItemList; import gregtech.api.enums.Textures; import gregtech.api.gui.GT_Container_1by1; @@ -11,8 +9,8 @@ import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.items.GT_MetaGenerated_Tool; import gregtech.api.metatileentity.MetaTileEntity; -import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine; +import gregtech.api.objects.GT_RenderedTexture; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java index efb25cb139..5035cfa831 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java @@ -7,7 +7,6 @@ import gregtech.api.metatileentity.MetaTileEntity; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine; import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.util.GT_Config; -import gregtech.api.util.GT_Utility; import net.minecraftforge.fluids.FluidStack; import static gregtech.api.enums.GT_Values.V; diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java index ab55bb2f3f..43b88537ef 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java @@ -16,7 +16,6 @@ import gregtech.common.gui.GT_Container_MicrowaveEnergyTransmitter; import gregtech.common.gui.GT_GUIContainer_MicrowaveEnergyTransmitter; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.InventoryPlayer; -import net.minecraft.init.Blocks; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumChatFormatting; diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java index 1d8fa47f35..3c61a206dd 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java @@ -11,13 +11,8 @@ import gregtech.api.metatileentity.MetaTileEntity; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine; import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.objects.ItemData; -import gregtech.api.util.GT_LanguageManager; -import gregtech.api.util.GT_Log; -import gregtech.api.util.GT_OreDictUnificator; -import gregtech.api.util.GT_Recipe; -import gregtech.api.util.GT_Utility; +import gregtech.api.util.*; import gregtech.common.items.behaviors.Behaviour_DataOrb; -import gregtech.common.items.behaviors.Behaviour_DataStick; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Teleporter.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Teleporter.java index 307d354275..3016a27771 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Teleporter.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Teleporter.java @@ -23,13 +23,11 @@ import net.minecraft.entity.boss.EntityDragonPart; import net.minecraft.entity.effect.EntityWeatherEffect; import net.minecraft.entity.item.*; import net.minecraft.entity.player.EntityPlayer; -//import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.entity.projectile.EntityArrow; import net.minecraft.entity.projectile.EntityFireball; import net.minecraft.entity.projectile.EntityFishHook; import net.minecraft.entity.projectile.EntityThrowable; -//import net.minecraft.init.Blocks; import net.minecraft.inventory.IInventory; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; @@ -38,8 +36,12 @@ import net.minecraft.util.EnumChatFormatting; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; import net.minecraftforge.fluids.FluidStack; + import static gregtech.api.enums.GT_Values.V; +//import net.minecraft.entity.player.EntityPlayerMP; +//import net.minecraft.init.Blocks; + public class GT_MetaTileEntity_Teleporter extends GT_MetaTileEntity_BasicTank { public static boolean sInterDimensionalTeleportAllowed = true; diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java index 38a1425a3e..f983595e9b 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java @@ -1,10 +1,5 @@ package gregtech.common.tileentities.machines.multi; -import java.util.ArrayList; -import java.util.Arrays; - -import org.apache.commons.lang3.ArrayUtils; - import gregtech.api.GregTech_API; import gregtech.api.enums.Textures; import gregtech.api.gui.GT_GUIContainer_MultiMachine; diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeTurbine_Plasma.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeTurbine_Plasma.java index 798be9dc9a..66b86b0fd2 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeTurbine_Plasma.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeTurbine_Plasma.java @@ -11,9 +11,8 @@ import gregtech.api.util.GT_Recipe.GT_Recipe_Map; import gregtech.api.util.GT_Utility; import net.minecraft.block.Block; import net.minecraft.item.ItemStack; -import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidRegistry; - +import net.minecraftforge.fluids.FluidStack; import java.util.ArrayList; import java.util.Collection; diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_MultiFurnace.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_MultiFurnace.java index 41f94790be..d8526ab3bc 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_MultiFurnace.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_MultiFurnace.java @@ -1,7 +1,5 @@ package gregtech.common.tileentities.machines.multi; -import java.util.ArrayList; - import gregtech.api.GregTech_API; import gregtech.api.enums.Textures; import gregtech.api.gui.GT_GUIContainer_MultiMachine; @@ -19,6 +17,8 @@ import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; import net.minecraftforge.common.util.ForgeDirection; +import java.util.ArrayList; + public class GT_MetaTileEntity_MultiFurnace extends GT_MetaTileEntity_MultiBlockBase { private int mLevel = 0; diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OilCracker.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OilCracker.java index aaede0c0db..09ce050548 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OilCracker.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OilCracker.java @@ -1,7 +1,5 @@ package gregtech.common.tileentities.machines.multi; -import java.util.ArrayList; - import gregtech.api.GregTech_API; import gregtech.api.enums.Materials; import gregtech.api.enums.Textures; @@ -19,6 +17,8 @@ import net.minecraft.item.ItemStack; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; +import java.util.ArrayList; + public class GT_MetaTileEntity_OilCracker extends GT_MetaTileEntity_MultiBlockBase { public GT_MetaTileEntity_OilCracker(int aID, String aName, String aNameRegional) { diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ProcessingArray.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ProcessingArray.java index cb93a43c17..d5ef058deb 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ProcessingArray.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ProcessingArray.java @@ -18,7 +18,6 @@ import net.minecraftforge.fluids.FluidStack; import org.apache.commons.lang3.ArrayUtils; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; public class GT_MetaTileEntity_ProcessingArray extends GT_MetaTileEntity_MultiBlockBase { diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PyrolyseOven.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PyrolyseOven.java index f187096eeb..c4e251dae9 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PyrolyseOven.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PyrolyseOven.java @@ -1,7 +1,5 @@ package gregtech.common.tileentities.machines.multi; -import java.util.ArrayList; - import gregtech.api.GregTech_API; import gregtech.api.enums.Textures; import gregtech.api.gui.GT_GUIContainer_MultiMachine; @@ -17,6 +15,8 @@ import net.minecraft.item.ItemStack; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; +import java.util.ArrayList; + public class GT_MetaTileEntity_PyrolyseOven extends GT_MetaTileEntity_MultiBlockBase { public GT_MetaTileEntity_PyrolyseOven(int aID, String aName, String aNameRegional) { diff --git a/src/main/java/gregtech/common/tools/GT_Tool_Chainsaw_LV.java b/src/main/java/gregtech/common/tools/GT_Tool_Chainsaw_LV.java index 5baf87dd4c..0572218257 100644 --- a/src/main/java/gregtech/common/tools/GT_Tool_Chainsaw_LV.java +++ b/src/main/java/gregtech/common/tools/GT_Tool_Chainsaw_LV.java @@ -1,9 +1,5 @@ package gregtech.common.tools; -import java.util.ArrayList; -import java.util.List; -import java.util.Random; - import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.enums.OrePrefixes; @@ -13,7 +9,6 @@ import gregtech.api.items.GT_MetaGenerated_Tool; import net.minecraft.block.Block; import net.minecraft.block.material.Material; import net.minecraft.entity.EntityLivingBase; -import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; @@ -23,6 +18,9 @@ import net.minecraft.util.IChatComponent; import net.minecraftforge.common.IShearable; import net.minecraftforge.event.world.BlockEvent; +import java.util.ArrayList; +import java.util.List; + public class GT_Tool_Chainsaw_LV extends GT_Tool_Saw { public int getToolDamagePerBlockBreak() { diff --git a/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java b/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java index 0f1c4554a6..e57d640d1f 100644 --- a/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java +++ b/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java @@ -9,9 +9,7 @@ import forestry.apiculture.genetics.Bee; import forestry.apiculture.genetics.BeeDefinition; import forestry.apiculture.genetics.BeeVariation; import forestry.apiculture.genetics.IBeeDefinition; -//import forestry.apiculture.items.EnumHoneyComb; import forestry.core.genetics.alleles.AlleleHelper; -//import forestry.plugins.PluginApiculture; import gregtech.api.GregTech_API; import gregtech.api.enums.GT_Values; import gregtech.api.enums.ItemList; @@ -19,12 +17,14 @@ import gregtech.api.util.GT_ModHandler; import gregtech.common.items.CombType; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; - import org.apache.commons.lang3.text.WordUtils; import java.util.Arrays; import java.util.Locale; +//import forestry.apiculture.items.EnumHoneyComb; +//import forestry.plugins.PluginApiculture; + public enum GT_BeeDefinition implements IBeeDefinition { CLAY(GT_BranchDefinition.ORGANIC, "Clay", true, 0x19d0ec, 0xffdc16) { @Override diff --git a/src/main/java/gregtech/loaders/misc/GT_Bees.java b/src/main/java/gregtech/loaders/misc/GT_Bees.java index 8635d9c8c5..227e948fda 100644 --- a/src/main/java/gregtech/loaders/misc/GT_Bees.java +++ b/src/main/java/gregtech/loaders/misc/GT_Bees.java @@ -1,12 +1,6 @@ package gregtech.loaders.misc; import cpw.mods.fml.common.Loader; -import forestry.api.apiculture.BeeManager; -import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IClassification; -import forestry.core.genetics.alleles.AlleleHelper; -import forestry.core.genetics.alleles.EnumAllele; import gregtech.GT_Mod; import gregtech.common.items.ItemComb; diff --git a/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java b/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java index ffb6b59b54..c357d1b64c 100644 --- a/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java +++ b/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java @@ -2,11 +2,9 @@ package gregtech.loaders.misc; import forestry.api.apiculture.BeeManager; import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.genetics.AlleleManager; import forestry.api.genetics.IAllele; import forestry.api.genetics.IClassification; import forestry.apiculture.genetics.alleles.AlleleEffect; -import forestry.core.genetics.alleles.Allele; import forestry.core.genetics.alleles.AlleleHelper; import forestry.core.genetics.alleles.EnumAllele; diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java index d2c50bfa0d..6740f92ebe 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java @@ -3,12 +3,13 @@ package gregtech.loaders.oreprocessing; import appeng.api.config.TunnelType; import appeng.core.Api; import gregtech.GT_Mod; -import gregtech.api.enums.*; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; import net.minecraft.item.ItemStack; public class ProcessingWire01 implements gregtech.api.interfaces.IOreRecipeRegistrator { diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java index dee453e731..7ae366998f 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java @@ -10,8 +10,6 @@ import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; import net.minecraft.item.ItemStack; public class ProcessingWire02 implements gregtech.api.interfaces.IOreRecipeRegistrator { diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java index 70ebf0b31e..ce78b940dc 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java @@ -10,8 +10,6 @@ import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; import net.minecraft.item.ItemStack; public class ProcessingWire04 implements gregtech.api.interfaces.IOreRecipeRegistrator { diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java index d798558b6d..34e212dca0 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java @@ -10,8 +10,6 @@ import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; import net.minecraft.item.ItemStack; public class ProcessingWire08 implements gregtech.api.interfaces.IOreRecipeRegistrator { diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java index 9074e085cc..d79113915b 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java @@ -10,8 +10,6 @@ import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; import net.minecraft.item.ItemStack; public class ProcessingWire12 implements gregtech.api.interfaces.IOreRecipeRegistrator { diff --git a/src/main/java/gregtech/loaders/postload/GT_CraftingRecipeLoader.java b/src/main/java/gregtech/loaders/postload/GT_CraftingRecipeLoader.java index 8c2e1a72aa..985a099c3c 100644 --- a/src/main/java/gregtech/loaders/postload/GT_CraftingRecipeLoader.java +++ b/src/main/java/gregtech/loaders/postload/GT_CraftingRecipeLoader.java @@ -1,7 +1,6 @@ package gregtech.loaders.postload; import cpw.mods.fml.common.Loader; -import cpw.mods.fml.common.registry.GameRegistry; import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.enums.*; diff --git a/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java b/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java index 03021e0fe6..b749e08378 100644 --- a/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java +++ b/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java @@ -1,13 +1,10 @@ package gregtech.loaders.postload; import com.dreammaster.gthandler.CustomItemList; -import com.dreammaster.gthandler.GT_CustomLoader; -import com.dreammaster.item.*; import cpw.mods.fml.common.Loader; import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.enums.*; -import gregtech.api.enums.ItemList; import gregtech.api.objects.MaterialStack; import gregtech.api.util.*; import gregtech.common.GT_DummyWorld; diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java b/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java index 108290bb71..1ea60d1d25 100644 --- a/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java @@ -8,7 +8,6 @@ import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_Log; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; -import gregtech.common.blocks.GT_Item_Casings2; import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; diff --git a/src/main/java/speiger/src/crops/api/ICropCardInfo.java b/src/main/java/speiger/src/crops/api/ICropCardInfo.java index 34d35edc12..7f1a76f611 100644 --- a/src/main/java/speiger/src/crops/api/ICropCardInfo.java +++ b/src/main/java/speiger/src/crops/api/ICropCardInfo.java @@ -1,9 +1,9 @@ package speiger.src.crops.api; -import java.util.List; - import net.minecraft.item.ItemStack; +import java.util.List; + /** * * @author Speiger -- cgit