From 24905c16017decae4ee60ce4128b6d26de66baf5 Mon Sep 17 00:00:00 2001 From: Jordan Byrne Date: Thu, 22 Feb 2018 13:55:56 +1000 Subject: % Minor project cleanup. --- .../core/util/minecraft/EnchantingUtils.java | 102 +++ .../core/util/minecraft/EntityUtils.java | 113 ++++ .../gtPlusPlus/core/util/minecraft/FluidUtils.java | 550 ++++++++++++++++ .../core/util/minecraft/InventoryUtils.java | 60 ++ .../gtPlusPlus/core/util/minecraft/ItemUtils.java | 717 +++++++++++++++++++++ .../core/util/minecraft/MaterialUtils.java | 205 ++++++ .../core/util/minecraft/ModularArmourUtils.java | 159 +++++ .../gtPlusPlus/core/util/minecraft/NBTUtils.java | 453 +++++++++++++ .../core/util/minecraft/PlayerUtils.java | 175 +++++ .../core/util/minecraft/RecipeUtils.java | 479 ++++++++++++++ .../core/util/minecraft/ShapelessUtils.java | 55 ++ .../core/util/minecraft/UtilsMining.java | 214 ++++++ .../util/minecraft/gregtech/PollutionUtils.java | 54 ++ .../gregtech/material/MaterialBuilder.java | 254 ++++++++ .../gregtech/recipehandlers/GregtechRecipe.java | 74 +++ .../minecraft/particles/BlockBreakParticles.java | 17 + .../particles/EntityParticleFXMysterious.java | 17 + 17 files changed, 3698 insertions(+) create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/EnchantingUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/EntityUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/InventoryUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/ModularArmourUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/NBTUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/PlayerUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/RecipeUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/ShapelessUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/UtilsMining.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/gregtech/PollutionUtils.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/gregtech/material/MaterialBuilder.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/gregtech/recipehandlers/GregtechRecipe.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/particles/BlockBreakParticles.java create mode 100644 src/Java/gtPlusPlus/core/util/minecraft/particles/EntityParticleFXMysterious.java (limited to 'src/Java/gtPlusPlus/core/util/minecraft') diff --git a/src/Java/gtPlusPlus/core/util/minecraft/EnchantingUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/EnchantingUtils.java new file mode 100644 index 0000000000..2f273d5f7f --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/EnchantingUtils.java @@ -0,0 +1,102 @@ +package gtPlusPlus.core.util.minecraft; + +import gtPlusPlus.api.objects.Logger; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +public class EnchantingUtils { + + + public static final int XP_PER_BOTTLE = 8; + public static final int RATIO = 20; + public static final int LIQUID_PER_XP_BOTTLE = 160; + public static final double RATIO_MOB_ESSENCE_TO_LIQUID_XP = 13.32; + + public static int liquidToXpRatio(final int liquid) { + return liquid / RATIO; + } + + public static int xpToLiquidRatio(final int xp) { + return xp * RATIO; + } + + public static FluidStack getEssenceFromLiquidXp(final int xpAmount){ + if (xpAmount <= 0){ + return null; + } + return getMobEssence((int) (xpAmount*RATIO_MOB_ESSENCE_TO_LIQUID_XP)); + } + + public static FluidStack getLiquidXpFromEssence(final int essenceAmount){ + if (essenceAmount <= 0){ + return null; + } + return getLiquidXP((int) (essenceAmount/RATIO_MOB_ESSENCE_TO_LIQUID_XP)); + } + + public static int getLiquidForLevel(final int level) { + final int xp = getExperienceForLevel(level); + return xpToLiquidRatio(xp); + } + + public static int getLevelForLiquid(final int liquid) { + final int xp = liquidToXpRatio(liquid); + return getLevelForExperience(xp); + } + + public static int getExperienceForLevel(final int level) { + if (level == 0) { + return 0; + } + if ((level > 0) && (level < 16)) { + return level * 17; + } + if ((level > 15) && (level < 31)) { + return (int) (((1.5 * Math.pow(level, 2.0)) - (29.5 * level)) + 360.0); + } + return (int) (((3.5 * Math.pow(level, 2.0)) - (151.5 * level)) + 2220.0); + } + + public static int getXpToNextLevel(final int level) { + final int levelXP = getLevelForExperience(level); + final int nextXP = getExperienceForLevel(level + 1); + return nextXP - levelXP; + } + + public static int getLevelForExperience(final int experience) { + int i; + for (i = 0; getExperienceForLevel(i) <= experience; ++i) { + } + return i - 1; + } + + + + + + + + //Xp Fluids + public static FluidStack getMobEssence(final int amount){ + Logger.WARNING("Trying to get a fluid stack of Mob Essence."); + try { + return FluidRegistry.getFluidStack("mobessence", amount).copy(); + } + catch (final Throwable e){ + return null; + } + + } + + public static FluidStack getLiquidXP(final int amount){ + Logger.WARNING("Trying to get a fluid stack of Liquid XP."); + try { + return FluidRegistry.getFluidStack("xpjuice", amount).copy(); + } + catch (final Throwable e){ + return null; + } + + } + +} diff --git a/src/Java/gtPlusPlus/core/util/minecraft/EntityUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/EntityUtils.java new file mode 100644 index 0000000000..b16089c0de --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/EntityUtils.java @@ -0,0 +1,113 @@ +package gtPlusPlus.core.util.minecraft; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import cpw.mods.fml.common.registry.EntityRegistry; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.api.objects.minecraft.BlockPos; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import ic2.core.IC2Potion; +import ic2.core.item.armor.ItemArmorHazmat; +import net.minecraft.block.Block; +import net.minecraft.entity.*; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.DamageSource; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; + +public class EntityUtils { + + public static void setEntityOnFire(final Entity entity, final int length){ + entity.setFire(length); + } + + public static int getFacingDirection(final Entity entity){ + final int d = MathHelper.floor_double((entity.rotationYaw * 4.0F) / 360 + 0.50) & 3; + return d; + } + + @Deprecated + public static Block findBlockUnderEntityNonBoundingBox(final Entity parEntity){ + final int blockX = MathHelper.floor_double(parEntity.posX); + final int blockY = MathHelper.floor_double(parEntity.posY-0.2D - parEntity.yOffset); + final int blockZ = MathHelper.floor_double(parEntity.posZ); + return parEntity.worldObj.getBlock(blockX, blockY, blockZ); + } + + public static Block findBlockUnderEntity(final Entity parEntity){ + final int blockX = MathHelper.floor_double(parEntity.posX); + final int blockY = MathHelper.floor_double(parEntity.boundingBox.minY)-1; + final int blockZ = MathHelper.floor_double(parEntity.posZ); + return parEntity.worldObj.getBlock(blockX, blockY, blockZ); + } + + public static BlockPos findBlockPosUnderEntity(final Entity parEntity){ + final int blockX = MathHelper.floor_double(parEntity.posX); + final int blockY = MathHelper.floor_double(parEntity.boundingBox.minY)-1; + final int blockZ = MathHelper.floor_double(parEntity.posZ); + return new BlockPos(blockX, blockY, blockZ); + } + + //TODO + public static void registerEntityToBiomeSpawns(final Class classy, final EnumCreatureType EntityType, final BiomeGenBase baseBiomeGen){ + EntityRegistry.addSpawn(classy, 6, 1, 5, EntityType, baseBiomeGen); //change the values to vary the spawn rarity, biome, etc. + } + + public static boolean applyRadiationDamageToEntity(final int stackSize, final int radiationLevel, final World world, final Entity entityHolding){ + if (!world.isRemote){ + if ((radiationLevel > 0) && (entityHolding instanceof EntityLivingBase)) { + final EntityLivingBase entityLiving = (EntityLivingBase) entityHolding; + if (!((EntityPlayer) entityHolding).capabilities.isCreativeMode){ + if (!ItemArmorHazmat.hasCompleteHazmat(entityLiving) && !GT_Utility.isWearingFullRadioHazmat(entityLiving)) { + int duration; + if (entityLiving.getActivePotionEffect(IC2Potion.radiation) != null){ + //Utils.LOG_INFO("t"); + duration = (radiationLevel*5)+entityLiving.getActivePotionEffect(IC2Potion.radiation).getDuration(); + } + else { + //Utils.LOG_INFO("f"); + duration = radiationLevel*30; + } + //IC2Potion.radiation.applyTo(entityLiving, duration, damage * 15); + GT_Utility.applyRadioactivity(entityLiving, radiationLevel, stackSize); + } + } + } + return true; + } + return false; + } + + + /** + * Static Version of the method used in {@code doFireDamage(entity, int)} to save memory. + */ + private static volatile Method dealFireDamage; + + /** + * Reflective Call to do Fire Damage to an entity (Does not set entity on fire though) + */ + public static boolean doFireDamage(Entity entity, int amount){ + if (dealFireDamage == null){ + try { + dealFireDamage = Entity.class.getDeclaredMethod("dealFireDamage", int.class); + dealFireDamage.setAccessible(true); + } + catch (NoSuchMethodException | SecurityException e) {} + } + else { + try { + dealFireDamage.invoke(entity, amount); + } + catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {} + } + return false; + } + + public static void doDamage(Entity entity, DamageSource dmg, int i) { + entity.attackEntityFrom(dmg, i); + } + +} diff --git a/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java new file mode 100644 index 0000000000..3e46b01fc7 --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java @@ -0,0 +1,550 @@ +package gtPlusPlus.core.util.minecraft; + +import gregtech.api.enums.Dyes; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.util.GT_LanguageManager; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.minecraft.FluidGT6; +import gtPlusPlus.core.fluids.GenericFluid; +import gtPlusPlus.core.item.base.BaseItemComponent; +import gtPlusPlus.core.item.base.cell.BaseItemCell; +import gtPlusPlus.core.item.base.cell.BaseItemPlasmaCell; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialStack; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidContainerItem; + +public class FluidUtils { + + public static FluidStack getWater(final int amount){ + return FluidUtils.getFluidStack("water", amount); + } + + public static FluidStack getlava(final int amount){ + return FluidUtils.getFluidStack("lava", amount); + } + + public static FluidStack getMilk(final int amount){ + return FluidUtils.getFluidStack("milk", amount); + } + + public static FluidStack getFluidStack(final String fluidName, final int amount){ + Logger.WARNING("Trying to get a fluid stack of "+fluidName); + try { + return FluidRegistry.getFluidStack(fluidName, amount).copy(); + } + catch (final Throwable e){ + return null; + } + + } + + public static FluidStack getFluidStack(final FluidStack vmoltenFluid, final int fluidAmount) { + Logger.WARNING("Trying to get a fluid stack of "+vmoltenFluid.getFluid().getName()); + try { + return FluidRegistry.getFluidStack(vmoltenFluid.getFluid().getName(), fluidAmount).copy(); + } + catch (final Throwable e){ + return null; + } + } + + public static FluidStack getFluidStack(final Fluid vFluid, final int fluidAmount) { + Logger.WARNING("Trying to get a fluid stack of "+vFluid.getName()); + try { + return FluidRegistry.getFluidStack(vFluid.getName(), fluidAmount).copy(); + } + catch (final Throwable e){ + return null; + } + } + + public static FluidStack[] getFluidStackArray(final String fluidName, final int amount){ + Logger.WARNING("Trying to get a fluid stack of "+fluidName); + try { + final FluidStack[] singleFluid = {FluidRegistry.getFluidStack(fluidName, amount)}; + return singleFluid; + } + catch (final Throwable e){ + return null; + } + + } + + public static FluidStack[] getFluidStackArray(final FluidStack fluidName, final int amount){ + Logger.WARNING("Trying to get a fluid stack of "+fluidName); + try { + final FluidStack[] singleFluid = {FluidRegistry.getFluidStack(fluidName.getLocalizedName(), amount)}; + return singleFluid; + } + catch (final Throwable e){ + return null; + } + + } + + + /** + * @param String displayName + * @param String fluidName + * @param int meltingPointC Temp + * @param short[] rgba + * @param byte state + * States: 0 (Solid), 1 (Fluid), 2(Gas), 3(Plasma) 4(Fuel I think? Don't use.) + * + * @return short[] + */ + public static Fluid generateFluid(final String displayName, final String fluidName, final int tempK, final short[] rgba ,final int aState){ + Fluid generatedFluid = null; + switch (aState) { + case 0: { + generatedFluid = new GenericFluid(displayName, fluidName, 0, 100, tempK, 10000, false, rgba); + break; + } + default: + case 1: + case 4: { + generatedFluid = new GenericFluid(displayName, fluidName, 0, 100, tempK, 1000, false, rgba); + break; + } + case 2: { + generatedFluid = new GenericFluid(displayName, fluidName, 0, -100, tempK, 200, true, rgba); + break; + } + case 3: { + generatedFluid = new GenericFluid(displayName, fluidName, 15, -10000, tempK, 10, true, rgba); + break; + } + } + return generatedFluid; + } + /** + * + * @param String fluidName + * @param int meltingPointC Temp + * @param short[] rgba + * @param byte state + * States: 0 (Solid), 1 (Fluid), 2(Gas), 3(Plasma) 4(Fuel I think? Don't use.) + * + * @return short[] + */ + public static Fluid generateFluid(final Material material ,final int aState){ + final int tempK = material.getMeltingPointC(); + Fluid generatedFluid = null; + switch (aState) { + case 0: { + generatedFluid = new GenericFluid(material, 0, 100, tempK, 10000, false); + break; + } + default: + case 1: + case 4: { + generatedFluid = new GenericFluid(material, 0, 100, tempK, 1000, false); + break; + } + case 2: { + generatedFluid = new GenericFluid(material, 0, -100, tempK, 200, true); + break; + } + case 3: { + generatedFluid = new GenericFluid(material, 15, -10000, tempK, 10, true); + break; + } + } + return generatedFluid; + } + + + public static Fluid addAutogeneratedMoltenFluid(final String materialNameFormatted, final short[] rgba, final int MeltingPoint) { + return addFluid("molten." + materialNameFormatted.toLowerCase(), "molten.autogenerated", "Molten " + materialNameFormatted, null, rgba, 1, (MeltingPoint <= 0L) ? 1000L : MeltingPoint, null, null, 0); + } + + public static Fluid addAutogeneratedMoltenFluid(final GT_Materials aMaterial) { + return addFluid("molten." + aMaterial.name().toLowerCase(), "molten.autogenerated", "Molten " + aMaterial.name(), aMaterial, aMaterial.mMoltenRGBa, 1, (aMaterial.mMeltingPoint <= 0L) ? 1000L : aMaterial.mMeltingPoint, null, null, 0); + } + + public static Fluid addFluid(final String aName, final String aLocalized, final GT_Materials aMaterial, final int aState, final long aTemperatureK) { + return addFluid(aName, aLocalized, aMaterial, aState, aTemperatureK, null, null, 0); + } + + public static Fluid addFluid(final String aName, final String aLocalized, final GT_Materials aMaterial, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { + return addFluid(aName, aName.toLowerCase(), aLocalized, aMaterial, null, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount); + } + + public static Fluid addFluid(String aName, final String aTexture, final String aLocalized, final GT_Materials aMaterial, final short[] aRGBa, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { + aName = Utils.sanitizeString(aName.toLowerCase()); + Fluid rFluid = new FluidGT6(aName, aTexture, (aRGBa != null) ? aRGBa : Dyes._NULL.getRGBA()); + GT_LanguageManager.addStringLocalization(rFluid.getUnlocalizedName(), (aLocalized == null) ? aName : aLocalized); + if (FluidRegistry.registerFluid(rFluid)) { + switch (aState) { + case 0: { + rFluid.setGaseous(false); + rFluid.setViscosity(10000); + break; + } + case 1: + case 4: { + rFluid.setGaseous(false); + rFluid.setViscosity(1000); + break; + } + case 2: { + rFluid.setGaseous(true); + rFluid.setDensity(-100); + rFluid.setViscosity(200); + break; + } + case 3: { + rFluid.setGaseous(true); + rFluid.setDensity(-10000); + rFluid.setViscosity(10); + rFluid.setLuminosity(15); + break; + } + } + } + else { + rFluid = FluidRegistry.getFluid(aName); + } + if ((rFluid.getTemperature() == new Fluid("test").getTemperature()) || (rFluid.getTemperature() <= 0)) { + rFluid.setTemperature((int) (aTemperatureK)); + } + if (aMaterial != null) { + switch (aState) { + case 1: { + aMaterial.mFluid = (rFluid); + break; + } + case 2: { + aMaterial.mGas = (rFluid); + break; + } + case 3: { + aMaterial.mPlasma = (rFluid); + break; + } + } + } + if ((aFullContainer != null) && (aEmptyContainer != null) && !FluidContainerRegistry.registerFluidContainer(new FluidStack(rFluid, aFluidAmount), aFullContainer, aEmptyContainer)) { + GT_Values.RA.addFluidCannerRecipe(aFullContainer, container(aFullContainer, false), null, new FluidStack(rFluid, aFluidAmount)); + } + return rFluid; + } + + public static Fluid addGTFluid(final String aName, final String aLocalized, final short[] aRGBa, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { + return addGTFluid("molten."+aName, "molten.autogenerated", aLocalized, aRGBa, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount); + } + + public static Fluid addGTFluidNonMolten(final String aName, final String aLocalized, final short[] aRGBa, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { + return addGTFluid("fluid."+aName, "fluid.autogenerated", aLocalized, aRGBa, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount); + } + + public static Fluid addGTFluidNoPrefix(final String aName, final String aLocalized, final short[] aRGBa, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { + return addGTFluid(aName, "fluid.autogenerated", aLocalized, aRGBa, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount); + } + + public static Fluid addGTPlasma(final Material aMaterial) { + if (aMaterial.getLocalizedName().toLowerCase().contains("clay") || (aMaterial.getComposites().size()>1) || aMaterial.getLocalizedName().toLowerCase().contains("wrought")){ + return null; + } + Logger.INFO("Generating a "+aMaterial.getLocalizedName()+" Plasma Cell"); + if (aMaterial.vComponentCount != 1){ + Logger.INFO("Compound made from: "); + for (final MaterialStack x : aMaterial.getComposites()){ + Logger.INFO(x.getStackMaterial().getLocalizedName()); + } + Logger.INFO("Material is a composite, not generating plasma."); + return null; + } + + ItemStack temp = null; + //Generate a Cell if we need to + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellPlasma"+aMaterial.getUnlocalizedName(), 1) == null){ + final Item temp2 = new BaseItemPlasmaCell(aMaterial); + temp = aMaterial.getPlasmaCell(1); + } + else { + temp = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellPlasma"+aMaterial.getUnlocalizedName(), 1); + } + if (temp != null){ + return addGTFluid( + "plasma." + Utils.sanitizeString(aMaterial.getLocalizedName().toLowerCase()), + "plasma.autogenerated", + aMaterial.getLocalizedName() + " Plasma", + aMaterial.getRGBA(), + 3, + 10000, + temp, + ItemList.Cell_Empty.get(1L, new Object[0]), + 1000); + } + return null; + } + + public static Fluid addGTFluid(String aName, final String aTexture, final String aLocalized, final short[] aRGBa, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { + aName = Utils.sanitizeString(aName.toLowerCase()); + Fluid rFluid = new FluidGT6(aName, aTexture, (aRGBa != null) ? aRGBa : Dyes._NULL.getRGBA()); + GT_LanguageManager.addStringLocalization(rFluid.getUnlocalizedName(), (aLocalized == null) ? aName : aLocalized); + if (FluidRegistry.registerFluid(rFluid)) { + switch (aState) { + case 0: { + rFluid.setGaseous(false); + rFluid.setViscosity(10000); + break; + } + case 1: + case 4: { + rFluid.setGaseous(false); + rFluid.setViscosity(1000); + break; + } + case 2: { + rFluid.setGaseous(true); + rFluid.setDensity(-100); + rFluid.setViscosity(200); + break; + } + case 3: { + rFluid.setGaseous(true); + rFluid.setDensity(-10000); + rFluid.setViscosity(10); + rFluid.setLuminosity(15); + break; + } + } + } + else { + rFluid = FluidRegistry.getFluid(aName); + } + if ((rFluid.getTemperature() == new Fluid("test").getTemperature()) || (rFluid.getTemperature() <= 0)) { + rFluid.setTemperature((int) (aTemperatureK)); + } + if ((aFullContainer != null) && (aEmptyContainer != null) && !FluidContainerRegistry.registerFluidContainer(new FluidStack(rFluid, aFluidAmount), aFullContainer, aEmptyContainer)) { + GT_Values.RA.addFluidCannerRecipe(aFullContainer, container(aFullContainer, false), null, new FluidStack(rFluid, aFluidAmount)); + } + else { + //Utils.LOG_INFO("Failed creating recipes to fill/empty cells of "+aName+"."); + } + return rFluid; + } + + public static boolean valid(final Object aStack) { + return (aStack != null) && (aStack instanceof ItemStack) && (((ItemStack)aStack).getItem() != null) && (((ItemStack)aStack).stackSize >= 0); + } + + public static boolean invalid(final Object aStack) { + return (aStack == null) || !(aStack instanceof ItemStack) || (((ItemStack)aStack).getItem() == null) || (((ItemStack)aStack).stackSize < 0); + } + + public static boolean equal(final ItemStack aStack1, final ItemStack aStack2) { + return equal(aStack1, aStack2, false); + } + + public static boolean equal(final ItemStack aStack1, final ItemStack aStack2, final boolean aIgnoreNBT) { + return (aStack1 != null) && (aStack2 != null) && equal_(aStack1, aStack2, aIgnoreNBT); + } + + public static boolean equal_(final ItemStack aStack1, final ItemStack aStack2, final boolean aIgnoreNBT) { + return (aStack1.getItem() == aStack2.getItem()) && (aIgnoreNBT || ((aStack1.getTagCompound() == null == (aStack2.getTagCompound() == null)) && ((aStack1.getTagCompound() == null) || aStack1.getTagCompound().equals(aStack2.getTagCompound())))) && ((meta(aStack1) == meta(aStack2)) || (meta(aStack1) == 32767) || (meta(aStack2) == 32767)); + } + + public static ItemStack copy(final Object... aStacks) { + for (final Object tStack : aStacks) { + if (valid(tStack)) { + return ((ItemStack)tStack).copy(); + } + } + return null; + } + + public static ItemStack copyMeta(final long aMetaData, final Object... aStacks) { + final ItemStack rStack = copy(aStacks); + if (invalid(rStack)) { + return null; + } + return meta(rStack, aMetaData); + } + + public static short meta(final ItemStack aStack) { + return (short)Items.feather.getDamage(aStack); + } + + public static ItemStack meta(final ItemStack aStack, final long aMeta) { + Items.feather.setDamage(aStack, (short)aMeta); + return aStack; + } + + public static ItemStack amount(final long aAmount, final Object... aStacks) { + final ItemStack rStack = copy(aStacks); + if (invalid(rStack)) { + return null; + } + rStack.stackSize = (int)aAmount; + return rStack; + } + + public static ItemStack container(final ItemStack aStack, final boolean aCheckIFluidContainerItems) { + if (invalid(aStack)) { + return null; + } + if (aStack.getItem().hasContainerItem(aStack)) { + return aStack.getItem().getContainerItem(aStack); + } + if (equal(aStack, ItemList.Cell_Empty.get(1), true)) { + return null; + } + if (aCheckIFluidContainerItems && (aStack.getItem() instanceof IFluidContainerItem) && (((IFluidContainerItem)aStack.getItem()).getCapacity(aStack) > 0)) { + final ItemStack tStack = amount(1L, aStack); + ((IFluidContainerItem)aStack.getItem()).drain(tStack, Integer.MAX_VALUE, true); + if (!equal(aStack, tStack)) { + return tStack; + } + return null; + } + if (equal(aStack, ItemList.IC2_ForgeHammer.get(1)) || equal(aStack, ItemList.IC2_WireCutter.get(1))) { + return copyMeta(meta(aStack) + 1, aStack); + } + return null; + } + + public static ItemStack container(final ItemStack aStack, final boolean aCheckIFluidContainerItems, final int aStacksize) { + return amount(aStacksize, container(aStack, aCheckIFluidContainerItems)); + } + + public final static Fluid generateFluid(final String unlocalizedName, final String localizedName, final int MeltingPoint, final short[] RGBA){ + if ((FluidUtils.getFluidStack("molten"+"."+unlocalizedName.toLowerCase(), 1) == null) && (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dust"+Utils.sanitizeString(localizedName), 1) != null)){ + Logger.WARNING("Generating our own fluid."); + + //Generate a Cell if we need to + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+unlocalizedName, 1) == null){ + @SuppressWarnings("unused") + final + Item temp = new BaseItemComponent(unlocalizedName, localizedName, RGBA); + } + + final Fluid gtFluid = FluidUtils.addGTFluid( + unlocalizedName, + "Molten "+localizedName, + RGBA, + 4, + MeltingPoint, + ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+unlocalizedName, 1), + ItemList.Cell_Empty.get(1L, new Object[0]), + 1000); + + //Disable this, not sure why it exists //TODO + /*GT_Values.RA.addFluidExtractionRecipe( + ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dust"+Utils.sanitizeString(localizedName), 1), //Input + null, //Input 2 + FluidUtils.getFluidStack(gtFluid, 144), //Fluid Output + 0, //Chance + 1*20, //Duration + 16 //Eu Tick + );*/ + + + return gtFluid; + } + Logger.INFO("FLUID GENERATION FAILED FOR "+localizedName); + return null; + } + + public final static Fluid generateFluidNonMolten(final String unlocalizedName, final String localizedName, final int MeltingPoint, final short[] RGBA, final ItemStack dustStack, final ItemStack dustStack2){ + return generateFluidNonMolten(unlocalizedName, localizedName, MeltingPoint, RGBA, dustStack, dustStack2, 144); + } + + public final static Fluid generateFluidNonMolten(final String unlocalizedName, final String localizedName, final int MeltingPoint, final short[] RGBA, ItemStack dustStack, final ItemStack dustStack2, final int amountPerItem){ + if (dustStack == null){ + dustStack = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dust"+Utils.sanitizeString(localizedName), 1); + } + if ((FluidUtils.getFluidStack(unlocalizedName.toLowerCase(), 1) == null)/* && ((dustStack != null) || (dustStack2 != null))*/){ + Logger.WARNING("Generating our own fluid."); + + //Generate a Cell if we need to + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+unlocalizedName, 1) == null){ + @SuppressWarnings("unused") + final + Item temp = new BaseItemComponent(unlocalizedName, localizedName, RGBA); + } + + final Fluid gtFluid = FluidUtils.addGTFluidNonMolten( + unlocalizedName, + localizedName, + RGBA, + 4, + MeltingPoint, + ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+unlocalizedName, 1), + ItemList.Cell_Empty.get(1L, new Object[0]), + 1000); + + if (dustStack != null){ + GT_Values.RA.addFluidExtractionRecipe( + dustStack, //Input + null, //Input 2 + FluidUtils.getFluidStack(gtFluid, amountPerItem), //Fluid Output + 0, //Chance + 1*20, //Duration + 16 //Eu Tick + ); + } + if (dustStack2 != null){ + GT_Values.RA.addFluidExtractionRecipe( + dustStack2, //Input + null, //Input 2 + FluidUtils.getFluidStack(gtFluid, amountPerItem), //Fluid Output + 0, //Chance + 1*20, //Duration + 16 //Eu Tick + ); + } + + return gtFluid; + } + Logger.INFO("FLUID GENERATION FAILED FOR "+localizedName); + return null; + } + + public final static Fluid generateFluidNoPrefix(final String unlocalizedName, final String localizedName, final int MeltingPoint, final short[] RGBA){ + Fluid gtFluid; + if (FluidUtils.getFluidStack(unlocalizedName.toLowerCase(), 1) == null){ + Logger.WARNING("Generating our own fluid."); + gtFluid = FluidUtils.addGTFluidNoPrefix( + unlocalizedName, + localizedName, + RGBA, + 4, + MeltingPoint, + ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+unlocalizedName, 1), + ItemList.Cell_Empty.get(1L, new Object[0]), + 1000); + } + else { + gtFluid = FluidUtils.getFluidStack(unlocalizedName.toLowerCase(), 1).getFluid(); + } + //Generate a Cell if we need to + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+unlocalizedName, 1) == null){ + new BaseItemCell(unlocalizedName, localizedName, RGBA, gtFluid); + } + return gtFluid; + } + + + public static FluidStack getMobEssence(final int amount){ + return EnchantingUtils.getMobEssence(amount); + } + + public static FluidStack getLiquidXP(final int amount){ + return EnchantingUtils.getLiquidXP(amount); + } + + +} diff --git a/src/Java/gtPlusPlus/core/util/minecraft/InventoryUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/InventoryUtils.java new file mode 100644 index 0000000000..0d4394d773 --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/InventoryUtils.java @@ -0,0 +1,60 @@ +package gtPlusPlus.core.util.minecraft; + +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; + +public class InventoryUtils { + + private final static Random mRandom = new Random(); + + public static void dropInventoryItems(World world, int x, int y, int z, Block block){ + Object tileentity = world.getTileEntity(x, y, z); + + if (tileentity != null) + { + for (int i1 = 0; i1 < ((IInventory) tileentity).getSizeInventory(); ++i1) + { + ItemStack itemstack = ((IInventory) tileentity).getStackInSlot(i1); + + if (itemstack != null) + { + float f = mRandom.nextFloat() * 0.8F + 0.1F; + float f1 = mRandom.nextFloat() * 0.8F + 0.1F; + EntityItem entityitem; + + for (float f2 = mRandom.nextFloat() * 0.8F + 0.1F; itemstack.stackSize > 0; world.spawnEntityInWorld(entityitem)) + { + int j1 = mRandom.nextInt(21) + 10; + + if (j1 > itemstack.stackSize) + { + j1 = itemstack.stackSize; + } + + itemstack.stackSize -= j1; + entityitem = new EntityItem(world, x + f, y + f1, z + f2, new ItemStack(itemstack.getItem(), j1, itemstack.getItemDamage())); + float f3 = 0.05F; + entityitem.motionX = (float)mRandom.nextGaussian() * f3; + entityitem.motionY = (float)mRandom.nextGaussian() * f3 + 0.2F; + entityitem.motionZ = (float)mRandom.nextGaussian() * f3; + + if (itemstack.hasTagCompound()) + { + entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy()); + } + } + } + } + + world.func_147453_f(x, y, z, block); + } + + } + +} diff --git a/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java new file mode 100644 index 0000000000..06176751eb --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java @@ -0,0 +1,717 @@ +package gtPlusPlus.core.util.minecraft; + +import java.util.ArrayList; +import java.util.List; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.common.registry.GameRegistry.UniqueIdentifier; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.Pair; +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.item.base.BasicSpawnEgg; +import gtPlusPlus.core.item.base.dusts.BaseItemDust; +import gtPlusPlus.core.item.base.dusts.BaseItemDustUnique; +import gtPlusPlus.core.item.base.dusts.decimal.BaseItemCentidust; +import gtPlusPlus.core.item.base.dusts.decimal.BaseItemDecidust; +import gtPlusPlus.core.item.base.plates.BaseItemPlate_OLD; +import gtPlusPlus.core.item.tool.staballoy.MultiPickaxeBase; +import gtPlusPlus.core.item.tool.staballoy.MultiSpadeBase; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.xmod.gregtech.loaders.RecipeGen_DustGeneration; +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.Item.ToolMaterial; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +public class ItemUtils { + + public static ItemStack getSimpleStack(final Item x){ + return getSimpleStack(x, 1); + } + public static ItemStack getSimpleStack(final Block x){ + return getSimpleStack(Item.getItemFromBlock(x), 1); + } + public static ItemStack getSimpleStack(final Block x, final int i){ + return getSimpleStack(Item.getItemFromBlock(x), i); + } + public static ItemStack getSimpleStack(final Item x, final int i){ + try { + final ItemStack r = new ItemStack(x, i); + return r.copy(); + } catch(final Throwable e){ + return null; + } + } + public static ItemStack getSimpleStack(final ItemStack x, final int i){ + try { + final ItemStack r = x.copy(); + r.stackSize = i; + return r; + } catch(final Throwable e){ + return null; + } + } + + public static final int WILDCARD_VALUE = Short.MAX_VALUE; + public static ItemStack getWildcardStack(final Item x){ + final ItemStack y = new ItemStack(x, 1, WILDCARD_VALUE); + return y; + } + + + public static ItemStack getIC2Cell(final String S){ + final ItemStack moreTemp = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cell"+S, 1); + + if (moreTemp == null){ + final int cellID = 0; + final ItemStack temp =GT_ModHandler.getModItem("IC2", "itemCellEmpty", 1L, cellID); + return temp != null ? temp : null; + } + + return moreTemp; + } + + public static ItemStack getIC2Cell(final int meta){ + final ItemStack temp = GT_ModHandler.getModItem("IC2", "itemCellEmpty", 1L, meta); + return temp != null ? temp : null; + } + + public static ItemStack getEmptyCell(){ + return getEmptyCell(1); + } + + public static ItemStack getEmptyCell(int i){ + final ItemStack temp = GT_ModHandler.getModItem("IC2", "itemCellEmpty", i, 0); + return temp != null ? temp : null; + } + + public static void getItemForOreDict(final String FQRN, final String oreDictName, final String itemName, final int meta){ + try { + Item em = null; + final Item em1 = getItem(FQRN); + //Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); + if (em1 != null){ + em = em1; + } + if (em != null){ + + final ItemStack metaStack = new ItemStack(em,1,meta); + GT_OreDictUnificator.registerOre(oreDictName, metaStack); + + /*ItemStack itemStackWithMeta = new ItemStack(em,1,meta); + GT_OreDictUnificator.registerOre(oreDictName, new ItemStack(itemStackWithMeta.getItem()));*/ + } + } catch (final NullPointerException e) { + Logger.ERROR(itemName+" not found. [NULL]"); + } + } + + public static void addItemToOreDictionary(final ItemStack stack, final String oreDictName){ + try { + GT_OreDictUnificator.registerOre(oreDictName, stack); + } catch (final NullPointerException e) { + Logger.ERROR(stack.getDisplayName()+" not registered. [NULL]"); + } + } + + public static ItemStack getItemStackWithMeta(final boolean MOD, final String FQRN, final String itemName, final int meta, final int itemstackSize){ + if (MOD){ + try { + Item em = null; + final Item em1 = getItem(FQRN); + //Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); + if (em1 != null){ + if (null == em){ + em = em1; + } + if (em != null){ + final ItemStack metaStack = new ItemStack(em,itemstackSize,meta); + return metaStack; + } + } + return null; + } catch (final NullPointerException e) { + Logger.ERROR(itemName+" not found. [NULL]"); + return null; + } + } + return null; + } + + public static ItemStack simpleMetaStack(final String FQRN, final int meta, final int itemstackSize){ + try { + Item em = null; + final Item em1 = getItem(FQRN); + //Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); + if (em1 != null){ + if (null == em){ + em = em1; + } + if (em != null){ + final ItemStack metaStack = new ItemStack(em,itemstackSize,meta); + return metaStack; + } + } + return null; + } catch (final NullPointerException e) { + Logger.ERROR(FQRN+" not found. [NULL]"); + return null; + } + } + + @SuppressWarnings("unused") + public static ItemStack simpleMetaStack(final Item item, final int meta, final int size){ + try { + if (item == null){ + return null; + } + Item em = item; + final Item em1 = item; + Logger.WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); + if (em1 != null){ + if (null == em){ + em = em1; + } + if (em != null){ + final ItemStack metaStack = new ItemStack(em,size,meta); + return metaStack; + } + } + return null; + } catch (final NullPointerException e) { + //Utils.LOG_ERROR(item.getUnlocalizedName()+" not found. [NULL]"); + return null; + } + } + + public static ItemStack simpleMetaStack(final Block block, final int meta, final int size) { + return simpleMetaStack(Item.getItemFromBlock(block), meta, size); + } + + public static ItemStack getCorrectStacktype(final String fqrn, final int stackSize){ + final String oreDict = "ore:"; + ItemStack temp; + if (fqrn.toLowerCase().contains(oreDict.toLowerCase())){ + final String sanitizedName = fqrn.replace(oreDict, ""); + temp = ItemUtils.getItemStack(sanitizedName, stackSize); + return temp; + } + final String[] fqrnSplit = fqrn.split(":"); + String temp1; + String temp2; + temp1 = fqrnSplit[1]; + if (fqrnSplit.length < 3){temp2 = "0";} + else {temp2 = fqrnSplit[2];} + temp = ItemUtils.getItemStackWithMeta(LoadedMods.MiscUtils, fqrn, temp1, Integer.parseInt(temp2), stackSize); + return temp; + } + + public static ItemStack getCorrectStacktype(final Object item_Input, final int stackSize) { + if (item_Input instanceof String){ + return getItemStackOfAmountFromOreDictNoBroken((String) item_Input, stackSize); + } + else if (item_Input instanceof ItemStack){ + return (ItemStack) item_Input; + } + return null; + } + + public static Item getItem(final String fqrn) // fqrn = fully qualified resource name + { + final String[] fqrnSplit = fqrn.split(":"); + return GameRegistry.findItem(fqrnSplit[0], fqrnSplit[1]); + } + + public static ItemStack getItemStack(final String fqrn, final int Size) // fqrn = fully qualified resource name + { + final String[] fqrnSplit = fqrn.split(":"); + return GameRegistry.findItemStack(fqrnSplit[0], fqrnSplit[1], Size); + } + + public static void generateSpawnEgg(final String entityModID, final String parSpawnName, final int colourEgg, final int colourOverlay){ + final Item itemSpawnEgg = new BasicSpawnEgg(entityModID, parSpawnName, colourEgg, colourOverlay).setUnlocalizedName("spawn_egg_"+parSpawnName.toLowerCase()).setTextureName(CORE.MODID+":spawn_egg"); + GameRegistry.registerItem(itemSpawnEgg, "spawnEgg"+parSpawnName); + } + + + public static ItemStack[] validItemsForOreDict(final String oredictName){ + final List validNames = MaterialUtils.oreDictValuesForEntry(oredictName); + final ItemStack[] inputs = new ItemStack[validNames.size()]; + for (int i=0; i oreDictList = OreDictionary.getOres(mTemp); + if (!oreDictList.isEmpty()){ + final ItemStack returnValue = oreDictList.get(0).copy(); + returnValue.stackSize = amount; + return returnValue; + } + return getSimpleStack(ModItems.AAA_Broken, amount); + } + + public static ItemStack getItemStackOfAmountFromOreDictNoBroken(final String oredictName, final int amount){ + if (CORE.DEBUG){ + Logger.WARNING("Looking up: "+oredictName+" - from method: "+ReflectionUtils.getMethodName(1)); + Logger.WARNING("Looking up: "+oredictName+" - from method: "+ReflectionUtils.getMethodName(2)); + Logger.WARNING("Looking up: "+oredictName+" - from method: "+ReflectionUtils.getMethodName(3)); + Logger.WARNING("Looking up: "+oredictName+" - from method: "+ReflectionUtils.getMethodName(4)); + Logger.WARNING("Looking up: "+oredictName+" - from method: "+ReflectionUtils.getMethodName(5)); + } + try{ + + //Adds a check to grab dusts using GT methodology if possible. + ItemStack returnValue = null; + if (oredictName.toLowerCase().contains("dust")){ + final String MaterialName = oredictName.toLowerCase().replace("dust", ""); + final Materials m = Materials.get(MaterialName); + returnValue = getGregtechDust(m, amount); + if (returnValue != null){ + return returnValue; + } + } + + if (returnValue == null){ + returnValue = getItemStackOfAmountFromOreDict(oredictName, amount); + if (returnValue != null){ + if ((returnValue.getItem().getClass() != ModItems.AAA_Broken.getClass()) || (returnValue.getItem() != ModItems.AAA_Broken)){ + return returnValue.copy(); + } + } + } + Logger.WARNING(oredictName+" was not valid."); + return null; + } + catch (final Throwable t){ + return null; + } + } + + public static ItemStack getGregtechDust(final Materials material, final int amount){ + final ItemStack returnValue = GT_OreDictUnificator.get(OrePrefixes.dust, material, 1L); + if (returnValue != null){ + if ((returnValue.getItem().getClass() != ModItems.AAA_Broken.getClass()) || (returnValue.getItem() != ModItems.AAA_Broken)){ + return returnValue.copy(); + } + } + Logger.WARNING(material+" was not valid."); + return null; + } + + public static Item[] generateDusts(final String unlocalizedName, final String materialName, final int materialTier, final Material matInfo, final int Colour){ + final int radioactive = getRadioactivityLevel(materialName); + final Item[] output = { + new BaseItemDust("itemDust"+unlocalizedName, materialName, matInfo, Colour, "Dust", materialTier, radioactive), + new BaseItemDust("itemDustSmall"+unlocalizedName, materialName, matInfo, Colour, "Small", materialTier, radioactive), + new BaseItemDust("itemDustTiny"+unlocalizedName, materialName, matInfo, Colour, "Tiny", materialTier, radioactive)}; + return output; + } + + //NullFormula + public static Item[] generateSpecialUseDusts(final String unlocalizedName, final String materialName, final int Colour){ + return generateSpecialUseDusts(unlocalizedName, materialName, "NullFormula", Colour); + } + + public static Item[] generateSpecialUseDusts(final String unlocalizedName, final String materialName, String mChemForm, final int Colour){ + final Item[] output = { + new BaseItemDustUnique("itemDust"+unlocalizedName, materialName, mChemForm, Colour, "Dust"), + new BaseItemDustUnique("itemDustSmall"+unlocalizedName, materialName, mChemForm, Colour, "Small"), + new BaseItemDustUnique("itemDustTiny"+unlocalizedName, materialName, mChemForm, Colour, "Tiny")}; + return output; + } + + public static Item generateSpecialUsePlate(final String internalName, final String displayName, final short[] rgb, final int radioactivity){ + return generateSpecialUsePlate(internalName, displayName, Utils.rgbtoHexValue(rgb[0], rgb[1], rgb[2]), radioactivity); + } + + public static Item generateSpecialUsePlate(final String internalName, final String displayName, final String mFormula, final short[] rgb, final int radioactivity){ + return generateSpecialUsePlate(internalName, displayName, mFormula, Utils.rgbtoHexValue(rgb[0], rgb[1], rgb[2]), radioactivity); + } + + public static Item generateSpecialUsePlate(final String internalName, final String displayName, final int rgb, final int radioactivity){ + return new BaseItemPlate_OLD(internalName, displayName, rgb, radioactivity); + } + + public static Item generateSpecialUsePlate(final String internalName, final String displayName, final String mFormula, final int rgb, final int radioactivity){ + return new BaseItemPlate_OLD(internalName, displayName, mFormula, rgb, radioactivity); + } + + public static Item[] generateSpecialUseDusts(final Material material, final boolean onlyLargeDust){ + final String materialName = material.getLocalizedName(); + final String unlocalizedName = Utils.sanitizeString(materialName); + final int Colour = material.getRgbAsHex(); + Item[] output = null; + if (onlyLargeDust == false){ + output = new Item[]{ + new BaseItemDustUnique("itemDust"+unlocalizedName, materialName, Colour, "Dust"), + new BaseItemDustUnique("itemDustSmall"+unlocalizedName, materialName, Colour, "Small"), + new BaseItemDustUnique("itemDustTiny"+unlocalizedName, materialName, Colour, "Tiny")}; + } else{ + output = new Item[]{ + new BaseItemDustUnique("itemDust"+unlocalizedName, materialName, Colour, "Dust") + }; + } + + RecipeGen_DustGeneration.generateRecipes(material); + + return output; + } + + public static MultiPickaxeBase generateMultiPick(final boolean GT_Durability, final Materials material){ + final ToolMaterial customMaterial = Utils.generateToolMaterialFromGT(material); + final int enchantLevel = material.mEnchantmentToolsLevel; + final Object enchant = new Pair(material.mEnchantmentTools, enchantLevel); + return generateMultiPick(GT_Durability, customMaterial, material.mDefaultLocalName, material.mDurability, material.mRGBa, enchant); + } + + public static MultiPickaxeBase generateMultiPick(final Material material){ + final ToolMaterial customMaterial = Utils.generateToolMaterial(material); + return generateMultiPick(true, customMaterial, material.getLocalizedName(), (int) material.vDurability, material.getRGBA(), null); + } + + public static MultiPickaxeBase generateMultiPick(final boolean GT_Durability, final ToolMaterial customMaterial, final String name, final int durability, final short[] rgba, final Object enchantment){ + Logger.WARNING("Generating a Multi-Pick out of "+name); + final short[] rgb = rgba; + int dur = customMaterial.getMaxUses(); + Logger.WARNING("Determined durability for "+name+" is "+dur); + if (GT_Durability){ + dur = durability*100; + Logger.WARNING("Using gregtech durability value, "+name+" is now "+dur+"."); + } + else if (dur <= 0){ + dur = durability; + Logger.WARNING("Determined durability too low, "+name+" is now "+dur+" based on the GT material durability."); + } + if (dur <= 0){ + Logger.WARNING("Still too low, "+name+" will now go unused."); + return null; + } + + Object enchant; + if (enchantment != null){ + if (enchantment instanceof Pair){ + enchant = enchantment; + } + } + else { + enchant = null; + } + + final MultiPickaxeBase MP_Redstone = new MultiPickaxeBase( + name+" Multipick", + (customMaterial), + dur, + Utils.rgbtoHexValue(rgb[0],rgb[1],rgb[2]), + enchantment); + + if (MP_Redstone.isValid){ + return MP_Redstone; + } + Logger.WARNING("Pickaxe was not valid."); + return null; + } + + + + + + + public static MultiSpadeBase generateMultiShovel(final boolean GT_Durability, final Materials material){ + final ToolMaterial customMaterial = Utils.generateToolMaterialFromGT(material); + return generateMultiShovel(GT_Durability, customMaterial, material.mDefaultLocalName, material.mDurability, material.mRGBa); + } + + public static MultiSpadeBase generateMultiShovel(final Material material){ + final ToolMaterial customMaterial = Utils.generateToolMaterial(material); + return generateMultiShovel(true, customMaterial, material.getLocalizedName(), (int) material.vDurability, material.getRGBA()); + } + + public static MultiSpadeBase generateMultiShovel(final boolean GT_Durability, final ToolMaterial customMaterial, final String name, final int durability, final short[] rgba){ + Logger.WARNING("Generating a Multi-Spade out of "+name); + final short[] rgb = rgba; + int dur = customMaterial.getMaxUses(); + Logger.WARNING("Determined durability for "+name+" is "+dur); + if (GT_Durability){ + dur = durability*100; + Logger.WARNING("Using gregtech durability value, "+name+" is now "+dur+"."); + } + else if (dur <= 0){ + dur = durability; + Logger.WARNING("Determined durability too low, "+name+" is now "+dur+" based on the GT material durability."); + } + if (dur <= 0){ + Logger.WARNING("Still too low, "+name+" will now go unused."); + return null; + } + final MultiSpadeBase MP_Redstone = new MultiSpadeBase( + name+" Multispade", + (customMaterial), + dur, + Utils.rgbtoHexValue(rgb[0],rgb[1],rgb[2]) + ); + + if (MP_Redstone.isValid){ + return MP_Redstone; + } + return null; + } + + + + + + + + + + + + + public static BaseItemDecidust generateDecidust(final Materials material){ + if (GT_OreDictUnificator.get(OrePrefixes.dust, material, 1L) != null){ + final Material placeholder = MaterialUtils.generateMaterialFromGtENUM(material); + if (placeholder != null) { + generateDecidust(placeholder); + } + } + return null; + } + + public static BaseItemDecidust generateDecidust(final Material material){ + if ((material.getDust(1) != null) && MaterialUtils.hasValidRGBA(material.getRGBA())){ + final BaseItemDecidust Decidust = new BaseItemDecidust(material); + return Decidust; + } + return null; + } + + public static BaseItemCentidust generateCentidust(final Materials material){ + if (GT_OreDictUnificator.get(OrePrefixes.dust, material, 1L) != null){ + final Material placeholder = MaterialUtils.generateMaterialFromGtENUM(material); + if (placeholder != null) { + generateCentidust(placeholder); + } + } + return null; + } + + public static BaseItemCentidust generateCentidust(final Material material){ + if ((material.getDust(1) != null) && MaterialUtils.hasValidRGBA(material.getRGBA())){ + final BaseItemCentidust Centidust = new BaseItemCentidust(material); + return Centidust; + } + return null; + } + + public static boolean isRadioactive(final String materialName){ + int sRadiation = 0; + if (materialName.toLowerCase().contains("uranium")){ + sRadiation = 2; + } + else if (materialName.toLowerCase().contains("plutonium")){ + sRadiation = 4; + } + else if (materialName.toLowerCase().contains("thorium")){ + sRadiation = 1; + } + if (sRadiation >= 1){ + return true; + } + return false; + } + + public static int getRadioactivityLevel(final String materialName){ + int sRadiation = 0; + if (materialName.toLowerCase().contains("uranium")){ + sRadiation = 2; + } + else if (materialName.toLowerCase().contains("plutonium")){ + sRadiation = 4; + } + else if (materialName.toLowerCase().contains("thorium")){ + sRadiation = 1; + } + return sRadiation; + } + + public static String getArrayStackNames(final ItemStack[] aStack){ + String itemNames = "Item Array: "; + for (final ItemStack alph : aStack){ + + if (alph != null){ + final String temp = itemNames; + itemNames = temp + ", " + alph.getDisplayName() + " x" + alph.stackSize; + } + else { + final String temp = itemNames; + itemNames = temp + ", " + "null" + " x" + "0"; + } + } + return itemNames; + + } + + public static String[] getArrayStackNamesAsArray(final ItemStack[] aStack){ + final String[] itemNames = {}; + int arpos = 0; + for (final ItemStack alph : aStack){ + itemNames[arpos] = alph.getDisplayName(); + arpos++; + } + return itemNames; + + } + + public static String getFluidArrayStackNames(final FluidStack[] aStack){ + String itemNames = "Fluid Array: "; + for (final FluidStack alph : aStack){ + final String temp = itemNames; + itemNames = temp + ", " + alph.getFluid().getName() + " x" + alph.amount; + } + return itemNames; + + } + + public static ItemStack getGregtechCircuit(final int Meta){ + return ItemUtils.getItemStackWithMeta(LoadedMods.Gregtech, "gregtech:gt.integrated_circuit", "Gregtech Circuit", Meta, 0); + } + public static ItemStack[] getBlockDrops(final ArrayList blockDrops) { + if (blockDrops == null){ + return null; + } + if (blockDrops.isEmpty()){ + return null; + } + final ItemStack[] outputs = new ItemStack[blockDrops.size()]; + short forCounter = 0; + for (final ItemStack I : blockDrops){ + outputs[forCounter++] = I; + } + return outputs; + } + + private static String getModId(final Item item) { + try { + final GameRegistry.UniqueIdentifier id = GameRegistry.findUniqueIdentifierFor(item); + final String modname = (id.modId == null ? id.name : id.modId); + return (id == null) || id.modId.equals("") ? "minecraft" : modname; + } catch (final Throwable t){ + try { + final UniqueIdentifier t2 = GameRegistry.findUniqueIdentifierFor(Block.getBlockFromItem(item)); + final String modname = (t2.modId == null ? t2.name : t2.modId); + return (t2 == null) || t2.modId.equals("") ? "minecraft" : modname; + } + catch (final Throwable t3){ + return "bad modid"; + } + } + } + + public static String getModId(final ItemStack key) { + return getModId(key.getItem()); + } + + //Take 2 - GT/GT++ Dusts + public static ItemStack getGregtechDust(final String oredictName, final int amount){ + final ArrayList oreDictList = OreDictionary.getOres(oredictName); + if (!oreDictList.isEmpty()){ + ItemStack returnvalue; + for (int xrc=0;xrc oreDictList = OreDictionary.getOres(oredictName); + if (!oreDictList.isEmpty()){ + ItemStack returnvalue; + for (int xrc=0;xrc oreDictList = OreDictionary.getOres(oredictname); + if (!oreDictList.isEmpty()){ + final ItemStack[] returnValues = new ItemStack[oreDictList.size()]; + for (int i=0;i0 ? returnValues : null; + } + else { + return null; + } + } + + +} diff --git a/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java new file mode 100644 index 0000000000..0af72661e9 --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java @@ -0,0 +1,205 @@ +package gtPlusPlus.core.util.minecraft; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import java.util.stream.Collectors; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import gregtech.api.enums.*; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.data.EnumUtils; +import gtPlusPlus.core.util.data.StringUtils; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +public class MaterialUtils { + + public static short firstID = 791; + + @SuppressWarnings({ "rawtypes", "unused" }) + private static Class[][] commonTypes = +{{Materials.class, int.class, TextureSet.class, float.class, int.class, + int.class, int.class, int.class, int.class, int.class, int.class, + String.class, int.class, int.class, int.class, int.class, boolean.class, + boolean.class, int.class, int.class, int.class, Dyes.class, int.class, + List.class , List.class}}; + + public static List oreDictValuesForEntry(final String oredictName){ + List oredictItemNames; + if(OreDictionary.doesOreNameExist(oredictName)){ + final List oredictItems = OreDictionary.getOres(oredictName); + oredictItemNames = oredictItems; + return oredictItemNames; + } + return null; + } + + public static Material generateMaterialFromGtENUM(final Materials material){ + @SuppressWarnings("deprecation") + String name = material.name(); + final short[] rgba = material.mRGBa; + final int melting = material.mMeltingPoint; + final int boiling = material.mBlastFurnaceTemp; + final long protons = material.getProtons(); + final long neutrons = material.getNeutrons(); + final boolean blastFurnace = material.mBlastFurnaceRequired; + final TextureSet iconSet = material.mIconSet; + final int durability = material.mDurability; + boolean mGenerateCell = false; + MaterialState materialState; + String chemicalFormula = StringUtils.subscript(Utils.sanitizeString(material.mChemicalFormula)); + final Element element = material.mElement; + int radioactivity = 0; + if (material.isRadioactive()){ + radioactivity = 1; + } + + //Weird Blacklist of Bad Chemical Strings + if (material.mElement == Element.Pb || material.mElement == Element.Na || material.mElement == Element.Ar){ + chemicalFormula = StringUtils.subscript(Utils.sanitizeString(material.mElement.name())); + } + + //Determine default state + Logger.MATERIALS("[Debug] Setting State of GT generated material. "+material.mDefaultLocalName); + if (material.getMolten(1) != null || material.getSolid(1) != null){ + materialState = MaterialState.SOLID; + Logger.MATERIALS("[Debug] Molten or Solid was not null."); + if (material.getMolten(1) == null && material.getSolid(1) != null){ + Logger.MATERIALS("[Debug] Molten is Null, Solid is not. Enabling cell generation."); + mGenerateCell = true; + } + else if (material.getMolten(1) != null && material.getSolid(1) == null){ + Logger.MATERIALS("[Debug] Molten is not Null, Solid is null. Not enabling cell generation."); + //mGenerateCell = true; + } + Logger.MATERIALS("[Debug] State set as solid."); + } + else if (material.getFluid(1) != null){ + Logger.MATERIALS("[Debug] State set as liquid."); + materialState = MaterialState.LIQUID; + } + else if (material.getGas(1) != null){ + Logger.MATERIALS("[Debug] State set as gas."); + materialState = MaterialState.GAS; + }/* + else if (material.getPlasma(1) != null){ + Logger.MATERIALS("[Debug] State set as plasma."); + materialState = MaterialState.PLASMA; + }*/ + else { + Logger.MATERIALS("[Debug] State set as solid."); + materialState = MaterialState.SOLID; + } + + + if (name.toLowerCase().contains("infused")){ + final String tempname = name.substring(7, name.length()); + name = "Infused " + tempname; + } + if (hasValidRGBA(rgba) || (element == Element.H) || ((material == Materials.InfusedAir) || (material == Materials.InfusedFire) || (material == Materials.InfusedEarth) || (material == Materials.InfusedWater))){ + //ModItems.itemBaseDecidust = UtilsItems.generateDecidust(material); + //ModItems.itemBaseCentidust = UtilsItems.generateCentidust(material); + return new Material(name, materialState,iconSet, durability, rgba, melting, boiling, protons, neutrons, blastFurnace, chemicalFormula, radioactivity, mGenerateCell); + } + else { + Logger.DEBUG_MATERIALS("Failed to generate GT++ material instance for "+material.name() +" | Valid RGB? "+(hasValidRGBA(rgba))); + } + return null; + + } + + public static Material generateQuickMaterial(final String materialName, final MaterialState defaultState, final short[] colour, final int sRadioactivity) { + final Material temp = new Material( + materialName, + defaultState, + 0, //Durability + colour, + 1000, //melting + 3000, //boiling + 50, //Protons + 50, //Neutrons + false, + "", + sRadioactivity); + return temp; + } + + public static boolean hasValidRGBA(final short[] rgba){ + if (rgba == null || rgba.length < 3 || rgba.length > 4){ + return false; + } + return true; + } + + public static int getTierOfMaterial(final int M){ + if ((M >= 0) && (M <= 1000)){ + return 1; + } + else if((M >= 1001) && (M <= 2000)){ + return 2; + } + else if((M >= 2001) && (M <= 3000)){ + return 3; + } + else if((M >= 3001) && (M <= 4000)){ + return 4; + } + else if((M >= 4001) && (M <= 5000)){ + return 5; + } + else if((M >= 5